gel 0.2.0

data/lib/gel/catalog/dependency_index.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "set"
+require "cgi"
+require "zlib"
+
+require_relative "../pinboard"
+
+require_relative "common"
+require_relative "marshal_hacks"
+
+class Gel::Catalog::DependencyIndex
+  include Gel::Catalog::Common
+  CACHE_TYPE = "quick"
+
+  LIST_MAX = 40
+
+  def initialize(catalog, *args)
+    super(*args)
+
+    @catalog = catalog
+
+    @active_gems = Set.new
+    @pending_gems = Set.new
+  end
+
+  def prepare(gems)
+    @monitor.synchronize do
+      @pending_gems.merge(gems)
+    end
+    force_refresh_including(gems.first)
+    @monitor.synchronize do
+      @refresh_cond.wait_until { gems.all? { |g| _info(g) } }
+    end
+  end
+
+  def force_refresh_including(gem_name)
+    gems_to_refresh = []
+
+    @monitor.synchronize do
+      return if _info(gem_name) || @active_gems.include?(gem_name)
+
+      gems_to_refresh << gem_name
+      @pending_gems.delete gem_name
+
+      while gems_to_refresh.size < LIST_MAX && @pending_gems.size > 0
+        a_gem = @pending_gems.first
+        @pending_gems.delete a_gem
+        gems_to_refresh << a_gem
+      end
+
+      @active_gems.merge gems_to_refresh
+    end
+
+    refresh_some_gems gems_to_refresh
+  end
+
+  def refresh_some_gems(gems)
+    gem_list = gems.map { |g| CGI.escape(g) }.sort.join(",")
+    @work_pool.queue(gem_list) do
+      response =
+        begin
+          @catalog.send(:http_get, "api/v1/dependencies?gems=#{gem_list}")
+        rescue Exception => ex
+          @monitor.synchronize do
+            @error = ex
+            @refresh_cond.broadcast
+          end
+          next
+        end
+
+      new_info = {}
+      gems.each { |g| new_info[g] = {} }
+
+      new_dependencies = Set.new
+
+      hashes = Marshal.load(response.body)
+      hashes.each do |hash|
+        v = hash[:number].to_s
+        v += "-#{hash[:platform]}" unless hash[:platform] == "ruby"
+
+        (new_info[hash[:name]] ||= {})[v] = {
+          dependencies: hash[:dependencies].map { |name, versions| [name, versions.split(/,\s*/)] },
+          ruby: lambda do
+            # The disadvantage of trying to avoid this per-version
+            # request is that when we do discover we need it, we need it
+            # immediately. :/
+            pinboard.file(uri("quick", "Marshal.4.8", "#{hash[:name]}-#{v}.gemspec.rz"), token: false, tail: false) do |f|
+              data = Zlib::Inflate.inflate(f.read)
+              # TODO: Extract the data we need without a full unmarshal
+              Marshal.load(data).required_ruby_version
+            end
+          end,
+        }
+      end
+
+      hashes.group_by { |h| h[:name] }.each do |_, group|
+        versions = group.group_by { |h| h[:number] }
+        latest = versions.keys.max_by { |v| Gel::Support::GemVersion.new(v) }
+        new_dependencies.merge versions[latest].flat_map { |h| h[:dependencies].map(&:first) }.uniq
+      end
+
+      @monitor.synchronize do
+        @gem_info.update new_info
+        @active_gems.subtract new_info.keys
+
+        @refresh_cond.broadcast
+
+        new_dependencies.subtract @active_gems
+        new_dependencies.subtract @gem_info.keys
+        @pending_gems.merge new_dependencies
+      end
+    end
+
+    @work_pool.start
+  end
+
+  def refresh_gem(gem_name, immediate = false)
+    @monitor.synchronize do
+      @pending_gems << gem_name unless _info(gem_name) || @active_gems.include?(gem_name)
+    end
+
+    force_refresh_including gem_name if immediate
+  end
+end

data/lib/gel/catalog/legacy_index.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "set"
+require "zlib"
+
+require_relative "../pinboard"
+
+require_relative "common"
+require_relative "marshal_hacks"
+
+class Gel::Catalog::LegacyIndex
+  include Gel::Catalog::Common
+  CACHE_TYPE = "quick"
+
+  def initialize(*)
+    super
+
+    @needs_update = true
+    @updating = false
+    @active_gems = Set.new
+    @pending_gems = Set.new
+
+    @gem_versions = {}
+  end
+
+  def prepare(gems)
+    @monitor.synchronize do
+      @pending_gems.merge(gems)
+    end
+    update
+    @monitor.synchronize do
+      @refresh_cond.wait_until { gems.all? { |g| _info(g) } }
+    end
+  end
+
+  def update
+    @monitor.synchronize do
+      return false unless @needs_update
+      @needs_update = false
+      @updating = true
+    end
+
+    specs = false
+    prerelease_specs = false
+
+    versions = {}
+
+    error = lambda do |ex|
+      @monitor.synchronize do
+        @error = ex
+        @updating = false
+        @refresh_cond.broadcast
+      end
+    end
+
+    spec_file_handler = lambda do |for_prerelease|
+      lambda do |f|
+        data = Zlib::GzipReader.new(f).read
+        data = Marshal.load(data)
+
+        data.each do |name, version, platform|
+          v = version.to_s
+          v += "-#{platform}" unless platform == "ruby"
+          (versions[name] ||= {})[v] = nil
+        end
+
+        done = false
+        @monitor.synchronize do
+          if for_prerelease
+            prerelease_specs = true
+          else
+            specs = true
+          end
+
+          if specs && prerelease_specs
+            done = true
+            @gem_info.update versions
+            @updating = false
+            @refresh_cond.broadcast
+          end
+        end
+
+        if done
+          (@active_gems | @pending_gems).each do |name|
+            refresh_gem(name)
+          end
+        end
+      end
+    end
+
+    pinboard.async_file(uri("specs.4.8.gz"), tail: false, error: error, &spec_file_handler.(false))
+    pinboard.async_file(uri("prerelease_specs.4.8.gz"), tail: false, error: error, &spec_file_handler.(true))
+
+    true
+  end
+
+  def refresh_gem(gem_name, immediate = true)
+    update
+
+    versions = nil
+    @monitor.synchronize do
+      if @updating
+        @pending_gems << gem_name
+        return
+      end
+
+      unless info = @gem_info[gem_name]
+        @gem_info[gem_name] = {}
+        @refresh_cond.broadcast
+        return
+      end
+
+      versions = info.keys.select { |v| info[v].nil? }
+      versions.each do |v|
+        info[v] = :pending
+      end
+    end
+
+    loaded_data = {}
+    versions.each do |v|
+      loaded_data[v] = nil
+    end
+
+    versions.each do |v|
+      error = lambda do |ex|
+        @gem_info[gem_name][v] = ex
+        @refresh_cond.broadcast
+      end
+
+      pinboard.async_file(uri("quick", "Marshal.4.8", "#{gem_name}-#{v}.gemspec.rz"), token: false, tail: false, error: error) do |f|
+        data = Zlib::Inflate.inflate(f.read)
+        # TODO: Extract the data we need without a full unmarshal
+        spec = Marshal.load(data)
+
+        @monitor.synchronize do
+          loaded_data[v] = { dependencies: spec.dependencies, ruby: spec.required_ruby_version }
+          if loaded_data.values.all?
+            @gem_info[gem_name].update loaded_data
+            @refresh_cond.broadcast
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def _info(gem_name)
+    if i = super
+      if i.values.all? { |v| v.is_a?(Hash) }
+        i
+      elsif e = i.values.grep(Exception).first
+        raise e
+      end
+    end
+  end
+end

data/lib/gel/catalog/marshal_hacks.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Gem::Specification
+  class Unmarshalled
+    attr_accessor :required_ruby_version
+    attr_accessor :dependencies
+  end
+
+  def self._load(str)
+    array = Marshal.load(str)
+    o = Unmarshalled.new
+    o.required_ruby_version = array[6].as_list
+    o.dependencies = array[9].map { |d| [d.name, d.requirement.as_list] if d.type == :runtime }.compact
+    o
+  end
+end

data/lib/gel/command.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "compatibility"
+require_relative "error"
+
+class Gel::Command
+  def self.run(command_line)
+    command_line = command_line.dup
+    if command_name = extract_word(command_line)
+      const = command_name.downcase.sub(/^./, &:upcase).gsub(/[-_]./) { |s| s[1].upcase }
+      if Gel::Command.const_defined?(const, false)
+        command = Gel::Command.const_get(const, false).new
+        command.run(command_line)
+      elsif Gel::Environment.activate_for_executable(["gel-#{command_name}", command_name])
+        command_name = "gel-#{command_name}" if Gel::Environment.find_executable("gel-#{command_name}")
+        command = Gel::Command::Exec.new
+        command.run([command_name, *command_line])
+      else
+        raise "Unknown command #{command_name.inspect}"
+      end
+    else
+      puts <<~EOF
+      Gel doesn't have a default command; please run `gel install`
+      EOF
+    end
+  rescue Exception => ex
+    raise if $DEBUG || (command && command.reraise)
+    handle_error(ex)
+  end
+
+  def self.handle_error(ex)
+    case ex
+    when Gel::ReportableError
+      $stderr.puts "ERROR: #{ex.message}"
+      if more = ex.details
+        $stderr.puts more
+      end
+
+      exit ex.exit_code
+    when Interrupt
+      # Re-signal so our parent knows why we died
+      Signal.trap(ex.signo, "SYSTEM_DEFAULT")
+      Process.kill(ex.signo, Process.pid)
+
+      # Shouldn't be reached
+      raise ex
+    when SystemExit, SignalException
+      raise ex
+    when StandardError, ScriptError, NoMemoryError, SystemStackError
+      # We want basically everything here: we definitely care about
+      # StandardError and ScriptError... but we also assume that whatever
+      # caused NoMemoryError or SystemStackError was way down the call
+      # stack, so we've now unwound enough to safely handle even those.
+
+      $stderr.print "\n\n===== Gel Internal Error =====\n\n"
+
+      # We'll improve this later, but for now after the header we'll leave
+      # ruby to write the message & backtrace:
+      raise ex
+    else
+      raise ex
+    end
+  end
+
+  def self.extract_word(arguments)
+    if idx = arguments.index { |w| w =~ /^[^-]/ }
+      arguments.delete_at(idx)
+    end
+  end
+
+  # If set to true, an error raised from #run will pass straight up to
+  # ruby instead of being treated as an internal Gel error
+  attr_accessor :reraise
+end
+
+require_relative "command/help"
+require_relative "command/install"
+require_relative "command/install_gem"
+require_relative "command/env"
+require_relative "command/exec"
+require_relative "command/lock"
+require_relative "command/update"
+require_relative "command/ruby"
+require_relative "command/stub"
+require_relative "command/config"
+require_relative "command/shell_setup"

data/lib/gel/command/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Gel::Command::Config < Gel::Command
+  def run(command_line)
+    if command_line.size == 1
+      puts Gel::Environment.config[command_line.first]
+    else
+      Gel::Environment.config[command_line.shift] = command_line.join(" ")
+    end
+  end
+end

data/lib/gel/command/env.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Gel::Command::Env < Gel::Command
+  def run(command_line)
+    raise "TODO"
+  end
+end

data/lib/gel/command/exec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Gel::Command::Exec < Gel::Command
+  def run(command_line, from_stub: false)
+    original_command = command_line.shift
+    expanded_command, command_source = expand_executable(original_command)
+
+    if from_stub && [:original, :path].include?(command_source)
+      raise Gel::Error::BrokenStubError.new(name: original_command)
+    end
+
+    gemfile = Gel::Environment.find_gemfile(error: false)
+
+    if gemfile && command_source != :gem
+      ENV["GEL_GEMFILE"] = File.expand_path(gemfile)
+      ENV["GEL_LOCKFILE"] = File.expand_path(Gel::Environment.lockfile_name(gemfile))
+    end
+
+    ENV["RUBYLIB"] = Gel::Environment.modified_rubylib
+
+    if execute_inline?(expanded_command)
+      if command_source == :path || command_source == :original
+        if ENV["GEL_LOCKFILE"]
+          Gel::Environment.activate(output: $stderr)
+        end
+      end
+
+      $0 = original_command
+      ARGV.replace(command_line)
+
+      # Any error after this point should bypass Gel's error
+      # handling
+      self.reraise = true
+      Kernel.load(expanded_command)
+    else
+      Kernel.exec([original_command, expanded_command], *command_line)
+    end
+  end
+
+  def expand_executable(original_command)
+    if original_command.include?(File::SEPARATOR) || (File::ALT_SEPARATOR && original_command.include?(File::ALT_SEPARATOR))
+      return [File.expand_path(original_command), :path]
+    end
+
+    if source = Gel::Environment.activate_for_executable([original_command])
+      if found = Gel::Environment.find_executable(original_command)
+        return [found, source]
+      end
+    end
+
+    path_attempts = ENV["PATH"].split(File::PATH_SEPARATOR).map { |e| File.join(e, original_command) }
+    if found = path_attempts.find { |path| File.executable?(path) }
+      return [File.expand_path(found), :path]
+    end
+
+    [original_command, :original]
+  end
+
+  def execute_inline?(expanded_command)
+    if File.exist?(expanded_command) && File.executable?(expanded_command)
+      File.open(expanded_command, "rb") do |f|
+        f.read(2) == "#!" && f.gets.chomp =~ /\bruby\b/
+      end
+    end
+  end
+end