gel 0.3.0 → 0.8.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ac61e9a6e0ebdc00fe6c63fe59040cb50f66cfd375f4f4041a1f535f1c8e492
-  data.tar.gz: 28812a81b32b67c6d23370974de0963229caef262585ecd91f81d4045a1e407e
+  metadata.gz: 12fd6cb40e3a3ad1f972f80bda31dab9b894f61393469c6030fbd05394d0a248
+  data.tar.gz: ec8b72583200dc1c5679a6eedde63c333970acc5834a8e454dbd00aaa30d0135
 SHA512:
-  metadata.gz: 55fc3ff597234684ef052023204ac18a7fafe8289b88a8dfc896f66f06081bd72d4560092f88c3f74e5054d0030a80732ca30cf2ec7f560806cb260730b2a6ac
-  data.tar.gz: 2631449a64f1b976833b17a632acd28a1f44b3c0821f6e96163ddb53767b0c96a7ccfa02bd49d3b2381ec0738a8aad2c25cb1261f714701f1ae75f8bc645ec74
+  metadata.gz: f27419701ba1c70f4ce7eef187ab61d9b681eade093f1966d5cc81a183a78ab8ff31dac4c365376b38e46331f3b66e0905930ff89044d948d26b9bc89b296df8
+  data.tar.gz: 1567767fb08472aa0fc1291ed0cfe56376acb28c7d5c3e56978952320694149910f9b8892f7a3937acef0aa5e22c89643afa1fc1e39b774ad04d0e39e834a53f

data/README.md

@@ -4,8 +4,7 @@
 
 A modern gem manager.
 
-Gel is a lightweight alternative to Bundler. 
-
+Gel is a lightweight alternative to Bundler.
 
 |         |         Gel        | Bundler & Rubygems |
 |---------|--------------------|--------------------|
@@ -88,10 +87,34 @@ Or add it to your `.bashrc` or `.zshrc` to enable it everywhere:
 
 Use `gel install`, `gel lock`, `gel update`, and `gel exec` as you would the equivalent `bundle` subcommands.
 
+## ENVIRONMENT VARIABLES
+
+* `GEL_GEMFILE`
+  The path to the gemfile gel should use
+
+* `GEL_LOCKFILE`
+  The path to the lockfile that gel should use
+
+* `GEL_CACHE`
+  The path to the gel version information cache
+
+* `GEL_AUTH`
+  Gem server credentials as a space-separated list of URIs, e.g.:
+  "http://user:pass@ruby.example.com/ http://user2:pass2@gems.example.org/"
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/rake test` to run the tests.
 
+To use your development instance as your primary Gel, add its `exe/` to your `$PATH` before running `shell-setup`, ensuring it comes before any RubyGems `bin` directory that might override it.
+
+For example:
+
+```sh
+PATH="$HOME/projects/gel/exe:$PATH"
+eval "$(gel shell-setup)"
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gel-rb/gel. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
@@ -102,4 +125,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Gel project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/gel-rb/gel/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Gel project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/gel-rb/gel/blob/main/CODE_OF_CONDUCT.md).

data/RELEASING.md

@@ -0,0 +1,12 @@
+# Releasing Gel
+
+1. Bump the version in `lib/gel/version.rb`
+1. `gel lock`
+1. `rake build`
+1. `git commit`
+1. `git tag vX.Y.Z`
+1. `git push --tags origin main vX.Y.Z`
+1. On GitHub, convert the tag to a release, and write a changelog
+1. `gem push pkg/gel-X.Y.Z.gem`
+1. `brew bump-formula-pr --url=https://github.com/gel-rb/gel/archive/vX.Y.Z.tar.gz`
+1. Tweet a link to https://github.com/gel-rb/gel/releases/tag/vX.Y.Z

data/exe/gel

@@ -1,9 +1,11 @@
-#!/usr/bin/env ruby --disable=gems
+#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 if defined?(::Gem) && !defined?(::Gel)
+  # Note there's a similar re-exec in gemlib/gel/stub.rb
+
   exec ::Gem.ruby,
-    "-I", File.expand_path("../lib/gel/compatibility", __dir__),
+    "-I", File.expand_path("../slib", __dir__),
     "--",
     __FILE__,
     *ARGV

data/gemlib/gel/stub.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# This file exists to be required from a Gel binstub if it has been
+# loaded via 'ruby -S' and Rubygems was loaded. It (only) defines an
+# alternative implementation of Gel.stub, which will re-exec Ruby to
+# switch to Gel.
+
+module Gel
+  def self.stub(name)
+    # Note there's a similar re-exec in exe/gel
+
+    exec ::Gem.ruby,
+      "-I", File.expand_path("../slib", __dir__),
+      "--",
+      File.expand_path("../exe/gel", __dir__),
+      "stub",
+      name,
+      *ARGV
+  end
+end

data/lib/gel/catalog/common.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "fileutils"
 require "monitor"
+require_relative "../util"
 
 module Gel::Catalog::Common
   def initialize(uri, uri_identifier, httpool:, work_pool:, cache:)
@@ -66,11 +66,13 @@ module Gel::Catalog::Common
   end
 
   def pinboard
+    require_relative "../pinboard"
+
     @pinboard || @monitor.synchronize do
       @pinboard ||=
         begin
           pinboard_dir = File.expand_path("#{@cache}/#{self.class::CACHE_TYPE}/#{@uri_identifier}")
-          FileUtils.mkdir_p(pinboard_dir) unless Dir.exist?(pinboard_dir)
+          Gel::Util.mkdir_p(pinboard_dir)
           Gel::Pinboard.new(pinboard_dir, httpool: @httpool, work_pool: @work_pool)
         end
     end

data/lib/gel/catalog/compact_index.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
-require "set"
-
-require_relative "../pinboard"
-
-require_relative "common"
+require_relative "../set"
 
 class Gel::Catalog::CompactIndex
   include Gel::Catalog::Common
   CACHE_TYPE = "index"
 
-  def initialize(*)
-    super
+  def initialize(*args, **kwargs)
+    super(*args, **kwargs)
 
     @gem_tokens = Hash.new("NONE")
     @needs_update = true
     @updating = false
-    @active_gems = Set.new
-    @pending_gems = Set.new
+    @active_gems = Gel::Set.new
+    @pending_gems = Gel::Set.new
   end
 
   def prepare(gems)
@@ -102,7 +98,7 @@ class Gel::Catalog::CompactIndex
     end
 
     pinboard.async_file(uri("info", gem_name), token: @gem_tokens[gem_name], only_updated: already_active, error: error) do |f|
-      dependency_names = Set.new
+      dependency_names = Gel::Set.new
       info = {}
 
       started = false

data/lib/gel/catalog/dependency_index.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require "set"
-require "cgi"
 require "zlib"
 
-require_relative "../pinboard"
+require_relative "../set"
+require_relative "../support/cgi_escape"
 
-require_relative "common"
 require_relative "marshal_hacks"
 
 class Gel::Catalog::DependencyIndex
   include Gel::Catalog::Common
+  include Gel::Support::CGIEscape
+
   CACHE_TYPE = "quick"
 
   LIST_MAX = 40
 
-  def initialize(catalog, *args)
-    super(*args)
+  def initialize(catalog, *args, **kwargs)
+    super(*args, **kwargs)
 
     @catalog = catalog
 
-    @active_gems = Set.new
-    @pending_gems = Set.new
+    @active_gems = Gel::Set.new
+    @pending_gems = Gel::Set.new
   end
 
   def prepare(gems)
@@ -56,7 +56,7 @@ class Gel::Catalog::DependencyIndex
   end
 
   def refresh_some_gems(gems)
-    gem_list = gems.map { |g| CGI.escape(g) }.sort.join(",")
+    gem_list = gems.map { |g| cgi_escape(g) }.sort.join(",")
     @work_pool.queue(gem_list) do
       response =
         begin
@@ -72,7 +72,7 @@ class Gel::Catalog::DependencyIndex
       new_info = {}
       gems.each { |g| new_info[g] = {} }
 
-      new_dependencies = Set.new
+      new_dependencies = Gel::Set.new
 
       hashes = Marshal.load(response.body)
       hashes.each do |hash|

data/lib/gel/catalog/legacy_index.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
-require "set"
 require "zlib"
 
-require_relative "../pinboard"
+require_relative "../set"
 
-require_relative "common"
 require_relative "marshal_hacks"
 
 class Gel::Catalog::LegacyIndex
   include Gel::Catalog::Common
   CACHE_TYPE = "quick"
 
-  def initialize(*)
+  def initialize(*args, **kwargs)
     super
 
     @needs_update = true
     @updating = false
-    @active_gems = Set.new
-    @pending_gems = Set.new
+    @active_gems = Gel::Set.new
+    @pending_gems = Gel::Set.new
 
     @gem_versions = {}
   end

data/lib/gel/catalog/marshal_hacks.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+module Gem; end unless defined? Gem
+
 class Gem::Specification
   class Unmarshalled
     attr_accessor :required_ruby_version

data/lib/gel/catalog.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "net/http"
 require "uri"
-require "digest"
 
 require_relative "httpool"
+require_relative "util"
 require_relative "support/gem_platform"
+require_relative "vendor/ruby_digest"
 
 class Gel::Catalog
   UPDATE_CONCURRENCY = 8
 
+  autoload :Common, File.expand_path("catalog/common", __dir__)
+  autoload :CompactIndex, File.expand_path("catalog/compact_index", __dir__)
+  autoload :DependencyIndex, File.expand_path("catalog/dependency_index", __dir__)
+  autoload :LegacyIndex, File.expand_path("catalog/legacy_index", __dir__)
+
   def initialize(uri, httpool: Gel::Httpool.new, work_pool:, cache: ENV["GEL_CACHE"] || "~/.cache/gel", initial_gems: [])
     @uri = normalize_uri(uri)
     @httpool = httpool
@@ -25,10 +29,10 @@ class Gel::Catalog
     ]
   end
 
-  def prepare
-    index.prepare(@initial_gems)
-  rescue Net::HTTPExceptions
-    if @indexes.size > 1
+  def attempting_each_index
+    yield send(@indexes.first)
+  rescue => ex
+    if recoverable?(ex) && @indexes.size > 1
       @indexes.shift
       retry
     else
@@ -36,65 +40,44 @@ class Gel::Catalog
     end
   end
 
-  def compact_index
-    @compact_index ||= Gel::Catalog::CompactIndex.new(@uri, uri_identifier, httpool: @httpool, work_pool: @work_pool, cache: @cache)
+  def recoverable?(exception)
+    defined?(Net::HTTPExceptions) && Net::HTTPExceptions === exception
   end
 
-  def dependency_index
-    @dependency_index ||= Gel::Catalog::DependencyIndex.new(self, @uri, uri_identifier, httpool: @httpool, work_pool: @work_pool, cache: @cache)
+  def prepare
+    attempting_each_index { |index| index.prepare(@initial_gems) }
   end
 
-  def legacy_index
-    @legacy_index ||= Gel::Catalog::LegacyIndex.new(@uri, uri_identifier, httpool: @httpool, work_pool: @work_pool, cache: @cache)
+  def gem_info(name)
+    attempting_each_index { |index| index.gem_info(name) }
   end
 
-  def index
-    send(@indexes.first)
+  def compact_index
+    @compact_index ||= Gel::Catalog::CompactIndex.new(@uri, uri_identifier, httpool: @httpool, work_pool: @work_pool, cache: @cache)
   end
 
-  def gem_info(name)
-    index.gem_info(name)
-  rescue Net::HTTPExceptions
-    if @indexes.size > 1
-      @indexes.shift
-      retry
-    else
-      raise
-    end
+  def dependency_index
+    @dependency_index ||= Gel::Catalog::DependencyIndex.new(self, @uri, uri_identifier, httpool: @httpool, work_pool: @work_pool, cache: @cache)
   end
 
-  def cached_gem(name, version)
-    path = cache_path(name, version)
-    return path if File.exist?(path)
+  def legacy_index
+    @legacy_index ||= Gel::Catalog::LegacyIndex.new(@uri, uri_identifier, httpool: @httpool, work_pool: @work_pool, cache: @cache)
   end
 
   def download_gem(name, version)
     path = cache_path(name, version)
     return path if File.exist?(path)
 
-    name, version = guess_version(name, version)
-
-    response = http_get("/gems/#{name}-#{version}.gem")
-    FileUtils.mkdir_p(cache_dir) unless Dir.exist?(cache_dir)
-    File.open(path, "wb") do |f|
-      f.write(response.body)
-    end
-    path
-  end
-
-  VARIANT_GEMS = %w(libv8)
-  def guess_version(name, version)
-    if VARIANT_GEMS.include?(name)
-      [name, "#{version}-#{platform_specific_version}"]
-    else
-      [name, version]
+    if gem_info(name)
+      response = http_get("/gems/#{name}-#{version}.gem")
+      Gel::Util.mkdir_p(cache_dir)
+      File.open(path, "wb") do |f|
+        f.write(response.body)
+      end
+      path
     end
   end
 
-  def platform_specific_version
-    Gel::Support::GemPlatform.new(RbConfig::CONFIG["arch"])
-  end
-
   def inspect
     "#<#{self.class} #{to_s.inspect}>"
   end
@@ -117,7 +100,7 @@ class Gel::Catalog
   end
 
   def uri_identifier
-    @uri.host + "-" + Digest(:SHA256).hexdigest(@uri.to_s)[0..10]
+    @uri.host + "-" + Gel::Vendor::RubyDigest::SHA256.hexdigest(@uri.to_s)[0..10]
   end
 
   def cache_dir
@@ -129,6 +112,8 @@ class Gel::Catalog
   end
 
   def http_get(path)
+    require "net/http"
+
     original_uri = uri = URI(File.join(@uri.to_s, path))
 
     5.times do
@@ -147,7 +132,3 @@ class Gel::Catalog
     raise Gel::Error::TooManyRedirectsError.new(original_uri: original_uri)
   end
 end
-
-require_relative "catalog/compact_index"
-require_relative "catalog/dependency_index"
-require_relative "catalog/legacy_index"

data/lib/gel/catalog_set.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "platform"
+
+class Gel::CatalogSet
+  CatalogEntry = Struct.new(:catalog, :name, :version, :info) do
+    def gem_version
+      @gem_version ||= Gel::Support::GemVersion.new(version)
+    end
+  end
+
+  def initialize(catalogs)
+    @catalogs = catalogs
+
+    @cached_specs = Hash.new { |h, k| h[k] = {} }
+    @specs_by_package_version = {}
+  end
+
+  def catalog_for_version(package, version)
+    @specs_by_package_version[package.name][version.to_s]&.catalog
+  end
+
+  def entries_for(package)
+    fetch_package_info(package)
+
+    @specs_by_package_version[package.name].values.select do |spec|
+      available_platforms = spec.info.map(&:first)
+      Gel::Platform.match(package.platform, available_platforms)
+    end
+  end
+
+  # Returns a list of [name, version_contraint] pairs representing the
+  # specified package's dependencies. Note that a given +name+ may
+  # appear multiple times, and the resulting dependency is the
+  # intersection of all constraints.
+  def dependencies_for(package, version)
+    fetch_package_info(package) # probably already done, can't hurt
+
+    spec = @specs_by_package_version[package.name][version.to_s]
+
+    raise "missing spec #{package.inspect} / #{version.inspect}" if spec.nil?
+
+    info = spec.info
+
+    available_platforms = info.map(&:first)
+    matching_platform = Gel::Platform.match(package.platform, available_platforms)
+
+    info = info.select { |p, i| p == matching_platform }
+
+    # FIXME: ruby_constraints ???
+
+    info.flat_map { |_, i| i[:dependencies] }
+  end
+
+  def platform_for(package, version)
+    fetch_package_info(package) # probably already done, can't hurt
+
+    spec = @specs_by_package_version[package.name][version.to_s]
+
+    info = spec.info
+
+    available_platforms = info.map(&:first)
+    Gel::Platform.match(package.platform, available_platforms)
+  end
+
+  private
+
+  def fetch_package_info(package)
+    return if @specs_by_package_version.key?(package.name)
+
+    specs = []
+    @catalogs.each do |catalog|
+      if catalog.nil?
+        break unless specs.empty?
+        next
+      end
+
+      if info = catalog.gem_info(package.name)
+        @cached_specs[catalog][package.name] ||=
+          begin
+            grouped_versions = info.to_a.map do |full_version, attributes|
+              version, platform = full_version.split("-", 2)
+              platform ||= "ruby"
+              [version, platform, attributes]
+            end.group_by(&:first)
+
+            grouped_versions.map { |version, tuples| CatalogEntry.new(catalog, package.name, version, tuples.map { |_, p, a| [p, a] }) }
+          end
+
+        specs.concat @cached_specs[catalog][package.name]
+      end
+    end
+
+    @specs_by_package_version[package.name] = {}
+    specs.each do |spec|
+      # TODO: are we going to find specs in multiple catalogs this way?
+      @specs_by_package_version[package.name][spec.version] = spec
+    end
+  end
+end

data/lib/gel/command/help.rb

@@ -1,7 +1,18 @@
 # frozen_string_literal: true
 
 class Gel::Command::Help < Gel::Command
-  def run(command_line)
-    raise "TODO"
+  def run(_command_line)
+    puts <<~HELP
+      Gel is a modern gem manager.
+
+      Usage:
+        gel help       Print this help message.
+        gel install    Install the gems from Gemfile.
+        gel lock       Update lockfile without installing.
+        gel exec       Run command in context of the gel.
+
+      Further information:
+        https://gel.dev/
+    HELP
   end
 end

data/lib/gel/command/lock.rb

@@ -25,10 +25,10 @@ class Gel::Command::Lock < Gel::Command
     end
 
     require_relative "../pub_grub/preference_strategy"
-    options[:preference_strategy] = lambda do |loader|
-      Gel::PubGrub::PreferenceStrategy.new(loader, overrides, bump: mode, strict: strict)
+    options[:preference_strategy] = lambda do |gem_set|
+      Gel::PubGrub::PreferenceStrategy.new(gem_set, overrides, bump: mode, strict: strict)
     end
 
-    Gel::Environment.lock(output: $stderr, **options)
+    Gel::Environment.write_lock(output: $stderr, **options)
   end
 end

data/lib/gel/command/open.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Gel::Command::Open < Gel::Command
+  def run(command_line)
+    require "shellwords"
+
+    raise "Please provide the name of a gem to open in your editor" if command_line.empty?
+    raise "Too many arguments, only 1 gem name is supported" if command_line.length > 1
+    gem_name = command_line.shift
+
+    editor = ENV.fetch("GEL_EDITOR", ENV["EDITOR"])
+    raise "An editor must be set using either $GEL_EDITOR or $EDITOR" unless editor
+
+    Gel::Environment.activate(output: $stderr)
+
+    found_gem = Gel::Environment.find_gem(gem_name)
+    raise "Can't find gem `#{gem_name}`" unless found_gem
+
+    command = [*Shellwords.split(editor), found_gem.root]
+    Dir.chdir(found_gem.root) do
+      exec(*command)
+    end
+  end
+end

data/lib/gel/command/shell_setup.rb

@@ -4,22 +4,25 @@ class Gel::Command::ShellSetup < Gel::Command
   def run(command_line)
     require "shellwords"
 
-    variables = []
+    shell = command_line[0] || File.basename(ENV.fetch("SHELL", "bash"))
 
     bin_dir = File.expand_path("~/.local/gel/bin")
     unless ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).include?(bin_dir)
-      puts "PATH=\"#{Shellwords.shellescape bin_dir}#{File::PATH_SEPARATOR}$PATH\""
-      variables << "PATH"
+      puts export("PATH", "\"#{Shellwords.shellescape bin_dir}#{File::PATH_SEPARATOR}$PATH\"", shell: shell)
     end
 
-    lib_dir = File.expand_path("../compatibility", __dir__)
+    lib_dir = File.expand_path("../../slib", __dir__)
     unless ENV.fetch("RUBYLIB", "").split(File::PATH_SEPARATOR).include?(lib_dir)
-      puts "RUBYLIB=\"#{Shellwords.shellescape lib_dir}:$RUBYLIB\""
-      variables << "RUBYLIB"
+      puts export("RUBYLIB", "\"#{Shellwords.shellescape lib_dir}:$RUBYLIB\"", shell: shell)
     end
+  end
 
-    unless variables.empty?
-      puts "export #{variables.join(" ")}"
+  def export(env, value, shell: nil)
+    case shell
+    when "fish"
+      "set -x #{env} #{value}"
+    else
+      "export #{env}=#{value}"
     end
   end
 end

data/lib/gel/command/stub.rb

@@ -2,11 +2,54 @@
 
 class Gel::Command::Stub < Gel::Command
   def run(command_line)
-    stub_command, _path, *arguments = command_line
+    if command_line.first == "--rebuild"
+      Gel::Environment.store.stub_set.rebuild!
+      return
+    end
+
+    # Note that the most common stub invocation doesn't actually pass
+    # through here at all: a stubfile being run directly will present
+    # as `gel <full-path-to-stubfile>` and will be handled by the
+    # corresponding special case in the top level Gel::Command.run.
+    #
+    # We do get here when invoked by Gel.stub, or manual `gel stub foo`
+    # execution, though. In both of those cases, the first element of
+    # command_line will be the unqualified command to run, and the rest
+    # will be its arguments -- so we can just pass command_line along to
+    # Exec unmodified.
+    #
+    # However, there is one more situation that will end up here: when a
+    # legacy stub file is invoked. In that case, after the unqualified
+    # command name and before any supplied arguments, the shebang
+    # invocation will have inserted the fully-qualified stubfile path as
+    # well. We need to detect that, and strip it out.
+
+    command_line.slice!(1) if redundant_stub_argument?(command_line)
 
     command = Gel::Command::Exec.new
-    command.run([stub_command, *arguments], from_stub: true)
+    command.run(command_line, from_stub: true)
   ensure
     self.reraise = command.reraise if command
   end
+
+  private
+
+  def redundant_stub_argument?((command, possible_stub_path, *))
+    return false unless possible_stub_path
+
+    # Gel.stub injects a symbol to disambiguate the subsequent
+    # arguments; we don't need to look any further, and definitely want
+    # to strip it out.
+    return true if possible_stub_path == :stub
+
+    # A true redundant argument is a fully-qualified version of the
+    # stubbed command. Does it even look like the names match?
+    return false unless possible_stub_path.end_with?(command)
+
+    # Okay, it seems plausible; in that case, it's time to check
+    # properly.
+    stub_set = Gel::Environment.store.stub_set
+    stub_set.own_stub?(possible_stub_path) &&
+      stub_set.parse_stub(possible_stub_path) == command
+  end
 end

data/lib/gel/command/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Gel::Command::Version < Gel::Command
+  def run(_command_line)
+    puts "Gel version #{Gel::VERSION}"
+  end
+end