Move tool.tool_version to tool.lineage

This change makes it obvious that a Lineage object will be returned.

Also removes two unused methods from ToolLineageVersion.

lib/galaxy/tools/__init__.py

@@ -414,6 +414,7 @@ class Tool( object, Dictifiable ):
         self.guid = guid
         self.old_id = None
         self.version = None
+        self._lineage = None
         self.dependencies = []
         # populate toolshed repository info, if available
         self.populate_tool_shed_info()
@@ -438,17 +439,17 @@ class Tool( object, Dictifiable ):
         return self.app.model.context
 
     @property
-    def tool_version( self ):
-        """Return a ToolLineage if one exists for our id."""
-        return self.app.toolbox._lineage_map.get(self.id)
+    def lineage(self):
+        """Return ToolLineage for this tool."""
+        return self._lineage
 
     @property
     def tool_versions( self ):
         # If we have versions, return them.
-        tool_version = self.tool_version
-        if tool_version:
-            return tool_version.get_versions( self.app )
-        return []
+        if self.lineage:
+            return self.lineage.get_versions()
+        else:
+            return []
 
     @property
     def tool_shed_repository( self ):
@@ -1830,7 +1831,7 @@ class Tool( object, Dictifiable ):
             tool_help = unicodify( tool_help, 'utf-8' )
 
         # create tool versions
-        tool_versions = self.tool_version.tool_versions
+        tool_versions = self.lineage.tool_versions
 
         # update tool model
         tool_model.update({

lib/galaxy/tools/toolbox/base.py

@@ -289,9 +289,7 @@ class AbstractToolBox( Dictifiable, ManagesIntegratedToolPanelMixin, object ):
                 inserted = True
             if not inserted:
                 # Check the tool's installed versions.
-                versions = []
-                if hasattr(tool, 'lineage'):
-                    versions = tool.lineage.get_versions()
+                versions = tool.lineage.get_versions()
                 for tool_lineage_version in versions:
                     lineage_id = tool_lineage_version.id
                     index = self._integrated_tool_panel.index_of_tool_id(lineage_id)
@@ -565,9 +563,8 @@ class AbstractToolBox( Dictifiable, ManagesIntegratedToolPanelMixin, object ):
                     tool.installed_changeset_revision = tool_shed_repository.installed_changeset_revision
                     tool.guid = guid
                     tool.version = item.elem.find( "version" ).text
-                # Make sure tools have a tool_version object.
-                tool_lineage = self._lineage_map.register( tool )
-                tool.lineage = tool_lineage
+                # Make sure tools are registered in self._lineage_map.
+                tool._lineage = self._lineage_map.register( tool )
                 if item.has_elem:
                     self._tool_tag_manager.handle_tags( tool.id, item.elem )
                 self.__add_tool( tool, load_panel_dict, panel_dict )
@@ -947,8 +944,6 @@ class AbstractToolBox( Dictifiable, ManagesIntegratedToolPanelMixin, object ):
         """
         if tool_lineage is None:
             assert tool is not None
-            if not hasattr( tool, "lineage" ):
-                return None
             tool_lineage = tool.lineage
         lineage_tool_versions = reversed(tool_lineage.get_versions())
         for lineage_tool_version in lineage_tool_versions:
@@ -963,8 +958,6 @@ class AbstractToolBox( Dictifiable, ManagesIntegratedToolPanelMixin, object ):
         """ Return True if tool1 is considered "newer" given its own lineage
         description.
         """
-        if not hasattr( tool1, "lineage" ):
-            return True
         return tool1.version_object > tool2.version_object
 
     def _tool_from_lineage_version( self, lineage_tool_version ):

lib/galaxy/tools/toolbox/lineages/interface.py

@@ -14,15 +14,6 @@ class ToolLineageVersion(object):
         self.id = id
         self.version = version
 
-    @staticmethod
-    def from_id_and_verion( id, version ):
-        assert version is not None
-        return ToolLineageVersion( id, version )
-
-    @staticmethod
-    def from_guid( guid ):
-        return ToolLineageVersion( guid, None )
-
     @property
     def id_based( self ):
         """ Return True if the lineage is defined by GUIDs (in this

lib/galaxy/webapps/galaxy/controllers/admin_toolshed.py

@@ -2059,9 +2059,12 @@ class AdminToolshed( AdminGalaxy ):
                     tool_config = tool_metadata[ 'tool_config' ]
                     if shed_config_dict and shed_config_dict.get( 'tool_path' ):
                         tool_config = os.path.join( shed_config_dict.get( 'tool_path' ), tool_config )
-                    tool = trans.app.toolbox.load_tool( os.path.abspath( tool_config ), guid=tool_metadata[ 'guid' ] )
-                    if tool:
-                        tool_lineage = tool.tool_version.get_version_ids(reverse=True)
+                    tool = trans.app.toolbox.get_tool(tool_id=tool_metadata[ 'guid' ], exact=True)
+                    if not tool:
+                        tool = trans.app.toolbox.load_tool( os.path.abspath( tool_config ), guid=tool_metadata[ 'guid' ] )
+                        if tool:
+                            tool._lineage = trans.app.toolbox._lineage_map.register( tool )
+                    tool_lineage = tool.lineage.get_version_ids(reverse=True)
                     break
         return trans.fill_template( "/admin/tool_shed_repository/view_tool_metadata.mako",
                                     repository=repository,