refactor(*): rework to include shards, wrap install for geode

Author: devnote-dev

shard.lock

@@ -12,6 +12,14 @@ shards:
     git: https://github.com/devnote-dev/license.git
     version: 0.1.0+git.commit.f95e1c1c95d1ef9d50097b38f4e6bc688629601a
 
+  molinillo:
+    git: https://github.com/crystal-lang/crystal-molinillo.git
+    version: 0.2.0
+
+  shards:
+    git: https://github.com/crystal-lang/shards.git
+    version: 0.18.0
+
   trigram:
     git: https://github.com/devnote-dev/trigram.git
     version: 0.1.0+git.commit.57df0066d2508d9b472be40babd3571b7b5bd772

shard.yml

@@ -17,6 +17,9 @@ dependencies:
     github: devnote-dev/license
     branch: main
 
+  shards:
+    github: crystal-lang/shards
+
   trigram:
     github: devnote-dev/trigram
 

src/commands/install.cr

@@ -5,7 +5,7 @@ module Geode::Commands
       @summary = "install dependencies from shard.yml"
       @description = <<-DESC
         Installs dependencies from a shard.yml file. This includes development dependencies
-        unless you include the '--production' flag.
+        unless you specify the '--production' flag.
         DESC
 
       add_usage "install [-D|--without-development] [-E|--skip-executables] [--frozen]" \
@@ -47,95 +47,33 @@ module Geode::Commands
     def run(arguments : Cling::Arguments, options : Cling::Options) : Nil
       ensure_local_shard!
 
-      shards = Process.find_executable "shards"
-      fatal(
-        "Could not find the Shards executable",
-        "(wrapped around for dependency resolution)",
-      ) unless shards
-
-      args = %w[install --skip-executables --skip-postinstall]
-      args << "--frozen" if options.has? "frozen"
-      args << "--no-color" if options.has? "no-color"
-      if value = options.get?("jobs").try &.as_i
-        args << "--jobs=#{value}"
-      end
-      args << "--local" if options.has? "local"
-      args << "--production" if options.has? "production"
-      args << "--without-development" if options.has? "without-development"
-
-      start = Time.monotonic
-      deps = [] of String
-
-      Process.run(shards, args) do |proc|
-        while message = proc.output.gets
-          if message.includes?("Installing") || message.includes?("Using")
-            deps << message.split(' ', 3)[1]
-          end
-          puts message
-        end
-        puts
-      end
+      reader, writer = IO.pipe(write_blocking: true)
+      Shards::Log.backend = ::Log::IOBackend.new writer
 
-      if $?.success?
-        if deps.empty? || (options.has?("skip-executables") && options.has?("skip-postinstall"))
-          success "Install completed in #{format_time(Time.monotonic - start)}"
-          return
-        end
+      if options.has? "production"
+        Shards.frozen = true
+        Shards.with_development = false
       else
-        fatal "Install failed (#{format_time(Time.monotonic - start)})"
+        Shards.frozen = options.has? "frozen"
+        Shards.with_development = !options.has?("without-development")
       end
 
-      shards = [] of Shard
-      Dir.each_child("lib") do |child|
-        next if child.starts_with? '.'
-        next unless Shard.exists? child
+      Shards.skip_executables = options.has? "skip-executables"
+      Shards.jobs = options.get("jobs").to_i32 if options.has?("jobs")
+      Shards.local = options.has? "local"
+      Shards.skip_postinstall = options.has? "skip-postinstall"
 
-        shards << Shard.load child
-      rescue YAML::ParseException
-        warn "Failed to parse shard.yml contents for '#{child}'"
-      end
-
-      unless options.has? "skip-postinstall"
-        shards.select(&.has_postinstall?).each do |shard|
-          if script = shard.find_target_script "postinstall", Geode::HOST_PLATFORM
-            run_postinstall shard.name, script
-          else
-            warn "No postinstall script available for this platform"
-          end
-        end
-      end
-
-      unless options.has? "skip-executables"
-        Dir.mkdir_p "bin"
-
-        shards.reject(&.executables.empty?).each do |shard|
-          shard.executables.each do |exe|
-            src = Path["lib"] / shard.name / "bin" / exe
-
-            {% if flag?(:win32) %}
-              unless File.exists?(src) || exe.ends_with?(".exe")
-                src = Path[src.basename, exe + ".exe"]
-              end
-            {% end %}
-
-            unless File.exists? src
-              warn "Executable '#{exe}' not found for #{shard.name}"
-              next
-            end
-
-            dest = Path["bin", exe].expand
-            unless File.exists? dest
-              begin
-                File.copy src, dest
-                info "Added executable '#{exe}'"
-              rescue
-                error "Failed to link #{shard.name} executable '#{exe}'"
-              end
-            end
+      spawn do
+        while input = reader.gets
+          if input.starts_with? "Fetching"
+            uri = URI.parse input.split(' ')[1]
+            stdout << "• " << uri.path << " (" << uri.hostname << ")\n"
           end
         end
       end
 
+      start = Time.monotonic
+      Shards::Commands::WrapInstall.new(stdout, stderr).run
       success "Install completed in #{format_time(Time.monotonic - start)}"
     end
 

src/geode.cr

@@ -4,13 +4,16 @@ require "colorize"
 require "file_utils"
 require "license"
 require "lua"
+require "shards/commands/install"
 require "trigram"
 require "wait_group"
 require "yaml"
 
 require "./commands/*"
 require "./config"
 require "./shard"
+require "./shards/base"
+require "./shards/install"
 
 Colorize.on_tty_only!
 

src/shards/base.cr

@@ -0,0 +1,49 @@
+module Geode
+  class WrapBase < Shards::Command
+    @stdout : IO
+    @stderr : IO
+
+    def initialize(@stdout : IO, @stderr : IO)
+      super Dir.current
+    end
+
+    protected def puts : Nil
+      @stdout.puts
+    end
+
+    protected def puts(msg : String) : Nil
+      @stdout.puts msg
+    end
+
+    protected def info(msg : String) : Nil
+      @stdout << "» " << msg << '\n'
+    end
+
+    protected def success(msg : String) : Nil
+      @stdout << "» Success".colorize.green << ": " << msg << '\n'
+    end
+
+    protected def warn(msg : String) : Nil
+      @stdout << "» Warning".colorize.yellow << ": " << msg << '\n'
+    end
+
+    protected def warn(*args : String) : Nil
+      @stdout << "» Warning".colorize.yellow << ": " << args[0] << '\n'
+      args[1..].each { |arg| @stdout << "»  ".colorize.yellow << arg << '\n' }
+    end
+
+    protected def error(msg : String) : Nil
+      @stderr << "» Error".colorize.red << ": " << msg << '\n'
+    end
+
+    protected def error(*args : String) : Nil
+      @stderr << "» Error".colorize.red << ": " << args[0] << '\n'
+      args[1..].each { |arg| @stderr << "»  ".colorize.red << arg << '\n' }
+    end
+
+    protected def fatal(*args : String) : NoReturn
+      error *args
+      raise Cling::ExitProgram.new 1
+    end
+  end
+end

src/shards/install.cr

@@ -0,0 +1,88 @@
+module Shards::Commands
+  class WrapInstall < Geode::WrapBase
+    def run : Nil
+      if Shards.frozen? && !lockfile?
+        fatal "A shard.lock file was not found (needed for frozen install)"
+      end
+
+      check_symlink_privilege
+      info "Resolving dependencies"
+
+      solver = MolinilloSolver.new(spec, override)
+      solver.locks = locks.shards if lockfile?
+
+      solver.prepare(development: Shards.with_development?)
+      packages = handle_resolver_errors { solver.solve }
+
+      validate packages if Shards.frozen?
+      install packages
+
+      if generate_lockfile? packages
+        write_lockfile packages
+      elsif !Shards.frozen?
+        File.touch lockfile_path
+      end
+
+      touch_install_path
+      check_crystal_version packages
+    end
+
+    private def validate(packages)
+      packages.each do |package|
+        if lock = locks.shards.find { |d| d.name == package.name }
+          if lock.resolver != package.resolver
+            fatal "#{package.name} source changed"
+          else
+            validate_locked_version(package, lock.version)
+          end
+        else
+          fatal "Can't install new dependency #{package.name} in production"
+        end
+      end
+    end
+
+    private def validate_locked_version(package, version)
+      return if package.version == version
+      fatal "#{package.name} requirements changed"
+    end
+
+    private def install(packages : Array(Package))
+      # packages are returned by the solver in reverse topological order,
+      # so transitive dependencies are installed first
+      packages.each do |package|
+        # first install the dependency:
+        next unless install package
+
+        # then execute the postinstall script
+        # (with access to all transitive dependencies):
+        package.postinstall
+
+        # always install executables because the path resolver never actually
+        # installs dependencies:
+        package.install_executables
+      end
+    end
+
+    private def install(package : Package)
+      if package.installed?
+        info "Using #{package.name} (#{package.report_version})"
+        return
+      end
+
+      info "Installing #{package.name} (#{package.report_version})"
+      package.install
+      package
+    end
+
+    private def generate_lockfile?(packages)
+      !Shards.frozen? && (!lockfile? || outdated_lockfile?(packages))
+    end
+
+    private def outdated_lockfile?(packages)
+      return true if locks.version != Shards::Lock::CURRENT_VERSION
+      return true if packages.size != locks.shards.size
+
+      packages.index_by(&.name) != locks.shards.index_by(&.name)
+    end
+  end
+end