gel 0.2.0

data/lib/gel/error.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Gel::ReportableError
+  # Include this module into any exception that should be treated as a
+  # "user facing error" -- that means an error that's user _reportable_,
+  # not necessarily that it's their fault.
+  #
+  # Examples of things that are user-facing errors:
+  #   * unknown subcommand / arguments
+  #   * requesting an unknown gem, or one with a malformed name
+  #   * problems talking to a gem source
+  #   * syntax errors inside a Gemfile or Gemfile.lock
+  #   * dependency resolution failure
+  #   * problems compiling or installing a gem
+  #
+  # In general, anything that's expected to possibly go wrong should at
+  # some point be wrapped in a user error describing the problem in
+  # terms of what they wanted to do. An unwrapped exception reaching the
+  # top in Command#run is a bug: either the exception is itself
+  # reporting a bug (nil reference, typo on a method name, etc), or if
+  # it's a legitimate failure, then the bug is a missing rescue.
+
+  def details
+  end
+
+  def exit_code
+    1
+  end
+end
+
+# Base class for user-facing errors. Errors _can_ directly include
+# ReportableError to bypass this, but absent a specific reason, they
+# should subclass UserError.
+#
+# Prefer narrow-purpose error classes that receive context parameters
+# over raising generic classes with pre-rendered message parameters. The
+# former can do a better job of fully describing the problem when
+# producing detailed CLI output, without filling real code with long
+# message heredocs.
+#
+# 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.)
+class Gel::UserError < StandardError
+  include Gel::ReportableError
+
+  def initialize(**context)
+    @context = context
+
+    super message
+  end
+
+  def [](key)
+    @context.fetch(key)
+  end
+
+  def message
+    self.class.name
+  end
+
+  def inner_backtrace
+    return [] unless cause
+
+    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.path == ignored_bt.last.path
+      bt.pop
+    end
+
+    bt
+  end
+end
+
+module Gel::Error
+  class GemfileEvaluationError < Gel::UserError
+    def initialize(filename:)
+      super
+    end
+
+    def message
+      "Failed to evaluate #{self[:filename].inspect}: #{cause&.message}"
+    end
+
+    def details
+      inner_backtrace.join("\n")
+    end
+  end
+
+  class BrokenStubError < Gel::UserError
+    def initialize(name:)
+      super
+    end
+
+    def message
+      "No available gem supplies a #{self[:name].inspect} executable"
+    end
+  end
+end

data/lib/gel/gemfile_parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Gel::GemfileParser
+  def self.parse(content, filename = nil, lineno = nil)
+    result = GemfileContent.new(filename)
+    context = ParseContext.new(result, filename)
+    if filename
+      context.instance_eval(content, filename, lineno)
+    else
+      context.instance_eval(content)
+    end
+    result
+  rescue ScriptError, StandardError
+    raise Gel::Error::GemfileEvaluationError.new(filename: filename)
+  end
+
+  class ParseContext
+    def initialize(result, filename)
+      @result = result
+
+      @stack = []
+    end
+
+    def source(uri)
+      if block_given?
+        begin
+          @stack << { source: uri }
+          yield
+        ensure
+          @stack.pop
+        end
+      else
+        @result.sources << uri
+      end
+    end
+
+    def git_source(name, &block)
+      @result.git_sources[name] = block
+    end
+
+    def ruby(version, engine: nil, engine_version: nil)
+      req = Gel::Support::GemRequirement.new(version)
+      raise "Running ruby version #{RUBY_VERSION} does not match requested #{version.inspect}" unless req.satisfied_by?(Gel::Support::GemVersion.new(RUBY_VERSION))
+      raise "Running ruby engine #{RUBY_ENGINE} does not match requested #{engine.inspect}" unless !engine || RUBY_ENGINE == engine
+      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))
+      end
+      @result.ruby << [version, engine: engine, engine_version: engine_version]
+    end
+
+    def gem(name, *requirements, **options)
+      options = @result.flatten(options, @stack)
+      @result.add_gem(name, requirements, options)
+    end
+
+    def gemspec
+      if file = Dir["#{File.dirname(@result.filename)}/*.gemspec"].first
+        spec = Gel::GemspecParser.parse(File.read(file), file)
+        gem spec.name, path: "."
+        spec.development_dependencies.each do |name, constraints|
+          gem name, constraints, group: :development
+        end
+      end
+    end
+
+    def group(*names)
+      @stack << { group: names }
+      yield
+    ensure
+      @stack.pop
+    end
+
+    def platforms(*names)
+      @stack << { platforms: names }
+      yield
+    ensure
+      @stack.pop
+    end
+  end
+
+  class GemfileContent
+    attr_reader :filename
+
+    attr_reader :sources
+    attr_reader :git_sources
+    attr_reader :ruby
+
+    attr_reader :gems
+
+    def initialize(filename)
+      @filename = filename
+      @sources = []
+      @git_sources = {}
+      @ruby = []
+      @gems = []
+    end
+
+    def flatten(options, stack)
+      options = options.dup
+      stack.reverse_each do |layer|
+        options.update(layer) { |_, current, outer| current }
+      end
+      @git_sources.each do |key, block|
+        next unless options.key?(key)
+        raise "Multiple git sources specified" if options.key?(:git)
+        options[:git] = block.call(options.delete(key))
+      end
+      options
+    end
+
+    def add_gem(name, requirements, options)
+      return if name == "bundler"
+      raise "Only git sources can specify a :branch" if options[:branch] && !options[:git]
+      raise "Duplicate entry for gem #{name.inspect}" if @gems.assoc(name)
+
+      @gems << [name, requirements, options]
+    end
+
+    def autorequire(target, gems = self.gems)
+      gems.each do |name, _version, options|
+        next if options[:require] == false
+
+        if [nil, true].include?(options[:require])
+          alt_name = name.include?("-") && name.tr("-", "/")
+          if target.gem_has_file?(name, name)
+            target.scoped_require name, name
+          elsif alt_name && target.gem_has_file?(name, alt_name)
+            target.scoped_require name, alt_name
+          elsif options[:require] == true
+            target.scoped_require name, name
+          end
+        elsif options[:require].is_a?(Array)
+          options[:require].each do |path|
+            target.scoped_require name, path
+          end
+        else
+          target.scoped_require name, options[:require]
+        end
+      end
+    end
+  end
+end

data/lib/gel/gemspec_parser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+class Gel::GemspecParser
+  module Context
+    def self.context
+      binding
+    end
+
+    module Gem
+      Version = Gel::Support::GemVersion
+      Requirement = Gel::Support::GemRequirement
+
+      VERSION = "2.99.0"
+
+      module Platform
+        RUBY = "ruby"
+      end
+
+      module Specification
+        def self.new(name = nil, version = nil, &block)
+          result = Result.new
+          result.name = name
+          result.version = version
+          block.call result
+          result
+        end
+      end
+    end
+  end
+
+  class Result < OpenStruct
+    def initialize
+      super
+      self.specification_version = nil
+      self.metadata = {}
+      self.requirements = []
+      self.rdoc_options = []
+      self.development_dependencies = []
+      self.runtime_dependencies = []
+      self.executables = []
+    end
+
+    def add_development_dependency(name, *versions)
+      development_dependencies << [name, versions.flatten]
+    end
+
+    def add_runtime_dependency(name, *versions)
+      runtime_dependencies << [name, versions.flatten]
+    end
+    alias add_dependency add_runtime_dependency
+  end
+
+  def self.parse(content, filename, lineno = 1, root: File.dirname(filename), isolate: true)
+    filename = File.expand_path(filename)
+    root = File.expand_path(root)
+
+    if isolate
+      in_read, in_write = IO.pipe
+      out_read, out_write = IO.pipe
+
+      pid = spawn({ "RUBYLIB" => Gel::Environment.modified_rubylib, "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))",
+                  filename, lineno.to_s, root,
+                  in: in_read, out: out_write)
+
+      in_read.close
+      out_write.close
+
+      write_thread = Thread.new do
+        in_write.write content
+        in_write.close
+      end
+
+      read_thread = Thread.new do
+        out_read.read
+      end
+
+      _, status = Process.waitpid2(pid)
+      raise "Gemspec parse failed" unless status.success?
+
+      write_thread.join
+      Marshal.load read_thread.value
+
+    else
+      Dir.chdir(root) do
+        Context.context.eval(content, filename, lineno)
+      end
+    end
+  end
+end

data/lib/gel/git_catalog.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "path_catalog"
+
+class Gel::GitCatalog
+  attr_reader :git_depot, :remote, :ref_type, :ref
+
+  def initialize(git_depot, remote, ref_type, ref)
+    @git_depot = git_depot
+    @remote = remote
+    @ref_type = ref_type
+    @ref = ref
+
+    @monitor = Monitor.new
+    @result = nil
+  end
+
+  def checkout_result
+    @result ||
+      @monitor.synchronize { @result ||= git_depot.resolve_and_checkout(remote, ref) }
+  end
+
+  def revision
+    checkout_result[0]
+  end
+
+  def gem_info(name)
+    path_catalog.gem_info(name)
+  end
+
+  def path_catalog
+    @path_catalog ||= Gel::PathCatalog.new(checkout_result[1])
+  end
+
+  def prepare
+    checkout_result
+  end
+end

data/lib/gel/git_depot.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+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)
+  end
+
+  def git_path(remote, revision)
+    short = File.basename(remote, ".git")
+    File.join(@store.root, "git", "#{short}-#{revision[0..12]}")
+  end
+
+  # Returns a path containing a local mirror of the given remote.
+  #
+  # If the mirror already exists, yields the path (same as the return
+  # value); if the block returns false the mirror will be updated.
+  def remote(remote)
+    cache_dir = "#{@mirror_root}/#{ident(remote)}"
+
+    if Dir.exist?(cache_dir)
+      if block_given? && !yield(cache_dir)
+        # The block didn't like what it saw; try updating the mirror
+        # from upstream
+        status = git(remote, "remote", "update", chdir: cache_dir)
+        raise "git remote update failed" unless status.success?
+      end
+    else
+      status = git(remote, "clone", "--mirror", remote, cache_dir)
+      raise "git clone --mirror failed" unless status.success?
+    end
+
+    cache_dir
+  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?
+
+    w.close
+
+    r.read.chomp
+  end
+
+  def resolve_and_checkout(remote, ref)
+    revision = resolve(remote, ref)
+    [revision, checkout(remote, revision)]
+  end
+
+  def checkout(remote, revision)
+    destination = git_path(remote, revision)
+    return destination if Dir.exist?(destination)
+
+    mirror = remote(remote) do |cache_dir|
+      # Check whether the revision is already in our mirror
+      status = git(remote, "rev-list", "--quiet", revision, chdir: cache_dir)
+      status.success?
+    end
+
+    status = git(remote, "clone", mirror, destination)
+    raise "git clone --local failed" unless status.success?
+
+    status = git(remote, "checkout", "--detach", "--force", revision, chdir: destination)
+    raise "git checkout failed" unless status.success?
+
+    destination
+  end
+
+  private
+
+  def git(remote, *arguments, **kwargs)
+    kwargs[:in] ||= IO::NULL
+    kwargs[:out] ||= IO::NULL
+    kwargs[:err] ||= IO::NULL
+
+    t = Time.now
+    pid = spawn("git", *arguments, **kwargs)
+    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" }
+
+    status
+  end
+
+  def ident(remote)
+    short = File.basename(remote, ".git")
+    digest = Digest(: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}'"
+    end
+  end
+
+  def command_for_log(*parts)
+    parts.map { |part| shellword(part) }.join(" ")
+  end
+
+  def logger
+    Logger
+  end
+end