gel 0.3.0 → 0.8.0.pre1

data/lib/gel/package/abortable.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kernel
+  module_function
+
+  alias_method :abort_without_gel, :abort
+  singleton_class.undef_method :abort
+
+  def abort(message = nil)
+    IO.open(3, "w") { |f| f.write(message) }
+    abort_without_gel(message)
+  end
+  private :abort
+end
+
+class << Process
+  public :abort
+end

data/lib/gel/package/installer.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "pathname"
 require "rbconfig"
 require "tempfile"
 require "shellwords"
 
+require_relative "../util"
+
 class Gel::Package::Installer
   def initialize(store)
     @store = store
@@ -22,7 +22,7 @@ class Gel::Package::Installer
     g
   end
 
-  class GemInstaller
+  class GemCompiler
     attr_reader :spec, :store, :root, :build_path
 
     def initialize(spec, store)
@@ -30,7 +30,13 @@ class Gel::Package::Installer
       @root_store = store
 
       if store.is_a?(Gel::MultiStore)
-        store = store[spec.architecture, spec.extensions.any?]
+        platform_parts = []
+        platform_parts << spec.platform if spec.platform && spec.platform != "ruby"
+        platform_parts << spec.architecture if spec.architecture
+
+        platform_dir = platform_parts.join("-") unless platform_parts.empty?
+
+        store = store[platform_dir, spec.extensions.any?]
       end
       @store = store
 
@@ -39,25 +45,21 @@ class Gel::Package::Installer
       @config = Gel::Environment.config
 
       @root = store.gem_root(spec.name, spec.version)
-      FileUtils.rm_rf(@root) if @root && Dir.exist?(@root)
+      Gel::Util.rm_rf(@root) if @root && Dir.exist?(@root)
 
       if spec.extensions.any?
         @build_path = store.extension_path(spec.name, spec.version)
-        FileUtils.rm_rf(@build_path) if @build_path && Dir.exist?(@build_path)
+        Gel::Util.rm_rf(@build_path) if @build_path && Dir.exist?(@build_path)
       else
         @build_path = nil
       end
-
-      @files = {}
-      @installed_files = []
-      spec.require_paths.each { |reqp| @files[reqp] = [] }
     end
 
     def abort!
-      $stderr.puts "FileUtils.rm_rf(#{root.inspect})" if root
-      $stderr.puts "FileUtils.rm_rf(#{build_path.inspect})" if build_path
-      #FileUtils.rm_rf(root) if root
-      #FileUtils.rm_rf(build_path) if build_path
+      $stderr.puts "Gel::Util.rm_rf(#{root.inspect})" if root
+      $stderr.puts "Gel::Util.rm_rf(#{build_path.inspect})" if build_path
+      #Gel::Util.rm_rf(root) if root
+      #Gel::Util.rm_rf(build_path) if build_path
     end
 
     def needs_compile?
@@ -71,8 +73,8 @@ class Gel::Package::Installer
     def with_build_environment(ext, install_dir)
       work_dir = File.expand_path(File.dirname(ext), root)
 
-      FileUtils.mkdir_p(install_dir)
-      short_install_dir = Pathname.new(install_dir).relative_path_from(Pathname.new(work_dir)).to_s
+      Gel::Util.mkdir_p(install_dir)
+      short_install_dir = Gel::Util.relative_path(work_dir, install_dir)
 
       local_config = Tempfile.new(["config", ".rb"])
       local_config.write(<<-RUBY)
@@ -114,7 +116,7 @@ class Gel::Package::Installer
           lockfile = Tempfile.new(["#{spec.name}.lockfile", ".lock"])
           lockfile.close
 
-          Gel::Environment.lock(store: @root_store, output: nil, gemfile: Gel::GemfileParser.parse(File.read(gemfile.path), gemfile.path, 1), lockfile: lockfile.path)
+          Gel::Environment.write_lock(store: @root_store, output: nil, gemfile: Gel::GemfileParser.parse(File.read(gemfile.path), gemfile.path, 1), lockfile: lockfile.path)
 
           lockfile
         end
@@ -133,71 +135,93 @@ class Gel::Package::Installer
       }
     end
 
-    def build_command(work_dir, log, *command, rake: false, **options)
+    def build_command(work_dir, log, *command, rake: false, abortable: false, **options)
       env = build_environment(rake: rake)
       env.merge!(command.shift) if command.first.is_a?(Hash)
 
+      options.update(chdir: work_dir, in: IO::NULL, [:out, :err] => log)
+
+      if abortable
+        abort_r, abort_w = IO.pipe
+        options.update(3 => abort_w)
+      end
+
       pid = spawn(
         env,
         *command,
-        chdir: work_dir,
-        in: IO::NULL,
-        [:out, :err] => log,
-        **options,
+        options,
       )
 
+      if abortable
+        abort_w.close
+
+        abort_message = abort_r.read
+        abort_message = nil if abort_message.strip.empty?
+      end
+
       _, status = Process.waitpid2(pid)
-      status
+
+      if abortable
+        [status, abort_message]
+      else
+        status
+      end
     end
 
     def compile_extconf(ext, install_dir)
       with_build_environment(ext, install_dir) do |work_dir, short_install_dir, local_config_path, log|
-        status = build_command(
+        status, abort = build_command(
           work_dir, log,
           { "MAKEFLAGS" => "-j3" },
           RbConfig.ruby,
+          "-r", File.expand_path("abortable", __dir__),
           "-r", local_config_path,
           File.basename(ext),
           *Shellwords.shellsplit(@config[:build, @spec.name] || ""),
+          abortable: true
         )
-        raise "extconf exited with #{status.exitstatus}" unless status.success?
+        raise Gel::Error::ExtensionBuildError.new(program_name: "extconf", exitstatus: status.exitstatus, abort: abort, log: log.path) unless status.success?
 
         _status = build_command(work_dir, log, "make", "clean", "DESTDIR=")
         # Ignore exit status
 
         status = build_command(work_dir, log, "make", "-j3", "DESTDIR=")
-        raise "make exited with #{status.exitstatus}" unless status.success?
+        raise Gel::Error::ExtensionBuildError.new(program_name: "make", exitstatus: status.exitstatus, log: log.path) unless status.success?
 
         status = build_command(work_dir, log, "make", "install", "DESTDIR=")
-        raise "make install exited with #{status.exitstatus}" unless status.success?
+        raise Gel::Error::ExtensionBuildError.new(program_name: "make install", exitstatus: status.exitstatus, log: log.path) unless status.success?
       end
     end
 
     def compile_rakefile(ext, install_dir)
       with_build_environment(ext, install_dir) do |work_dir, short_install_dir, local_config_path, log|
         if File.basename(ext) =~ /mkrf_conf/i
-          status = build_command(
+          status, abort = build_command(
             work_dir, log,
             RbConfig.ruby,
+            "-r", File.expand_path("abortable", __dir__),
             "-r", local_config_path,
             File.basename(ext),
             rake: true,
+            abortable: true
           )
-          raise Gel::Error::ExtensionBuildError.new(program_name: "mkrf_conf", exitstatus: status.exitstatus) unless status.success?
+          raise Gel::Error::ExtensionBuildError.new(program_name: "mkrf_conf", exitstatus: status.exitstatus, abort: abort, log: log.path) unless status.success?
         end
 
-        status = build_command(
+        status, abort = build_command(
           work_dir, log,
           { "RUBYARCHDIR" => short_install_dir, "RUBYLIBDIR" => short_install_dir },
           RbConfig.ruby,
+          "-r", File.expand_path("abortable", __dir__),
           "-r", File.expand_path("../command", __dir__),
           "-e", "Gel::Command.run(ARGV)",
           "--",
           "exec",
           "rake",
           rake: true,
+          abortable: true
         )
-        raise Gel::Error::ExtensionBuildError.new(program_name: "rake", exitstatus: status.exitstatus) unless status.success?
+        raise Gel::Error::ExtensionBuildError.new(program_name: "rake", exitstatus: status.exitstatus, abort: abort, log: log.path) unless status.success?
       end
     end
 
@@ -215,29 +239,60 @@ class Gel::Package::Installer
         end
       end
     end
+  end
 
-    def install
-      loadable_file_types = ["rb", RbConfig::CONFIG["DLEXT"], RbConfig::CONFIG["DLEXT2"]].compact.reject(&:empty?)
-      loadable_file_types_re = /\.#{Regexp.union loadable_file_types}\z/
-      loadable_file_types_pattern = "*.{#{loadable_file_types.join(",")}}"
+  class GitCompiler < GemCompiler
+    def initialize(spec, store, path)
+      super(spec, store)
 
-      store.add_gem(spec.name, spec.version, spec.bindir, spec.executables, spec.require_paths, spec.runtime_dependencies, spec.extensions.any?) do
-        is_first = true
+      @root = @build_path = path
+    end
+  end
+
+  class GemInstaller < GemCompiler
+    def initialize(spec, store)
+      super
+
+      @files = {}
+      @installed_files = []
+      spec.require_paths&.each { |reqp| @files[reqp] = [] }
+    end
+
+    def install
+      store.add_gem(spec.name, spec.version, spec.bindir, spec.executables, spec.require_paths, spec.runtime_dependencies, spec.required_ruby_version, spec.extensions.any?) do
+        first_require_path = true
         spec.require_paths.each do |reqp|
-          location = is_first ? spec.version : [spec.version, reqp]
-          store.add_lib(spec.name, location, @files[reqp].map { |s| s.sub(loadable_file_types_re, "") })
-          is_first = false
+          add_libs(spec, reqp, @files[reqp], first_subdir: first_require_path)
+          first_require_path = false
         end
 
         if build_path
-          files = Dir["#{build_path}/**/#{loadable_file_types_pattern}"].map do |file|
-            file[build_path.size + 1..-1]
-          end.map do |file|
-            file.sub(loadable_file_types_re, "")
+          files = Gel::Util.loadable_files(build_path)
+          add_libs(spec, Gel::StoreGem::EXTENSION_SUBDIR_TOKEN, files, first_subdir: false)
+        end
+      end
+    end
+
+    def add_libs(spec, subdir, files, first_subdir:)
+      hash = {}
+
+      files.each do |s|
+        basename, ext = Gel::Util.split_filename_for_require(s)
+        next if ext.nil?
+        (hash[ext] ||= []) << basename
+      end
+
+      hash.each do |ext, basenames|
+        location =
+          if ext != ".rb"
+            [spec.version, subdir, ext]
+          elsif !first_subdir
+            [spec.version, subdir]
+          else
+            spec.version
           end
 
-          store.add_lib(spec.name, [spec.version, Gel::StoreGem::EXTENSION_SUBDIR_TOKEN], files)
-        end
+        store.add_lib(spec.name, location, basenames)
       end
     end
 
@@ -246,21 +301,41 @@ class Gel::Package::Installer
       raise "invalid filename #{target.inspect} outside #{(root + "/").inspect}" unless target.start_with?("#{root}/")
       return if @installed_files.include?(target)
       @installed_files << target
+      requirable = false
       spec.require_paths.each do |reqp|
         prefix = "#{root}/#{reqp}/"
         if target.start_with?(prefix)
           @files[reqp] << target[prefix.size..-1]
+          requirable = true
         end
       end
-      raise "won't overwrite #{target}" if File.exist?(target)
-      FileUtils.mkdir_p(File.dirname(target))
+      exe = spec.executables.find { |e| filename == "#{spec.bindir}/#{e}" }
+
+      if File.exist?(target)
+        real = File.realpath(target)
+
+        if real && real.downcase == target.downcase && real != target && @installed_files.include?(real)
+          if requirable || exe
+            raise "Can't extract #{filename} because it conflicts with #{Gel::Util.relative_path(root, real)} (case-sensitive archive extracting on case-insensitive filesytem?)"
+          else
+            # Test or something? We'll skip it, and just hope it wasn't
+            # important.
+            return
+          end
+        end
+
+        raise "won't overwrite #{target}"
+      end
+
+      Gel::Util.mkdir_p(File.dirname(target))
       mode = 0444
       mode |= source_mode & 0200
       mode |= 0111 if source_mode & 0111 != 0
-      if exe = spec.executables.find { |e| filename == "#{spec.bindir}/#{e}" }
+      if exe
         mode |= 0111
         @root_store.stub_set.add(File.basename(@store.root), [exe])
       end
+
       File.open(target, "wb", mode) do |f|
         f.write io.read
       end

data/lib/gel/package.rb

@@ -3,7 +3,9 @@
 require "zlib"
 require "yaml"
 
+require_relative "support/sha512"
 require_relative "support/tar"
+require_relative "vendor/ruby_digest"
 
 module Gel
   class Package
@@ -24,6 +26,10 @@ module Gel
         @inner.architecture
       end
 
+      def platform
+        @inner.platform
+      end
+
       def bindir
         @inner.bindir
       end
@@ -40,6 +46,10 @@ module Gel
         @inner.extensions
       end
 
+      def required_ruby_version
+        @inner.required_ruby_version&.requirements&.map { |pair| pair.map(&:to_s) }
+      end
+
       def runtime_dependencies
         h = {}
         @inner.dependencies.each do |dep|
@@ -70,7 +80,7 @@ module Gel
       end
 
       def initialize
-        super(%w(Symbol Time), [])
+        super(%w(Symbol Time Date), [])
       end
 
       def find(klass)
@@ -91,7 +101,7 @@ module Gel
       end
 
       class Gem_Specification
-        attr_accessor :architecture, :bindir, :executables, :name, :require_paths, :specification_version, :version, :dependencies, :extensions
+        attr_accessor :architecture, :bindir, :executables, :name, :platform, :require_paths, :specification_version, :version, :dependencies, :extensions, :required_ruby_version
       end
       class Gem_Dependency
         attr_accessor :name, :requirement, :type, :version_requirements
@@ -110,8 +120,15 @@ module Gel
           stream.rewind
 
           checksums.each do |type, map|
-            next unless %w(SHA1 SHA512).include?(type)
-            calculated = Digest(type).hexdigest(data)
+            calculated =
+              case type
+              when "SHA1"
+                Gel::Vendor::RubyDigest::SHA1.hexdigest(data)
+              when "SHA512"
+                Gel::Support::SHA512.hexdigest(data)
+              else
+                next
+              end
             raise "#{type} checksum mismatch on #{filename}" unless calculated == map[filename]
           end
         end

data/lib/gel/path_catalog.rb

@@ -27,7 +27,7 @@ class Gel::PathCatalog
     gemspec = gemspec_from(gemspec)
 
     info = {}
-    info[gemspec.version] = {
+    info[Gel::Support::GemVersion.new(gemspec.version).to_s] = {
       dependencies: gemspec.runtime_dependencies,
       ruby: gemspec.required_ruby_version,
     }

data/lib/gel/pinboard.rb

@@ -4,6 +4,7 @@ require_relative "db"
 require_relative "httpool"
 require_relative "tail_file"
 require_relative "work_pool"
+require_relative "vendor/ruby_digest"
 
 # For each URI, this stores:
 #   * the current etag
@@ -117,7 +118,8 @@ class Gel::Pinboard
   def updated(uri, etag, changed = true)
     blocks = nil
     @monitor.synchronize do
-      @db[uri.to_s] = read(uri).merge(etag: etag, stale: false)
+      h = read(uri) || {}
+      @db[uri.to_s] = h.merge(etag: etag, stale: false)
 
       blocks = @waiting.delete(uri)
     end
@@ -135,6 +137,6 @@ class Gel::Pinboard
   private
 
   def mangle_uri(uri)
-    "#{uri.hostname}--#{uri.path.gsub(/[^A-Za-z0-9]+/, "-")}--#{Digest(:SHA256).hexdigest(uri.to_s)[0, 12]}"
+    "#{uri.hostname}--#{uri.path.gsub(/[^A-Za-z0-9]+/, "-")}--#{Gel::Vendor::RubyDigest::SHA256.hexdigest(uri.to_s)[0, 12]}"
   end
 end

data/lib/gel/platform.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Gel::Platform
+  SYNONYMS = [
+    ["ruby", "mri", "rbx"],
+    ["java", "jruby"],
+    ["x64-mingw32", "mswin64", "x64_mingw"],
+    ["x86-mingw32", "mswin", "mingw"],
+  ]
+
+  def self.filter(target_platforms, filter)
+    # Ignore ruby-version constraint tails ("mri_23" => "mri")
+    filter = filter.map { |f| f.sub(/_[0-9]+\z/, "") }
+
+    target_platforms.select do |platform|
+      next true if filter.include?(platform)
+
+      SYNONYMS.any? do |row|
+        row.include?(platform) && !(row & filter).empty?
+      end
+    end
+  end
+
+  def self.match(target_platform, available_platforms)
+    return target_platform if available_platforms.include?(target_platform)
+
+    SYNONYMS.each do |row|
+      next unless row.include?(target_platform)
+
+      overlap = row & available_platforms
+      return overlap.first unless overlap.empty?
+    end
+
+    return "ruby" if available_platforms.include?("ruby")
+
+    nil
+  end
+end

data/lib/gel/pub_grub/package.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Gel::PubGrub
+  ##
+  # Based on PubGrub::Package, but we need some extra tricks
+  class Package
+    attr_reader :name
+    attr_reader :platform
+
+    def initialize(name, platform)
+      @name = name
+      @platform = platform
+    end
+
+    def inspect
+      "#<#{self.class} #{name.inspect} (#{platform})>"
+    end
+
+    def <=>(other)
+      return 1 if other.is_a?(Pseudo)
+      (name <=> other.name).nonzero? || (platform <=> other.platform)
+    end
+
+    def to_s
+      "#{name} (#{platform})"
+    end
+
+    def hash
+      name.hash ^ platform.hash
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) && name.eql?(other.name) && platform.eql?(other.platform)
+    end
+    alias == eql?
+
+    class Pseudo
+      attr_reader :role
+
+      def initialize(role)
+        @role = role
+      end
+
+      def inspect
+        "#<#{self.class} #{role}>"
+      end
+
+      def <=>(other)
+        return -1 unless other.is_a?(Pseudo)
+        role <=> other.role
+      end
+
+      def to_s
+        "[[#{role}]]"
+      end
+
+      def hash
+        role.hash
+      end
+
+      def eql?(other)
+        self.class.eql?(other.class) && role.eql?(other.role)
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/gel/pub_grub/preference_strategy.rb

@@ -2,8 +2,8 @@
 
 module Gel::PubGrub
   class PreferenceStrategy
-    def initialize(loader, overrides, bump: :major, strict: false)
-      @loader = loader
+    def initialize(gem_set, overrides, bump: :major, strict: false)
+      @gem_set = gem_set
       @overrides = overrides
       @bump = bump
       @strict = strict
@@ -12,7 +12,7 @@ module Gel::PubGrub
     # Overrides first, then packages for which we have a preference (and
     # that preference is still in play), then everything else.
     def package_priority(package, versions)
-      if package.name =~ /^~/
+      if package.is_a?(Package::Pseudo)
         -1000
       elsif @overrides.key?(package.name)
         -100
@@ -34,8 +34,12 @@ module Gel::PubGrub
       versions.partition { |version| range.satisfied_by?(version) }.inject(:+)
     end
 
+    def refresh_git?(name)
+      @overrides.key?(name) || @bump != :hold
+    end
+
     def constraints
-      ranges = @strict ? self.ranges : @overrides
+      ranges = @strict ? ranges() : @overrides
 
       result = {}
       ranges.each do |package_name, range|
@@ -50,10 +54,10 @@ module Gel::PubGrub
       @ranges ||=
         begin
           result = @overrides.dup
-          @loader.each_gem do |section, body, name, version, platform, deps|
+          @gem_set.gems.each do |name, resolved_gems|
             next if @overrides.key?(name)
 
-            result[name] = range_for(version, @bump)
+            result[name] = range_for(resolved_gems.first.version, @bump)
           end
           result.delete_if { |_, v| !v }
           result

data/lib/gel/pub_grub/solver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "source"
+
+class Gel::PubGrub::Solver < Gel::Vendor::PubGrub::VersionSolver
+  def self.logger
+    ::Gel::Vendor::PubGrub.logger
+  end
+
+  def initialize(gemfile:, catalog_set:, platforms:, strategy:)
+    source = Gel::PubGrub::Source.new(gemfile, catalog_set, platforms, strategy)
+
+    super(source: source, root: source.root)
+
+    @strategy = strategy
+  end
+
+  def next_package_to_try
+    self.solution.unsatisfied.min_by do |term|
+      package = term.package
+      versions = self.source.versions_for(package, term.constraint.range)
+
+      if @strategy
+        @strategy.package_priority(package, versions) + @package_depth[package]
+      else
+        @package_depth[package]
+      end * 1000 + versions.count
+    end.package
+  end
+
+  def each_resolved_package(&block)
+    result.each do |package, version|
+      next if package.is_a?(Gel::PubGrub::Package::Pseudo)
+      yield package, version
+    end
+  end
+end