gel 0.3.0 → 0.8.0.pre1

data/lib/gel/error.rb

@@ -41,39 +41,60 @@ end
 # Define all UserError subclasses in this file. (Non-reportable errors,
 # which describe errors in interaction between internal components, can
 # and should be defined whereever they're used.)
+#
+# To support special cases where external API dictates a different
+# superclass (e.g. an UnsatisfiedDependencyError must be a ::LoadError),
+# while retaining most of the conveniences, it's also possible to
+# include the Gel::UserError::Impl module directly.
 class Gel::UserError < StandardError
-  include Gel::ReportableError
+  module Impl
+    include Gel::ReportableError
 
-  def initialize(**context)
-    @context = context
+    def set_context(context)
+      @context = context
+    end
 
-    super message
-  end
+    def [](key)
+      @context.fetch(key)
+    end
 
-  def [](key)
-    @context.fetch(key)
-  end
+    def message
+      self.class.name
+    end
 
-  def message
-    self.class.name
-  end
+    def inner_backtrace
+      return [] unless cause
 
-  def inner_backtrace
-    return [] unless cause
+      bt = cause.backtrace_locations
+      ignored_bt = backtrace_locations
 
-    bt = cause.backtrace_locations
-    ignored_bt = backtrace_locations
+      while bt.last.to_s == ignored_bt.last.to_s
+        bt.pop
+        ignored_bt.pop
+      end
 
-    while bt.last.to_s == ignored_bt.last.to_s
-      bt.pop
-      ignored_bt.pop
-    end
+      while bt.last.path == ignored_bt.last.path
+        bt.pop
+      end
 
-    while bt.last.path == ignored_bt.last.path
-      bt.pop
+      bt
     end
+  end
+
+  include Impl
+
+  def initialize(**context)
+    set_context context
+    super message
+  end
+end
 
-    bt
+class Gel::LoadError < ::LoadError
+  include Gel::UserError::Impl
+
+  def initialize(**context)
+    set_context context
+    super message
   end
 end
 
@@ -122,6 +143,18 @@ module Gel::Error
     end
   end
 
+  class OutdatedLockfileError < Gel::UserError
+    def message
+      "Lockfile out of date; use 'gel lock' or 'gel install' to re-resolve"
+    end
+  end
+
+  class NoLockfileError < OutdatedLockfileError
+    def message
+      "Gemfile has not been resolved; use 'gel lock' or 'gel install' to resolve"
+    end
+  end
+
   class UnexpectedConfigError < Gel::UserError
     def initialize(line:)
       super
@@ -143,12 +176,32 @@ module Gel::Error
   end
 
   class ExtensionBuildError < Gel::UserError
-    def initialize(program_name:, exitstatus:)
+    def initialize(program_name:, exitstatus:, log:, abort: nil)
+      super
+    end
+
+    def message
+      if self[:exitstatus] == 1 && self[:abort]
+        abort_message = self[:abort]
+
+        if abort_message.include?("\n") || abort_message.size > 100
+          "#{self[:program_name].inspect} aborted:\n#{abort_message.gsub(/^/, "  ")}"
+        else
+          "#{self[:program_name].inspect} aborted: #{abort_message.sub(/\A[\[({]?(?:error|err|abort|fatal)[\])}]?:?\s+/i, "")}"
+        end
+      else
+        "#{self[:program_name].inspect} exited with #{self[:exitstatus].inspect}"
+      end + "\n\nBuild log: #{self[:log]}"
+    end
+  end
+
+  class ExtensionDependencyError < Gel::UserError
+    def initialize(dependency:, failure:)
       super
     end
 
     def message
-      "#{self[:program_name].inspect} exited with #{self[:exitstatus].inspect}"
+      "Depends on #{self[:dependency].inspect}, which failed to #{self[:failure]}"
     end
   end
 
@@ -202,9 +255,88 @@ module Gel::Error
     end
   end
 
+  class UnsatisfiableRubyVersionError < Gel::UserError
+    def initialize(name:, running:, attempted_platforms:)
+      super
+    end
+
+    def message
+      "None of the available #{self[:name].inspect} packages are compatible with Ruby version #{self[:running].inspect}. Found: #{self[:attempted_platforms].inspect}"
+    end
+  end
+
+  class MissingGemError < Gel::UserError
+    def initialize(name:)
+      super
+    end
+
+    def message
+      "Missing gem #{self[:name].inspect}. Do you need to 'gel install'?"
+    end
+  end
+
+  class AlreadyActivatedError < Gel::LoadError
+    def initialize(name:, existing:, requirements: nil, requested: nil, why:)
+      raise ArgumentError, "exactly one of :requirements and :requested must be supplied" unless requirements.nil? != requested.nil?
+      super
+    end
+
+    def message
+      "Already activated #{self[:name].inspect} #{self[:existing]}" +
+        if self[:requirements]
+          ", which is incompatible with: #{self[:requirements]}"
+        else
+          "; cannot also activate #{self[:requested]}"
+        end +
+        (self[:why] ? " (#{self[:why].join("; ")})" : "")
+    end
+  end
+
+  class UnsatisfiedDependencyError < Gel::LoadError
+    def initialize(name:, was_locked:, found_any:, requirements:, why:)
+      super
+    end
+
+    def message
+      if self[:was_locked]
+        if self[:found_any]
+          "Locked version of gem #{self[:name].inspect} does not satisfy requirements: #{self[:requirements]}"
+        else
+          "Gem #{self[:name].inspect} is not present in Gemfile; unable to satisfy requirements: #{self[:requirements]}"
+        end
+      else
+        if self[:found_any]
+          "No available version of gem #{self[:name].inspect} satisfies requirements: #{self[:requirements]}"
+        else
+          "No version of gem #{self[:name].inspect} is installed; unable to satisfy requirements: #{self[:requirements]}"
+        end
+      end + (self[:why] ? " (#{self[:why].join("; ")})" : "")
+    end
+  end
+
+  class MissingExecutableError < Gel::UserError
+    def initialize(executable:, gem_name:, gem_versions:, locked_gem_version:)
+      super
+    end
+
+    def message
+      "Locked gem #{self[:gem_name].inspect} #{self[:locked_gem_version].inspect} does not supply executable #{self[:executable].inspect}. Found in other installed versions: #{self[:gem_versions].inspect}"
+    end
+  end
+
   class ParsedGemspecError < Gel::UserError
     def message
       "Gemspec parse failed"
     end
   end
+
+  class GitResolveError < Gel::UserError
+    def initialize(remote:, ref:)
+      super
+    end
+
+    def message
+      "Unable to resolve #{self[:ref].inspect} in git repository #{self[:remote].inspect}"
+    end
+  end
 end

data/lib/gel/gemfile_parser.rb

@@ -14,6 +14,29 @@ module Gel::GemfileParser
     raise Gel::Error::GemfileEvaluationError.new(filename: filename)
   end
 
+  def self.inline(&block)
+    filename, _lineno = block.source_location
+
+    result = GemfileContent.new(filename)
+    context = ParseContext.new(result, filename)
+    context.instance_eval(&block)
+    result
+  end
+
+  class RunningRuby
+    def self.version
+      RUBY_VERSION
+    end
+
+    def self.engine
+      RUBY_ENGINE
+    end
+
+    def self.engine_version
+      RUBY_ENGINE_VERSION
+    end
+  end
+
   class ParseContext
     def initialize(result, filename)
       @result = result
@@ -38,29 +61,40 @@ module Gel::GemfileParser
       @result.git_sources[name] = block
     end
 
-    def ruby(version, engine: nil, engine_version: nil)
-      req = Gel::Support::GemRequirement.new(version)
-      unless req.satisfied_by?(Gel::Support::GemVersion.new(RUBY_VERSION))
+    def ruby(*versions, engine: nil, engine_version: nil)
+      req = Gel::Support::GemRequirement.new(versions)
+      running_ruby_version = RunningRuby.version
+      running_engine = RunningRuby.engine
+      running_engine_version = RunningRuby.engine_version
+
+      unless req.satisfied_by?(Gel::Support::GemVersion.new(running_ruby_version))
         raise Gel::Error::MismatchRubyVersionError.new(
-          running: RUBY_VERSION,
-          requested: version,
+          running: running_ruby_version,
+          requested: versions,
         )
       end
-      unless !engine || RUBY_ENGINE == engine
+      unless !engine || running_engine == engine
         raise Gel::Error::MismatchRubyEngineError.new(
-          running: RUBY_ENGINE,
+          running: running_engine,
           engine: engine,
         )
       end
       if engine_version
         raise "Cannot specify :engine_version without :engine" unless engine
-        req = Gel::Support::GemRequirement.new(version)
-        raise "Running ruby engine version #{RUBY_ENGINE_VERSION} does not match requested #{engine_version.inspect}" unless req.satisfied_by?(Gel::Support::GemVersion.new(RUBY_ENGINE_VERSION))
+        req = Gel::Support::GemRequirement.new(engine_version)
+        raise "Running ruby engine version #{running_engine_version} does not match requested #{engine_version.inspect}" unless req.satisfied_by?(Gel::Support::GemVersion.new(running_engine_version))
       end
-      @result.ruby << [version, engine: engine, engine_version: engine_version]
+      @result.ruby << [versions, engine: engine, engine_version: engine_version]
     end
 
     def gem(name, *requirements, **options)
+      aliases = GemfileContent::OPTION_ALIASES
+      options.keys.each do |key|
+        if original = aliases[key]
+          raise "Duplicate key #{key.inspect} == #{original.inspect}" if options.key?(original)
+          options[original] = options.delete(key)
+        end
+      end
       options = @result.flatten(options, @stack)
       @result.add_gem(name, requirements, options)
     end
@@ -77,8 +111,8 @@ module Gel::GemfileParser
       else
         spec = gemspecs[0]
         gem spec.name, path: path
-        spec.development_dependencies.each do |name, constraints|
-          gem name, constraints, group: development_group
+        spec.development_dependencies.each do |dep_name, constraints|
+          gem dep_name, constraints, group: development_group
         end
       end
     end
@@ -90,6 +124,20 @@ module Gel::GemfileParser
       @stack.pop
     end
 
+    def install_if(*conditions)
+      @stack << { install_if: conditions }
+      yield
+    ensure
+      @stack.pop
+    end
+
+    def path(*names)
+      @stack << { path: names }
+      yield
+    ensure
+      @stack.pop
+    end
+
     def platforms(*names)
       @stack << { platforms: names }
       yield
@@ -99,6 +147,10 @@ module Gel::GemfileParser
   end
 
   class GemfileContent
+    OPTION_ALIASES = {
+      platform: :platforms,
+    }
+
     attr_reader :filename
 
     attr_reader :sources
@@ -133,6 +185,12 @@ module Gel::GemfileParser
       raise "Only git sources can specify a :branch" if options[:branch] && !options[:git]
       raise "Duplicate entry for gem #{name.inspect}" if @gems.assoc(name)
 
+      if options[:install_if]
+        options[:install_if] = Array(options[:install_if]).all? do |condition|
+          condition.respond_to?(:call) ? condition.call : condition
+        end
+      end
+
       @gems << [name, requirements, options]
     end
 
@@ -158,5 +216,9 @@ module Gel::GemfileParser
         end
       end
     end
+
+    def gem_names
+      @gems.map(&:first).flatten.map(&:to_s)
+    end
   end
 end

data/lib/gel/gemspec_parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ostruct"
-
 class Gel::GemspecParser
   module Context
     def self.context
@@ -30,16 +28,19 @@ class Gel::GemspecParser
     end
   end
 
-  class Result < OpenStruct
+  class Result
     def initialize
-      super
+      @values = {}
+
       self.specification_version = nil
       self.metadata = {}
       self.requirements = []
       self.rdoc_options = []
+      self.extra_rdoc_files = []
       self.development_dependencies = []
       self.runtime_dependencies = []
       self.executables = []
+      self.extensions = []
     end
 
     def add_development_dependency(name, *versions)
@@ -50,6 +51,18 @@ class Gel::GemspecParser
       runtime_dependencies << [name, versions.flatten]
     end
     alias add_dependency add_runtime_dependency
+
+    def method_missing(name, *args)
+      if name =~ /(.*)=$/
+        @values[$1.to_sym] = args.first
+      else
+        @values[name]
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      name != :marshal_dump && name != :_dump
+    end
   end
 
   def self.parse(content, filename, lineno = 1, root: File.dirname(filename), isolate: true)
@@ -60,13 +73,19 @@ class Gel::GemspecParser
       in_read, in_write = IO.pipe
       out_read, out_write = IO.pipe
 
-      pid = spawn({ "RUBYLIB" => Gel::Environment.modified_rubylib, "GEL_GEMFILE" => "", "GEL_LOCKFILE" => "" },
+      pid = spawn({
+                    "RUBYLIB" => Gel::Environment.modified_rubylib,
+                    "RUBYOPT" => "",
+                    "GEL_DEBUG" => nil,
+                    "GEL_GEMFILE" => "",
+                    "GEL_LOCKFILE" => "",
+                  },
                   RbConfig.ruby,
                   "-r", File.expand_path("compatibility", __dir__),
                   "-r", File.expand_path("gemspec_parser", __dir__),
-                  "-e", "puts Marshal.dump(Gel::GemspecParser.parse($stdin.read, ARGV.shift, ARGV.shift.to_i, root: ARGV.shift, isolate: false))",
+                  "-e", "IO.new(3, 'w').write Marshal.dump(Gel::GemspecParser.parse($stdin.read, ARGV.shift, ARGV.shift.to_i, root: ARGV.shift, isolate: false))",
                   filename, lineno.to_s, root,
-                  in: in_read, out: out_write)
+                  in: in_read, 3 => out_write)
 
       in_read.close
       out_write.close

data/lib/gel/git_catalog.rb

@@ -5,11 +5,12 @@ require_relative "path_catalog"
 class Gel::GitCatalog
   attr_reader :git_depot, :remote, :ref_type, :ref
 
-  def initialize(git_depot, remote, ref_type, ref)
+  def initialize(git_depot, remote, ref_type, ref, revision = nil)
     @git_depot = git_depot
     @remote = remote
     @ref_type = ref_type
     @ref = ref
+    @revision = revision
 
     @monitor = Monitor.new
     @result = nil
@@ -17,11 +18,18 @@ class Gel::GitCatalog
 
   def checkout_result
     @result ||
-      @monitor.synchronize { @result ||= git_depot.resolve_and_checkout(remote, ref) }
+      @monitor.synchronize do
+        @result ||=
+          if @revision
+            [@revision, git_depot.checkout(remote, @revision)]
+          else
+            git_depot.resolve_and_checkout(remote, ref)
+          end
+      end
   end
 
   def revision
-    checkout_result[0]
+    @revision || checkout_result[0]
   end
 
   def gem_info(name)
@@ -35,4 +43,8 @@ class Gel::GitCatalog
   def prepare
     checkout_result
   end
+
+  def path
+    git_depot.git_path(remote, revision)
+  end
 end

data/lib/gel/git_depot.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "vendor/ruby_digest"
+
 class Gel::GitDepot
   attr_reader :mirror_root
 
-  require "logger"
-  Logger = ::Logger.new($stderr)
-  Logger.level = $DEBUG ? ::Logger::DEBUG : ::Logger::WARN
-
   def initialize(store, mirror_root = (ENV["GEL_CACHE"] || "~/.cache/gel") + "/git")
     @store = store
     @mirror_root = File.expand_path(mirror_root)
@@ -40,15 +38,42 @@ class Gel::GitDepot
   end
 
   def resolve(remote, ref)
-    mirror = remote(remote) { false } # always update mirror
-
-    r, w = IO.pipe
-    status = git(remote, "rev-parse", ref || "HEAD", chdir: mirror, out: w)
-    raise "git rev-parse failed" unless status.success?
+    if ref
+      # ref could be an arbitrarily-complex ref (HEAD~3 or whatever), so
+      # update our mirror and then resolve it locally
+
+      mirror = remote(remote) { false } # always update mirror
+
+      r, w = IO.pipe
+      status = git(remote, "rev-parse", ref || "HEAD", chdir: mirror, out: w)
+      w.close
+
+      if status.success?
+        r.read.chomp
+      else
+        # We didn't keep stderr, but we can infer the nature of the problem
+        # from whether git produced any output: for simple "I don't know what
+        # that is" errors, it returns the input, while more fundamental
+        # problems die earlier and return nothing.
+        if r.read.chomp.empty?
+          # This is an internal error: our mirror must be broken
+          raise "git rev-parse failed"
+        else
+          # This is a user error: the ref doesn't exist
+          raise Gel::Error::GitResolveError.new(remote: remote, ref: ref)
+        end
+      end
+    else
+      # If we just want to know the remote HEAD, we can ask without even
+      # touching our mirror
 
-    w.close
+      r, w = IO.pipe
+      status = git(remote, "ls-remote", remote, "HEAD", out: w)
+      raise "git ls-remote failed" unless status.success?
 
-    r.read.chomp
+      w.close
+      r.read.split.first
+    end
   end
 
   def resolve_and_checkout(remote, ref)
@@ -84,36 +109,45 @@ class Gel::GitDepot
 
     t = Time.now
     pid = spawn("git", *arguments, **kwargs)
-    logger.debug { "#{remote} [#{pid}] #{command_for_log("git", *arguments)}" }
+    logger&.debug { "#{remote} [#{pid}] #{command_for_log("git", *arguments)}" }
 
     _, status = Process.waitpid2(pid)
-    logger.debug { "#{remote} [#{pid}]   process exited #{status.exitstatus} (#{status.success? ? "success" : "failure"}) after #{Time.now - t}s" }
+    logger&.debug { "#{remote} [#{pid}]   process exited #{status.exitstatus} (#{status.success? ? "success" : "failure"}) after #{Time.now - t}s" }
 
     status
   end
 
   def ident(remote)
     short = File.basename(remote, ".git")
-    digest = Digest(:SHA256).hexdigest(remote)[0..12]
+    digest = Gel::Vendor::RubyDigest::SHA256.hexdigest(remote)[0..12]
     "#{short}-#{digest}"
   end
 
-  require "shellwords"
-  def shellword(word)
-    if word =~ /\A[A-Za-z0-9=+\/,.-]+\z/
-      word
-    elsif word =~ /'/
-      "\"#{Shellwords.shellescape(word).gsub(/\\\s/, "\\1")}\""
-    else
-      "'#{word}'"
+  if $DEBUG
+    require "shellwords"
+    def shellword(word)
+      if word =~ /\A[A-Za-z0-9=+\/,.-]+\z/
+        word
+      elsif word =~ /'/
+        "\"#{Shellwords.shellescape(word).gsub(/\\\s/, "\\1")}\""
+      else
+        "'#{word}'"
+      end
     end
-  end
 
-  def command_for_log(*parts)
-    parts.map { |part| shellword(part) }.join(" ")
-  end
+    def command_for_log(*parts)
+      parts.map { |part| shellword(part) }.join(" ")
+    end
 
-  def logger
-    Logger
+    require "logger"
+    Logger = ::Logger.new($stderr)
+    Logger.level = ::Logger::DEBUG
+
+    def logger
+      Logger
+    end
+  else
+    def logger
+    end
   end
 end

data/lib/gel/httpool.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "monitor"
-require "net/http"
 
 class Gel::Httpool
   include MonitorMixin
@@ -25,7 +24,11 @@ class Gel::Httpool
     end
   end
 
-  def request(uri, request = Net::HTTP::Get.new(uri))
+  def request(uri, request = nil)
+    require "net/http"
+
+    request ||= Net::HTTP::Get.new(uri)
+
     with_connection(uri) do |http|
       logger.debug { "GET #{uri}" }