Added support for a dependencies.json file

This should make development easier for package developers since they do not need
to rely on creating a repository.json file with the dependencies for their
Sublime Text install to have the appropriate dependencies.

Author: wbond

dependencies.json

@@ -0,0 +1,20 @@
+{
+	"windows": {
+		"<3000": [
+			"select-windows",
+			"ssl-windows",
+			"bz2"
+		]
+	},
+	"linux": {
+		"*": [
+			"ssl-linux",
+			"bz2"
+		]
+	},
+	"*": {
+		"*": [
+			"bz2"
+		]
+	}
+}

package_control/package_cleanup.py

@@ -37,6 +37,7 @@ def run(self):
         found_dependencies = []
 
         installed_packages = list(self.original_installed_packages)
+        installed_dependencies = list(self.original_installed_dependencies)
 
         for package_name in os.listdir(sublime.packages_path()):
             found = True
@@ -161,13 +162,20 @@ def show_still_locked():
         invalid_packages = []
         invalid_dependencies = []
 
-        # Check metadata to verify packages were not improperly installed
+        # Check metadata to verify packages were not improperly installed, and
+        # also make sure we have all dependencies we need
         for package in found_packages:
             if package == 'User':
                 continue
+
             metadata = self.manager.get_metadata(package)
-            if metadata and not self.is_compatible(metadata):
-                invalid_packages.append(package)
+            if metadata:
+                if not self.is_compatible(metadata):
+                    invalid_packages.append(package)
+
+            for dependency in self.manager.get_dependencies(package):
+                if dependency not in installed_dependencies:
+                    installed_dependencies.append(dependency)
 
         for dependency in found_dependencies:
             metadata = self.manager.get_metadata(dependency, is_dependency=True)
@@ -198,7 +206,7 @@ def show_sync_error():
                 show_error(message)
             sublime.set_timeout(show_sync_error, 100)
 
-        sublime.set_timeout(lambda: self.finish(installed_packages, found_packages, found_dependencies), 10)
+        sublime.set_timeout(lambda: self.finish(installed_packages, installed_dependencies, found_packages, found_dependencies), 10)
 
     def is_compatible(self, metadata):
         """
@@ -237,7 +245,7 @@ def is_compatible(self, metadata):
 
         return True
 
-    def finish(self, installed_packages, found_packages, found_dependencies):
+    def finish(self, installed_packages, installed_dependencies, found_packages, found_dependencies):
         """
         A callback that can be run the main UI thread to perform saving of the
         Package Control.sublime-settings file. Also fires off the
@@ -247,6 +255,10 @@ def finish(self, installed_packages, found_packages, found_dependencies):
             A list of the string package names of all "installed" packages,
             even ones that do not appear to be in the filesystem.
 
+        :param installed_dependencies:
+            A list of the string dependency names of all "installed"
+            dependencies, even ones that do not appear to be in the filesystem.
+
         :param found_packages:
             A list of the string package names of all packages that are
             currently installed on the filesystem.
@@ -276,6 +288,9 @@ def finish(self, installed_packages, found_packages, found_dependencies):
             save_list_setting(settings, filename, 'ignored_packages', new_ignored, ignored)
             save_list_setting(pc_settings, pc_filename, 'in_process_packages', [])
 
+        save_list_setting(pc_settings, pc_filename, 'installed_dependencies',
+            installed_dependencies, self.original_installed_dependencies)
+
         save_list_setting(pc_settings, pc_filename, 'installed_packages',
             installed_packages, self.original_installed_packages)
         AutomaticUpgrader(found_packages, found_dependencies).start()

package_control/package_manager.py

@@ -39,10 +39,10 @@
 from .clients.client_exception import ClientException
 from .download_manager import downloader
 from .providers.channel_provider import ChannelProvider
-from .providers.release_selector import filter_releases
+from .providers.release_selector import filter_releases, is_compatible_version
 from .upgraders.git_upgrader import GitUpgrader
 from .upgraders.hg_upgrader import HgUpgrader
-from .package_io import read_package_file
+from .package_io import read_package_file, package_file_exists
 from .providers import CHANNEL_PROVIDERS, REPOSITORY_PROVIDERS
 from .settings import pc_settings_filename, load_list_setting, save_list_setting
 from .versions import version_comparable
@@ -165,6 +165,58 @@ def get_metadata(self, package, is_dependency=False):
 
         return {}
 
+    def get_dependencies(self, package):
+        """
+        Returns a list of dependencies for the specified package on the
+        current machine
+
+        :param package:
+            The name of the package
+
+        :return:
+            A list of dependency names
+        """
+
+        try:
+            debug = self.settings.get('debug')
+            if not package_file_exists(package, 'dependencies.json'):
+                raise ValueError()
+
+            dep_info_json = read_package_file(package, 'dependencies.json', debug=debug)
+            if not dep_info_json:
+                raise ValueError()
+
+            dep_info = json.loads(dep_info_json)
+            platform_selectors = [sublime.platform() + '-' + sublime.arch(),
+                sublime.platform(), '*']
+
+            for platform_selector in platform_selectors:
+                if platform_selector not in dep_info:
+                    continue
+
+                platform_dep_info = dep_info[platform_selector]
+                versions = platform_dep_info.keys()
+
+                # Sorting reverse will give us >, < then *
+                for version_selector in sorted(versions, reverse=True):
+                    if not is_compatible_version(version_selector):
+                        continue
+                    return platform_dep_info[version_selector]
+
+            # If there were no matches in dependencies.json, but there also
+            # weren't any errors, then it just means there are not dependencies
+            # for this machine
+            return []
+
+        except (IOError, ValueError) as e:
+            pass
+
+        metadata = self.get_metadata(package)
+        if metadata:
+            return metadata.get('dependencies', [])
+
+        return []
+
     def list_repositories(self):
         """
         Returns a master list of all repositories pulled from all sources
@@ -477,20 +529,12 @@ def find_required_dependencies(self, ignore_package):
             A list of the dependencies required by the installed packages
         """
 
-        output = ['0_package_control_loader', 'bz2']
-
-        # Hard-code Package Control deps by os/plat
-        if os.name == 'nt' and sys.version_info < (3,):
-            output.extend(['ssl-windows', 'select-windows'])
-
-        if sublime.platform() == 'linux':
-            output.append('ssl-linux')
+        output = ['0_package_control_loader']
 
         for package in self.list_packages():
             if package == ignore_package:
                 continue
-            metadata = self.get_metadata(package)
-            output.extend(metadata.get('dependencies', []))
+            output.extend(self.get_dependencies(package))
 
         output = list(set(output))
         return sorted(output, key=lambda s: s.lower())