diff --git a/galaxy/tools/deps/resolvers/brewed_tool_shed_packages.py b/galaxy/tools/deps/resolvers/brewed_tool_shed_packages.py
new file mode 100644
index 0000000000000000000000000000000000000000..530dc7df2afc1b1aedc6611cf1660421dfc976f8
--- /dev/null
+++ b/galaxy/tools/deps/resolvers/brewed_tool_shed_packages.py
@@ -0,0 +1,150 @@
+"""
+This dependency resolver resolves tool shed dependencies (those defined
+tool_dependencies.xml) installed using Platform Homebrew and converted
+via shed2tap (e.g. https://github.com/jmchilton/homebrew-toolshed).
+"""
+import logging
+import os
+from xml.etree import ElementTree as ET
+
+from .resolver_mixins import (
+ UsesHomebrewMixin,
+ UsesToolDependencyDirMixin,
+ UsesInstalledRepositoriesMixin,
+)
+from ..resolvers import DependencyResolver, INDETERMINATE_DEPENDENCY
+
+log = logging.getLogger(__name__)
+
+
+class HomebrewToolShedDependencyResolver(
+ DependencyResolver,
+ UsesHomebrewMixin,
+ UsesToolDependencyDirMixin,
+ UsesInstalledRepositoriesMixin,
+):
+ resolver_type = "tool_shed_tap"
+
+ def __init__(self, dependency_manager, **kwds):
+ self._init_homebrew(**kwds)
+ self._init_base_path(dependency_manager, **kwds)
+
+ def resolve(self, name, version, type, **kwds):
+ if type != "package":
+ return INDETERMINATE_DEPENDENCY
+
+ if version is None:
+ return INDETERMINATE_DEPENDENCY
+
+ return self._find_tool_dependencies(name, version, type, **kwds)
+
+ def _find_tool_dependencies(self, name, version, type, **kwds):
+ installed_tool_dependency = self._get_installed_dependency(name, type, version=version, **kwds)
+ if installed_tool_dependency:
+ return self._resolve_from_installed_tool_dependency(name, version, installed_tool_dependency)
+
+ if "tool_dir" in kwds:
+ tool_directory = os.path.abspath(kwds["tool_dir"])
+ tool_depenedencies_path = os.path.join(tool_directory, "tool_dependencies.xml")
+ if os.path.exists(tool_depenedencies_path):
+ return self._resolve_from_tool_dependencies_path(name, version, tool_depenedencies_path)
+
+ return INDETERMINATE_DEPENDENCY
+
+ def _resolve_from_installed_tool_dependency(self, name, version, installed_tool_dependency):
+ tool_shed_repository = installed_tool_dependency.tool_shed_repository
+ recipe_name = build_recipe_name(
+ package_name=name,
+ package_version=version,
+ repository_owner=tool_shed_repository.owner,
+ repository_name=tool_shed_repository.name,
+ )
+ return self._find_dep_default(recipe_name, None)
+
+ def _resolve_from_tool_dependencies_path(self, name, version, tool_dependencies_path):
+ try:
+ raw_dependencies = RawDependencies(tool_dependencies_path)
+ except Exception:
+ log.debug("Failed to parse dependencies in file %s" % tool_dependencies_path)
+ return INDETERMINATE_DEPENDENCY
+
+ raw_dependency = raw_dependencies.find(name, version)
+ if not raw_dependency:
+ return INDETERMINATE_DEPENDENCY
+
+ recipe_name = build_recipe_name(
+ package_name=name,
+ package_version=version,
+ repository_owner=raw_dependency.repository_owner,
+ repository_name=raw_dependency.repository_name
+ )
+ dep = self._find_dep_default(recipe_name, None)
+ return dep
+
+
+class RawDependencies(object):
+
+ def __init__(self, dependencies_file):
+ self.root = ET.parse(dependencies_file).getroot()
+ dependencies = []
+ package_els = self.root.findall("package") or []
+ for package_el in package_els:
+ repository_el = package_el.find("repository")
+ if repository_el is None:
+ continue
+ dependency = RawDependency(self, package_el, repository_el)
+ dependencies.append(dependency)
+ self.dependencies = dependencies
+
+ def find(self, package_name, package_version):
+ target_dependency = None
+
+ for dependency in self.dependencies:
+ if dependency.package_name == package_name and dependency.package_version == package_version:
+ target_dependency = dependency
+ break
+ return target_dependency
+
+
+class RawDependency(object):
+
+ def __init__(self, dependencies, package_el, repository_el):
+ self.dependencies = dependencies
+ self.package_el = package_el
+ self.repository_el = repository_el
+
+ def __repr__(self):
+ temp = "Dependency[package_name=%s,version=%s,dependent_package=%s]"
+ return temp % (
+ self.package_el.attrib["name"],
+ self.package_el.attrib["version"],
+ self.repository_el.attrib["name"]
+ )
+
+ @property
+ def repository_owner(self):
+ return self.repository_el.attrib["owner"]
+
+ @property
+ def repository_name(self):
+ return self.repository_el.attrib["name"]
+
+ @property
+ def package_name(self):
+ return self.package_el.attrib["name"]
+
+ @property
+ def package_version(self):
+ return self.package_el.attrib["version"]
+
+
+def build_recipe_name(package_name, package_version, repository_owner, repository_name):
+ # TODO: Consider baking package_name and package_version into name? (would be more "correct")
+ owner = repository_owner.replace("-", "")
+ name = repository_name
+ name = name.replace("_", "").replace("-", "")
+ base = "%s_%s" % (owner, name)
+ return base
+
+
+__all__ = ['HomebrewToolShedDependencyResolver']
diff --git a/galaxy/tools/deps/resolvers/resolver_mixins.py b/galaxy/tools/deps/resolvers/resolver_mixins.py
new file mode 100644
index 0000000000000000000000000000000000000000..661d87ecaee4f440ce0a7a427bafd2f0a3861c1f
--- /dev/null
+++ b/galaxy/tools/deps/resolvers/resolver_mixins.py
@@ -0,0 +1,73 @@
+import os
+from ..brew_exts import DEFAULT_HOMEBREW_ROOT, recipe_cellar_path, build_env_statements
+from ..resolvers import INDETERMINATE_DEPENDENCY, Dependency
+
+
+class UsesHomebrewMixin:
+
+ def _init_homebrew(self, **kwds):
+ cellar_root = kwds.get('cellar', None)
+ if cellar_root is None:
+ cellar_root = os.path.join(DEFAULT_HOMEBREW_ROOT, "Cellar")
+
+ self.cellar_root = cellar_root
+
+ def _find_dep_versioned(self, name, version):
+ recipe_path = recipe_cellar_path(self.cellar_root, name, version)
+ if not os.path.exists(recipe_path) or not os.path.isdir(recipe_path):
+ return INDETERMINATE_DEPENDENCY
+
+ commands = build_env_statements(self.cellar_root, recipe_path, relaxed=True)
+ return HomebrewDependency(commands)
+
+ def _find_dep_default(self, name, version):
+ installed_versions = self._installed_versions(name)
+ if not installed_versions:
+ return INDETERMINATE_DEPENDENCY
+
+ # Just grab newest installed version - may make sense some day to find
+ # the linked version instead.
+ default_version = sorted(installed_versions, reverse=True)[0]
+ return self._find_dep_versioned(name, default_version)
+
+ def _installed_versions(self, recipe):
+ recipe_base_path = os.path.join(self.cellar_root, recipe)
+ if not os.path.exists(recipe_base_path):
+ return []
+
+ names = os.listdir(recipe_base_path)
+ return filter(lambda n: os.path.isdir(os.path.join(recipe_base_path, n)), names)
+
+
+class UsesToolDependencyDirMixin:
+
+ def _init_base_path(self, dependency_manager, **kwds):
+ self.base_path = os.path.abspath( kwds.get('base_path', dependency_manager.default_base_path) )
+
+
+class UsesInstalledRepositoriesMixin:
+
+ def _get_installed_dependency( self, name, type, version=None, **kwds ):
+ installed_tool_dependencies = kwds.get("installed_tool_dependencies", [])
+ for installed_tool_dependency in (installed_tool_dependencies or []):
+ name_and_type_equal = installed_tool_dependency.name == name and installed_tool_dependency.type == type
+ if version:
+ if name_and_type_equal and installed_tool_dependency.version == version:
+ return installed_tool_dependency
+ else:
+ if name_and_type_equal:
+ return installed_tool_dependency
+ return None
+
+
+class HomebrewDependency(Dependency):
+
+ def __init__(self, commands):
+ self.commands = commands
+
+ def shell_commands(self, requirement):
+ raw_commands = self.commands.replace("\n", ";")
+ return raw_commands
+
+ def __repr__(self):
+ return "PlatformBrewDependency[commands=%s]" % self.commands