Basic dependency resolver

The resolver applies requirements as best as it can, but won't try
to fix conflicts —like selecting an older dependency version higher
in the dependency graph.

Author: ysbaddaden

README.md

@@ -6,6 +6,9 @@ The idea is for Crystal applications and libraries to have a `shard.yml` file
 at their root looking like this:
 
 ```yaml
+name: shards
+version: 0.1.0
+
 sources:
   - https://shards.crystal-lang.org/
   - https://shards.example.com/
@@ -28,16 +31,17 @@ folder, ready to be required.
 
 ## Development Plan
 
-- [ ] step 1: install/update dependencies
-  - [ ] clone from Git repositories (with github shortener)
+- [x] step 1: install/update dependencies
+  - [x] clone from Git repositories (with github shortener)
   - [ ] clone from Mercurial repositories (optional)
-  - [ ] copy/link from local path
+  - [x] copy/link from local path
 
 - [ ] step 2: resolve dependencies
   - [ ] recursively install dependencies
-  - [ ] list versions using git tags (v0.0.0-{pre,rc}0)
+  - [x] list versions using git tags (v0.0.0-{pre,rc}0)
   - [ ] checkout specified versions (defaults to the latest one)
-  - [ ] resolve versions, applying requirements (`*`, `>=`, `<=`, `<`, `>`, `~>`), recursively
+  - [x] resolve versions, applying requirements (`*`, `>=`, `<=`, `<`, `>`, `~>`), recursively
+  - [ ] resolve conflicts (when possible)
 
 - [ ] step 3: central registry (dumb)
   - [ ] resolve dependencies by name => repository URL

src/dependencies.cr

@@ -0,0 +1,20 @@
+module Shards
+  class Dependency < Hash(String, String)
+    getter :name, :config
+
+    def initialize(@name, config)
+      super nil
+      config.each { |k, v| self[k.to_s] = v.to_s }
+    end
+
+    def version
+      self["version"]? || "*"
+    end
+
+    def inspect(io)
+      io << "#<" << self.class.name << " {\"" << name << "\" => "
+      super
+      io << "}>"
+    end
+  end
+end

src/dependency.cr

@@ -0,0 +1,12 @@
+module Shards
+  class Error < ::Exception
+  end
+
+  class Conflict < Error
+    getter :package
+
+    def initialize(@package)
+      super "can't resolve #{package.name} (#{package.requirements.join(", ")})"
+    end
+  end
+end

src/errors.cr

@@ -0,0 +1,31 @@
+module Shards
+  module Helpers
+    module NaturalSort
+      EXTRACT_ALPHA_OR_NUMBER_GROUP = /([A-Za-z]+|[\d]+)/
+      IS_NUMBER_STRING = /\A\d+\Z/
+
+      def natural_sort(a, b)
+        ia = ib = 0
+
+        loop do
+          return 0 unless a[ia .. -1] =~ EXTRACT_ALPHA_OR_NUMBER_GROUP
+          aaa = $1
+          ia += $1.size + 1
+
+          return 0 unless b[ib .. -1] =~ EXTRACT_ALPHA_OR_NUMBER_GROUP
+          bbb = $1
+          ib += $1.size + 1
+
+          if aaa =~ IS_NUMBER_STRING && bbb =~ IS_NUMBER_STRING
+            aaa, bbb = aaa.to_i, bbb.to_i
+            ret = bbb <=> aaa
+          else
+            ret = bbb <=> aaa
+          end
+
+          return ret unless ret == 0
+        end
+      end
+    end
+  end
+end

src/helpers/natural_sort.cr

@@ -0,0 +1,48 @@
+require "./natural_sort"
+
+module Shards
+  module Helpers
+    module Versions
+      include NaturalSort
+
+      def resolve_versions(versions, requirements)
+        matches = requirements
+          .map { |requirement| resolve_requirement(versions, requirement) }
+          .inject(versions) { |a, e| a & e }
+      end
+
+      def resolve_requirement(versions, requirement)
+        case requirement
+        when "*", ""
+          versions
+
+        when /~>(.+)/
+          ver = $1.strip
+          vver = ver[0 ... ver.rindex(".").to_i]
+          versions.select { |v| v.starts_with?(vver) && (natural_sort(v, ver) <= 0) }
+
+        when />=(.+)/
+          ver = $1.strip
+          versions.select { |v| natural_sort(v, ver) <= 0 }
+
+        when /<=(.+)/
+          ver = $1.strip
+          versions.select { |v| natural_sort(v, ver) >= 0 }
+
+        when />(.+)/
+          ver = $1.strip
+          versions.select { |v| natural_sort(v, ver) < 0 }
+
+        when /<(.+)/
+          ver = $1.strip
+          versions.select { |v| natural_sort(v, ver) > 0 }
+
+        else
+          ver = requirement.strip
+          versions.select { |v| v == ver }
+
+        end
+      end
+    end
+  end
+end

src/helpers/versions.cr

@@ -0,0 +1,14 @@
+require "logger"
+
+module Shards
+  def self.logger
+    @@logger ||= Logger.new(STDOUT).tap do |logger|
+      logger.progname = "shards"
+      logger.level = Logger::Severity::DEBUG
+
+      logger.formatter = Logger::Formatter.new do |severity, _datetime, _progname, message, io|
+        io << severity[0] << ": " << message
+      end
+    end
+  end
+end

src/logger.cr

@@ -0,0 +1,75 @@
+require "./dependency"
+require "./resolvers"
+require "./helpers/versions"
+
+module Shards
+  class Package
+    include Helpers::Versions
+
+    getter :requirements
+
+    def initialize(@dependency)
+      @requirements = [] of String
+    end
+
+    def name
+      @dependency.name
+    end
+
+    def version
+      versions = resolve_versions(resolver.available_versions, requirements)
+
+      if versions.any?
+        versions.first
+      else
+        raise Conflict.new(self)
+      end
+    end
+
+    def spec
+      resolver.spec(version)
+    end
+
+    private def resolver
+      @resolver ||= Shards.find_resolver(@dependency)
+    end
+  end
+
+  class Set < Array(Package)
+    def add(dependency)
+      package = find { |package| package.name == dependency.name }
+
+      unless package
+        package = Package.new(dependency)
+        self << package
+      end
+
+      package.requirements << dependency.version
+      package
+    end
+  end
+
+  class Manager
+    getter :spec
+    getter :packages
+
+    def initialize(@spec)
+      @packages = Set.new
+    end
+
+    def resolve
+      resolve(spec)
+    rescue ex : Conflict
+      Shards.logger.error ex.message
+      exit -1
+    end
+
+    # TODO: handle conflicts
+    def resolve(spec)
+      spec.dependencies.each do |dependency|
+        package = packages.add(dependency)
+        resolve(package.spec)
+      end
+    end
+  end
+end

src/manager.cr

@@ -1,20 +1,38 @@
+require "./spec"
+
 module Shards
-  class Resolver
+  abstract class Resolver
     getter :dependency
 
     def initialize(@dependency)
     end
+
+    def spec(version = nil)
+      Spec.new(read_spec(version))
+    end
+
+    abstract def read_spec(version = nil)
+    abstract def available_versions
   end
 
-  @@resolvers = {} of String => Resolver.class
+  @@resolver_classes = {} of String => Resolver.class
+  @@resolvers = {} of String => Resolver
 
   def self.register_resolver(name, resolver)
-    @@resolvers[name.to_s] = resolver
+    @@resolver_classes[name.to_s] = resolver
+  end
+
+  def self.find_resolver(dependency)
+    @@resolvers[dependency.name] ||= begin
+      klass = get_resolver_class(dependency.keys)
+      raise Error.new("can't resolve dependency #{dependency.name} (unsupported resolver)") unless klass
+      klass.new(dependency)
+    end
   end
 
-  def self.find_resolver(names)
+  private def self.get_resolver_class(names)
     names.each do |name|
-      if resolver = @@resolvers[name.to_s]
+      if resolver = @@resolver_classes[name.to_s]
         return resolver
       end
     end
@@ -26,3 +44,4 @@ end
 require "./resolvers/git"
 require "./resolvers/github"
 require "./resolvers/bitbucket"
+require "./resolvers/path"