Use SAT solver in all commands

Author: ysbaddaden

src/cli.cr

@@ -14,7 +14,7 @@ module Shards
           list [--tree]                  - Lists installed dependencies.
           outdated [--pre]               - Lists dependencies that are outdated.
           prune                          - Removes unused dependencies from `lib` folder.
-          update                         - Updates dependencies and `shards.lock`.
+          update [<shard>, ...]          - Updates dependencies and `shard.lock`.
           version [<path>]               - Prints the current version of the shard.
 
       Options:
@@ -59,7 +59,7 @@ module Shards
         when "prune"
           Commands::Prune.run(path)
         when "update"
-          Commands::Update.run(path)
+          Commands::Update.run(path, args.reject(&.starts_with?("--")))
         when "version"
           Commands::Version.run(args[1]? || path)
         else

src/commands/build.cr

@@ -10,7 +10,7 @@ module Shards
         end
 
         if targets.empty?
-          targets = manager.spec.targets.map(&.name)
+          targets = spec.targets.map(&.name)
         end
 
         targets.each do |name|
@@ -23,15 +23,15 @@ module Shards
       end
 
       private def build(target, options)
-        Shards.logger.info "Building: #{target.name}"
+        Shards.logger.info { "Building: #{target.name}" }
 
         args = [
           "build",
           "-o", File.join(Shards.bin_path, target.name),
           target.main,
         ]
         options.each { |option| args << option }
-        Shards.logger.debug "crystal #{args.join(' ')}"
+        Shards.logger.debug { "crystal #{args.join(' ')}" }
 
         error = IO::Memory.new
         status = Process.run("crystal", args: args, output: Process::Redirect::Inherit, error: error)

src/commands/command.cr

@@ -1,5 +1,4 @@
 require "../lock"
-require "../manager"
 require "../spec"
 
 module Shards
@@ -40,10 +39,6 @@ module Shards
       File.basename(spec_path)
     end
 
-    def manager
-      @manager ||= Manager.new(spec)
-    end
-
     def locks
       @locks ||= if lockfile?
                    Shards::Lock.from_file(lockfile_path)
@@ -55,5 +50,10 @@ module Shards
     def lockfile?
       File.exists?(lockfile_path)
     end
+
+    def write_lockfile(packages)
+      Shards.logger.info { "Writing #{LOCK_FILENAME}" }
+      Shards::Lock.write(packages, LOCK_FILENAME)
+    end
   end
 end

src/commands/install.cr

@@ -1,77 +1,67 @@
 require "./command"
+require "../solver"
 
 module Shards
   module Commands
-    # OPTIMIZE: avoid updating GIT caches until required
     class Install < Command
       def run
+        Shards.logger.info { "Resolving dependencies" }
+
+        solver = Solver.new(spec)
+
         if lockfile?
-          manager.locks = locks
-          manager.resolve
-          install(manager.packages, locks)
-        else
-          manager.resolve
-          install(manager.packages)
+          # install must be as conservative as possible:
+          solver.locks = locks
         end
 
-        if generate_lockfile?
-          manager.to_lock(lockfile_path)
-        end
-      end
+        solver.prepare(development: !Shards.production?)
 
-      private def install(packages : Set, locks : Array(Dependency))
-        packages.each do |package|
-          version = nil
+        if packages = solver.solve
+          install(packages)
 
-          if lock = locks.find { |dependency| dependency.name == package.name }
-            if version = lock["version"]?
-              unless package.matching_versions.includes?(version)
-                raise LockConflict.new("#{package.name} requirements changed")
-              end
-            elsif version = lock["commit"]?
-              unless package.matches?(version)
-                raise LockConflict.new("#{package.name} requirements changed")
-              end
-            else
-              raise InvalidLock.new # unknown lock resolver
-            end
-          elsif Shards.production?
-            raise LockConflict.new("can't install new dependency #{package.name} in production")
+          if generate_lockfile?(packages)
+            write_lockfile(packages)
           end
-
-          install(package, version)
+        else
+          solver.each_conflict do |message|
+            Shards.logger.warn { "Conflict #{message}" }
+          end
+          Shards.logger.error { "Failed to resolve dependencies" }
         end
       end
 
-      private def install(packages : Set)
-        packages
-          .compact_map { |package| install(package) }
-          .each(&.postinstall)
+      private def install(packages : Array(Package))
+        # first install all dependencies:
+        installed = packages.compact_map { |package| install(package) }
 
-        # always install executables because the path resolver never installs
-        # dependencies, but uses them as-is:
+        # then execute the postinstall script of installed dependencies (with
+        # access to all transitive dependencies):
+        installed.each(&.postinstall)
+
+        # always install executables because the path resolver never actually
+        # installs dependencies:
         packages.each(&.install_executables)
       end
 
-      private def install(package : Package, version = nil)
-        version ||= package.version
-
-        if package.installed?(version)
-          Shards.logger.info "Using #{package.name} (#{package.report_version})"
+      private def install(package : Package)
+        if package.installed?
+          Shards.logger.info { "Using #{package.name} (#{package.report_version})" }
           return
         end
 
-        Shards.logger.info "Installing #{package.name} (#{package.report_version})"
-        package.install(version)
+        Shards.logger.info { "Installing #{package.name} (#{package.report_version})" }
+        package.install
         package
       end
 
-      private def generate_lockfile?
-        !Shards.production? && manager.packages.any? && (!lockfile? || outdated_lockfile?)
+      private def generate_lockfile?(packages)
+        !Shards.production? && !packages.empty? && (!lockfile? || outdated_lockfile?(packages))
       end
 
-      private def outdated_lockfile?
-        locks.size != manager.packages.size
+      private def outdated_lockfile?(packages)
+        a = packages.map { |x| {x.name, x.version, x.commit} }
+        b = locks.map { |x| {x.name, x["version"], x["commit"]?} }
+        a != b
       end
     end
   end

src/commands/lock.cr

@@ -4,7 +4,7 @@ require "../solver"
 module Shards
   module Commands
     class Lock < Command
-      def run(shards, print = false, update = false)
+      def run(shards : Array(String), print = false, update = false)
         Shards.logger.info { "Resolving dependencies" }
 
         solver = Solver.new(spec)
@@ -24,35 +24,34 @@ module Shards
 
         solver.prepare(development: !Shards.production?)
 
-        if solution = solver.solve
+        if packages = solver.solve
           if print
-            to_lockfile(solution, STDOUT)
+            Shards::Lock.write(packages, STDOUT)
           else
-            Shards.logger.info { "Writing #{LOCK_FILENAME}" }
-            File.open(LOCK_FILENAME, "w") { |file| to_lockfile(solution, file) }
+            write_lockfile(packages)
           end
         else
           solver.each_conflict do |message|
             Shards.logger.warn { "Conflict #{message}" }
           end
-          Shards.logger.error { "Failed to find a solution" }
+          Shards.logger.error { "Failed to resolve dependencies" }
         end
       end
 
-      private def to_lockfile(solution, io)
+      private def to_lockfile(packages, io)
         io << "version: 1.0\n"
         io << "shards:\n"
 
-        solution.sort_by!(&.name).each do |rs|
-          key = rs.resolver.class.key
+        packages.sort_by!(&.name).each do |package|
+          key = package.resolver.class.key
 
-          io << "  " << rs.name << ":\n"
-          io << "    " << key << ": " << rs.resolver.dependency[key] << '\n'
+          io << "  " << package.name << ":\n"
+          io << "    " << key << ": " << package.resolver.dependency[key] << '\n'
 
-          if rs.commit
-            io << "    commit: " << rs.commit << '\n'
+          if package.commit
+            io << "    commit: " << package.commit << '\n'
           else
-            io << "    version: " << rs.version << '\n'
+            io << "    version: " << package.version << '\n'
           end
 
           io << '\n'

src/commands/outdated.cr

@@ -11,53 +11,59 @@ module Shards
       def run(@prereleases = false)
         return unless has_dependencies?
 
-        if lockfile?
-          manager.locks = locks
-          manager.resolve
-        else
-          manager.resolve
-        end
+        Shards.logger.info { "Resolving dependencies" }
 
-        manager.packages.each do |package|
-          analyze(package)
-        end
+        solver = Solver.new(spec)
+        solver.prepare(development: !Shards.production?)
 
-        if @up_to_date
-          Shards.logger.info "Dependencies are up to date!"
+        if packages = solver.solve
+          packages.each { |package| analyze(package) }
+
+          if @up_to_date
+            Shards.logger.info "Dependencies are up to date!"
+          else
+            @output.rewind
+            Shards.logger.warn "Outdated dependencies:"
+            puts @output.to_s
+          end
         else
-          @output.rewind
-          Shards.logger.warn "Outdated dependencies:"
-          puts @output.to_s
+          solver.each_conflict do |message|
+            Shards.logger.warn { "Conflict #{message}" }
+          end
+          Shards.logger.error { "Failed to resolve dependencies" }
         end
       end
 
       private def analyze(package)
-        _spec = package.resolver.installed_spec
+        resolver = package.resolver
+        installed = resolver.installed_spec.try(&.version)
 
-        unless _spec
+        unless installed
           Shards.logger.warn { "#{package.name}: not installed" }
           return
         end
 
-        installed = _spec.version
-
         # already the latest version?
-        latest = Versions.sort(package.available_versions(@prereleases)).first
+        available_versions =
+          if @prereleases
+            resolver.available_versions
+          else
+            Versions.without_prereleases(resolver.available_versions)
+          end
+        latest = Versions.sort(available_versions).first
         return if latest == installed
 
         @up_to_date = false
 
         @output << "  * " << package.name
         @output << " (installed: " << installed
 
-        # is new version matching constraints available?
-        available = package.matching_versions(@prereleases).first
-        unless available == installed
-          @output << ", available: " << available
+        unless installed == package.version
+          @output << ", available: " << package.version
         end
 
         # also report latest version:
-        if Versions.compare(latest, available) < 0
+        if Versions.compare(latest, package.version) < 0
           @output << ", latest: " << latest
         end