Lock command: read lockfile and updates

- The lock command now reads the lockfile and passes it to the
  solver.
- The solver calculates the distance based on the locked version if
  present and locked, otherwise aims for the latest release.
- The solver always aims for the latest version when the --update
  command line flag is set.

These changes enable the following scenarios:

- running the lock command twice without changing dependency
  requirements shall lock the same versions;

- adding a new dependency, or changing a dependency requirement,
  shall update the minimum number of other dependencies to satisfy
  the new dependency (or changed requirements);

- removing a dependency shall remove extraneous dependencies and
  update none.

Author: ysbaddaden

src/cli.cr

@@ -48,7 +48,10 @@ module Shards
         when "list"
           Commands::List.run(path, tree: args.includes?("--tree"))
         when "lock"
-          Commands::Lock.run(path, print: args.includes?("--print"))
+          Commands::Lock.run(path,
+            print: args.includes?("--print"),
+            update: args.includes?("--update")
+          )
         when "outdated"
           Commands::Outdated.run(path, prereleases: args.includes?("--pre"))
         when "prune"

src/commands/lock.cr

@@ -4,10 +4,11 @@ require "../solver"
 module Shards
   module Commands
     class Lock < Command
-      def run(print = false)
+      def run(print = false, update = false)
         Shards.logger.info { "Resolving dependencies" }
 
         solver = Solver.new(spec)
+        solver.locks = locks if !update && lockfile?
         solver.prepare(development: !Shards.production?)
 
         if solution = solver.solve
@@ -26,7 +27,7 @@ module Shards
       end
 
       private def to_lockfile(solution, io)
-        io << "version: 1.1\n"
+        io << "version: 1.0\n"
         io << "shards:\n"
 
         solution.sort_by!(&.name).each do |rs|
@@ -41,7 +42,7 @@ module Shards
             io << "    version: " << rs.version << '\n'
           end
 
-          puts
+          io << '\n'
         end
       end
     end

src/solver.cr

@@ -10,9 +10,7 @@ module Shards
       version : String,
       commit : String?
 
-    alias Solution = Array(Result)
-
-    getter graph : Graph
+    setter locks : Array(Dependency)?
 
     def initialize(@spec : Spec)
       @graph = Graph.new
@@ -24,7 +22,7 @@ module Shards
       build_cnf_clauses(development)
     end
 
-    def solve : Solution?
+    def solve : Array(Result)?
       distances = calculate_distances
 
       solution = nil
@@ -50,7 +48,7 @@ module Shards
     end
 
     private def to_result(proposal)
-      solution = Solution.new
+      solution = [] of Result
 
       proposal.each do |str|
         next unless colon = str.index(':')
@@ -96,7 +94,7 @@ module Shards
             clause[0] =~ /^~(.+):(.+)$/
             a_name, a_version = $1, $2
 
-            spec = graph.packages[a_name].versions[a_version]
+            spec = @graph.packages[a_name].versions[a_version]
             interest << "#{a_name}:"
           end
 
@@ -143,7 +141,7 @@ module Shards
 
     private def add_dependencies(negation, dependencies)
       dependencies.each do |d|
-        versions = graph.resolve(d)
+        versions = @graph.resolve(d)
 
         if versions.empty?
           # FIXME: we couldn't resolve a constraint
@@ -163,18 +161,27 @@ module Shards
 
     # Computes the distance for each version from a reference version, for
     # deciding the best solution.
-    #
-    # TODO: should be the distance from a given version or a range of
-    #       versions, not necessarily from the latest one (e.g. for
-    #       conservative updates).
-    # TODO: consider adding some weight (e.g. to update some dependencies).
     private def calculate_distances
       distances = {} of String => Int32
       distances[@spec.name] = 0
 
-      graph.each do |pkg|
+      @graph.each do |pkg|
+        # reference is latest version by default:
+        position = 0
+
+        if locked = @locks.try(&.find { |d| d.name == pkg.name })
+          # determine position of locked version to use it as reference:
+          pkg.each_version do |version, index|
+            if version == locked.version
+              position = index
+              break
+            end
+          end
+        end
+
+        # calculate distances to reference version:
         pkg.each_version do |version, index|
-          distances["#{pkg.name}:#{version}"] = index
+          distances["#{pkg.name}:#{version}"] = (position - index).abs
         end
       end