gel 0.3.0 → 0.8.0.pre1

data/lib/gel/command.rb

@@ -8,16 +8,25 @@ class Gel::Command
     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}")
+      if const =~ /\A[a-z]+\z/i
+        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 Gel::Error::UnknownCommandError.new(command_name: command_name)
+        end
+      elsif stub_name = own_stub_file?(command_name) || other_stub_file?(command_name)
         command = Gel::Command::Exec.new
-        command.run([command_name, *command_line])
+        command.run([stub_name, *command_line], from_stub: true)
       else
         raise Gel::Error::UnknownCommandError.new(command_name: command_name)
       end
+    elsif flag_constant = flags(command_line).first
+      flag_constant.new.run(command_line)
     else
       puts <<~EOF
       Gel doesn't have a default command; please run `gel install`
@@ -68,12 +77,39 @@ class Gel::Command
     end
   end
 
+  def self.own_stub_file?(path)
+    # If it's our own stub file, we can skip reading and parsing it, and
+    # just trust that the basename is correct.
+    if Gel::Environment.store.stub_set.own_stub?(path)
+      File.basename(path)
+    end
+  end
+
+  def self.other_stub_file?(path)
+    Gel::Environment.store.stub_set.parse_stub(path)
+  end
+
+  def self.flags(arguments)
+    flag_constants = {
+      "h" => Gel::Command::Help,
+      "help" => Gel::Command::Help,
+      "v" => Gel::Command::Version,
+      "version" => Gel::Command::Version,
+    }
+
+    arguments.map { |word|
+      match = word.match(/-+(?<flag>\w+)/)
+      match && flag_constants[match[:flag]]
+    }.compact
+  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/version"
 require_relative "command/install"
 require_relative "command/install_gem"
 require_relative "command/env"
@@ -84,3 +120,4 @@ require_relative "command/ruby"
 require_relative "command/stub"
 require_relative "command/config"
 require_relative "command/shell_setup"
+require_relative "command/open"

data/lib/gel/compatibility/rubygems.rb

@@ -1,201 +1,14 @@
 # frozen_string_literal: true
 
-# The goal here is not to be a full drop-in replacement of RubyGems'
-# API.
+# Deprecation plan: Ship this without a warning for at least one
+# version, so people with an existing `gel shell-setup`-configured shell
+# don't get messages immediately after updating.
 #
-# The threshold is basically "things that already-popular/established
-# gems assume are there without checking".
-
-require_relative "../runtime"
-
-module Gem
-  Version = Gel::Support::GemVersion
-  Requirement = Gel::Support::GemRequirement
-
-  class Dependency
-    attr_reader :name
-    attr_reader :requirement
-    attr_reader :type
-
-    def initialize(name, requirement, type)
-      @name = name
-      @requirement = requirement
-      @type = type
-    end
-  end
-
-  LoadError = Class.new(::LoadError)
-
-  class Specification
-    def self.find_by_name(name, *requirements)
-      if g = Gel::Environment.find_gem(name, *requirements)
-        new(g)
-      else
-        # TODO: Should probably be a Gel exception instead?
-        raise Gem::LoadError, "Unable to find gem #{name.inspect}" + (requirements.empty? ? "" : " (#{requirements.join(", ")})")
-      end
-    end
-
-    def self.each(&block)
-      Gel::Environment.store.each.map { |g| new(g) }.each(&block)
-    end
-
-    def initialize(store_gem)
-      @store_gem = store_gem
-    end
-
-    def name
-      @store_gem.name
-    end
-
-    def version
-      Gem::Version.new(@store_gem.version)
-    end
-
-    def dependencies
-      @store_gem.dependencies.map do |name, pairs|
-        Gem::Dependency.new(name, pairs.map { |op, ver| "#{op} #{ver}" }, :runtime)
-      end
-    end
-    alias runtime_dependencies dependencies
-
-    def gem_dir
-      @store_gem.root
-    end
-    alias full_gem_path gem_dir
-
-    def require_paths
-      base = Pathname.new(gem_dir)
-
-      @store_gem.require_paths.map do |path|
-        Pathname.new(path).relative_path_from(base).to_s
-      end
-    end
-  end
-
-  class DependencyInstaller
-    def install(name, requirement = nil)
-      require_relative "../catalog"
-      require_relative "../work_pool"
-
-      Gel::WorkPool.new(2) do |work_pool|
-        catalog = Gel::Catalog.new("https://rubygems.org", work_pool: work_pool)
-
-        return Gel::Environment.install_gem([catalog], name, requirement)
-      end
-    end
-  end
-
-  def self.try_activate(file)
-    Gel::Environment.resolve_gem_path(file) != file
-  rescue LoadError
-    false
-  end
-
-  def self.ruby
-    RbConfig.ruby
-  end
-
-  def self.win_platform?
-    false
-  end
-
-  def self.loaded_specs
-    result = {}
-    Gel::Environment.activated_gems.each do |name, store_gem|
-      result[name] = Gem::Specification.new(store_gem)
-    end
-    result
-  end
-
-  def self.find_files(pattern)
-    Gel::Environment.store.each.
-      flat_map(&:require_paths).
-      flat_map { |dir| Dir[File.join(dir, pattern)] }
-  end
-
-  def self.refresh
-    # no-op
-  end
-
-  def self.path
-    Gel::Environment.store.paths
-  end
-
-  def self.default_dir
-    path.first
-  end
-
-  def self.activate_bin_path(gem_name, bin_name, version = nil)
-    if gem_name == "bundler" && bin_name == "bundle"
-      # Extra-special case: this is the bundler binstub, we need to
-      # re-exec to hand over.
-
-      ENV["RUBYLIB"] = Gel::Environment.original_rubylib
-      exec RbConfig.ruby, "--", $0, *ARGV
-    end
-
-    if gem_name == "gel" && bin_name == "gel"
-      # Another extra-special case: gel is already activated, but it's
-      # being invoked via a rubygems-installed binstub. We can't
-      # activate gel inside gel, but we also don't need to: we know
-      # exactly which file they need.
-
-      return File.expand_path("../../../exe/gel", __dir__)
-    end
-
-    if g = Gel::Environment.activated_gems[gem_name]
-      Gel::Environment.gem g.name, version if version
-    elsif g = Gel::Environment.find_gem(gem_name, *version) do |g|
-        g.executables.include?(bin_name)
-      end
-
-      Gel::Environment.gem g.name, g.version
-    elsif g = Gel::Environment.find_gem(gem_name, *version)
-      raise "#{g.name} (#{g.version}) doesn't contain executable #{bin_name.inspect}"
-    elsif version && Gel::Environment.find_gem(gem_name)
-      raise "#{gem_name} (#{version}) not available"
-    else
-      raise "Unknown gem #{gem_name.inspect}"
-    end
-
-    Gel::Environment.find_executable(bin_name, g.name, g.version)
-  rescue => ex
-    # This method may be our entry-point, if we're being invoked by a
-    # rubygems binstub. Detect that situation, and provide nicer error
-    # reporting.
-
-    raise unless locations = caller_locations(2, 2)
-    raise unless locations.size == 1
-    raise unless path = locations.first.absolute_path
-    raise unless File.exist?(path) && File.readable?(path)
-    raise unless File.open(path, "rb") { |f| f.read(1024).include?("\n# This file was generated by RubyGems.\n") }
-
-    require_relative "../command"
-    Gel::Command.handle_error(ex)
-  end
-
-  def self.bin_path(gem_name, bin_name, version = nil)
-    if g = Gel::Environment.activated_gems[gem_name]
-      Gel::Environment.gem g.name, version if version
-
-      Gel::Environment.find_executable(bin_name, g.name, g.version)
-    elsif Gel::Environment.find_gem(gem_name)
-      raise "Gem #{gem_name.inspect} is not active"
-    else
-      raise "Unknown gem #{gem_name.inspect}"
-    end
-  end
-end
-
-def gem(*args)
-  Gel::Environment.gem(*args)
-end
-private :gem
-
-def require(path)
-  super Gel::Environment.resolve_gem_path(path)
-end
-private :require
+# After that, we'll ship the below message for at least one version,
+# catching anyone whose terminal session is still alive from before the
+# above, as well as anyone setting RUBYLIB manually.
+#
+# Finally, we can remove this file and surrounding directory entirely.
 
-require "rubygems/deprecate"
+#$stderr.puts "Gel: lib/gel/compatibility/ is deprecated; please update your RUBYLIB to point to slib/, or use `gel shell-setup`. Restarting your shell may resolve this warning."
+require_relative "../compatibility"

data/lib/gel/compatibility.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-$:[0, 0] = File.expand_path("compatibility", __dir__)
-require_relative "compatibility/rubygems"
+$:[0, 0] = File.expand_path("../../slib", __dir__)
+require_relative "../../slib/rubygems"

data/lib/gel/config.rb

@@ -1,8 +1,37 @@
 # frozen_string_literal: true
 
+require_relative "util"
+
+##
+# Reads an optional config file ~/.config/gel/config and injects
+# authorization info from the environment $GEL_AUTH.
+#
+# Environment format:
+#
+#     GEL_AUTH="https://user@pass:host1/ https://user@pass:host2/"
+#
+# Config file format:
+#
+#     # comment:
+#     context-name: # where context-name in [build]
+#       key: val
+#
+#     key: val
+#
+# Example:
+#
+#     build:
+#       nokogiri: --libdir=blah
+#
+#     rails-assets.org: username:password
+#
+#     ---
+#
+#     GEL_AUTH="https://user@pass:private-gem-server.local"
+
 class Gel::Config
-  def initialize
-    @root = File.expand_path("~/.config/gel")
+  def initialize(root_path = "~/.config/gel")
+    @root = File.expand_path(root_path)
     @path = File.join(@root, "config")
     @config = nil
   end
@@ -12,10 +41,6 @@ class Gel::Config
   end
 
   def [](group = nil, key)
-    if group.nil?
-      group, key = key.split(".", 2)
-    end
-
     (group ? (config[group.to_s] || {}) : config)[key.to_s]
   end
 
@@ -50,11 +75,20 @@ class Gel::Config
         end
       end
     end
+
+    # GEL_AUTH = "http://username:password@host http://username:password@host"
+    if auths = ENV["GEL_AUTH"] then
+      auths.split.each do |auth|
+        auth = URI(auth)
+        result[auth.host] = auth.userinfo
+      end
+    end
+
     result
   end
 
   def write(data)
-    Dir.mkdir(@root) unless Dir.exist?(@root)
+    Gel::Util.mkdir_p(@root)
 
     tempfile = File.join(@root, ".config.#{Process.pid}")
     File.open(tempfile, "w", 0644) do |f|

data/lib/gel/db.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-begin
-  require "sdbm"
-rescue LoadError
-end
-require "pstore"
-require "pathname"
+require_relative "util"
+require_relative "vendor/pstore"
 
 require "monitor"
 
@@ -13,11 +9,7 @@ class Gel::DB
   def self.new(root, name)
     return super unless self == Gel::DB
 
-    if defined? ::SDBM
-      SDBM.new(root, name)
-    else
-      PStore.new(root, name)
-    end
+    PStore.new(root, name)
   end
 
   def initialize(root, name)
@@ -40,6 +32,9 @@ class Gel::DB
 
   def []=(key, value)
   end
+
+  def delete(key)
+  end
 end
 
 module Gel::DB::AutoTransaction
@@ -133,6 +128,14 @@ module Gel::DB::AutoTransaction
     end
   end
 
+  def delete(key)
+    if write?
+      super
+    else
+      writing { super }
+    end
+  end
+
   private
 
   def marshal_dump
@@ -144,121 +147,112 @@ module Gel::DB::AutoTransaction
   end
 end
 
-class Gel::DB::SDBM < Gel::DB
-  prepend Gel::DB::AutoTransaction
-  SDBM_MAX_STORE_SIZE = 1000 - 1 # arbitrary on PBLKSIZ-N
-  SAFE_DELIMITER = '---'
-
-  def initialize(root, name)
-    @sdbm = ::SDBM.new("#{root}/#{name}")
+module Gel::DB::Cache
+  def initialize(*)
+    @cache = nil
+    super
   end
 
-  def writing
-    yield
+  def writing(&block)
+    @cache = nil
+    super
   end
 
-  def reading
+  def reading(&block)
+    if @cache.nil?
+      super do
+        cache = {}
+        each_key do |k|
+          cache[k] = self[k]
+        end
+        @cache = cache
+      end
+    end
+
     yield
   end
 
   def each_key(&block)
-    @sdbm.each_key(&block)
+    if @cache
+      @cache.each_key(&block)
+    else
+      super
+    end
   end
 
   def key?(key)
-    !!@sdbm[key.to_s]
-  end
-
-  ##
-  # Retrieve the value from SDBM and handle for when we split
-  # over multiple stores. It is safe to assume that the value
-  # stored will be a marshaled value or a integer implying the
-  # amount of extra stores to retrieve the data string form. A
-  # marshaled store would have special starting delimiter that
-  # is not a decimal. If a number is not found at start of string
-  # then simply load it as a string and you get a value that
-  # is then marshaled.
-  def [](key)
-    value = @sdbm[key.to_s]
-    return nil unless value
-
-    if value =~ /\A~(\d+)\z/
-      value = $1.to_i.times.map do |idx|
-        @sdbm["#{key}#{SAFE_DELIMITER}#{idx}"]
-      end.join
+    if @cache
+      @cache.key?(key)
+    else
+      super
     end
-
-    return Marshal.load(value)
   end
 
-
-  ##
-  # SDBM has an arbitrary limit on the size of a string it stores,
-  # so we simply split any string over multiple stores for the edge
-  # case when it reaches this. It's optimised to take advantage of the common
-  # case where this is not needed.
-  # When the edge case is hit, the first value in the storage will be the amount
-  # of extra values stored to hold the split string. This amount is determined by string
-  # size split by the arbitrary limit imposed by SDBM
-  def []=(key, value)
-    return unless value && key
-
-    dump = Marshal.dump(value)
-    count = dump.length / SDBM_MAX_STORE_SIZE
-
-    if count > 0
-      count += 1
-      @sdbm["#{key.to_s}"] = "~#{count}"
-      count.times.map do |idx|
-        @sdbm["#{key.to_s}#{SAFE_DELIMITER}#{idx}"] = dump.slice!(0, SDBM_MAX_STORE_SIZE)
-      end
+  def [](key)
+    if @cache
+      @cache[key]
     else
-      @sdbm[key.to_s] = dump
+      super
     end
   end
 end
 
 class Gel::DB::PStore < Gel::DB
+  prepend Gel::DB::Cache
   prepend Gel::DB::AutoTransaction
 
   def initialize(root, name)
-    @pstore = ::PStore.new("#{root}/#{name}.pstore", true)
+    @filename = "#{root}/#{name}.pstore"
+    @pstore = (store if ::File.exist?(@filename))
   end
 
   def writing(&block)
+    @pstore ||= store
     @pstore.transaction(false, &block)
   end
 
   def reading(&block)
-    @pstore.transaction(true, &block)
+    @pstore = store if @pstore.nil? && ::File.exist?(@filename)
+    @pstore&.transaction(true, &block)
   end
 
   def each_key(&block)
-    @pstore.roots.each(&block)
+    @pstore.roots.each(&block) if @pstore
   end
 
   def key?(key)
-    @pstore.key?(key.to_s)
+    @pstore&.root?(key.to_s)
   end
 
   def [](key)
-    @pstore[key.to_s]
+    @pstore && @pstore[key.to_s]
   end
 
   def []=(key, value)
     @pstore[key.to_s] = value
   end
+
+  def delete(key)
+    @pstore.delete(key.to_s)
+  end
+
+  private
+
+  def store
+    Gel::Util.mkdir_p(::File.dirname(@filename))
+    Gel::Vendor::PStore.new(@filename, true)
+  end
 end
 
 class Gel::DB::File < Gel::DB
   prepend Gel::DB::AutoTransaction
 
   def initialize(root, name)
-    @path = Pathname.new("#{root}/#{name}")
+    @base = "#{root}/#{name}"
   end
 
   def writing
-    @path.mkdir unless @path.exist?
+    Gel::Util.mkdir_p(@base)
     yield
   end
 
@@ -267,28 +261,44 @@ class Gel::DB::File < Gel::DB
   end
 
   def each_key
-    @path.each_child(false) do |child|
-      yield child.to_s
+    return unless Dir.exist?(@base)
+    Dir.each_child(@base) do |child|
+      yield child
     end
   end
 
   def key?(key)
-    @path.join(key).exist?
+    ::File.exist?(path(key))
   end
 
   def [](key)
-    child = @path.join(key)
-    if child.exist?
-      Marshal.load(child.binread)
+    child = path(key)
+    if ::File.exist?(child)
+      Marshal.load(IO.binread(child))
     end
   end
 
   def []=(key, value)
-    child = @path.join(key)
+    child = path(key)
     if value
-      child.binwrite Marshal.dump(value)
-    elsif child.exist?
-      child.unlink
+      IO.binwrite child, Marshal.dump(value)
+    elsif ::File.exist?(child)
+      ::File.unlink(child)
     end
   end
+
+  def delete(key)
+    child = path(key)
+    if ::File.exist?(child)
+      value = Marshal.load(IO.binread(child))
+      ::File.unlink(child)
+      value
+    end
+  end
+
+  private
+
+  def path(key)
+    ::Gel::Util.join(@base, key)
+  end
 end

data/lib/gel/direct_gem.rb

@@ -5,9 +5,19 @@ class Gel::DirectGem < Gel::StoreGem
     Gel::GemspecParser.parse(File.read(filename), filename, isolate: false)
   end
 
-  def initialize(root, name, version = nil)
+  def self.from_block(*args, &block)
+    filename, _lineno = block.source_location
+
+    result = Gel::GemspecParser::Context::Gem::Specification.new(*args, &block)
+
+    new(File.dirname(filename), result.name, loaded_gemspec: result)
+  end
+
+  def initialize(root, name, version = nil, loaded_gemspec: nil)
     root = File.expand_path(root)
-    if File.exist?("#{root}/#{name}.gemspec")
+    if loaded_gemspec
+      gemspec = loaded_gemspec
+    elsif File.exist?("#{root}/#{name}.gemspec")
       gemspec = load_gemspec("#{root}/#{name}.gemspec")
     elsif File.exist?("#{root}/#{name}/#{name}.gemspec")
       root = "#{root}/#{name}"
@@ -17,13 +27,15 @@ class Gel::DirectGem < Gel::StoreGem
       return
     end
 
+    require_paths = gemspec.require_paths&.compact || [gemspec.require_path || "lib"]
+
     info = {
       bindir: gemspec.bindir || "bin",
       executables: gemspec.executables,
-      require_paths: gemspec.require_paths || [gemspec.require_path].compact,
+      require_paths: require_paths,
       dependencies: gemspec.runtime_dependencies,
     }
 
-    super(root, name, version || gemspec.version, gemspec.extensions, info)
+    super(root, name, version || Gel::Support::GemVersion.new(gemspec.version).to_s, ("#{root}/ext" if gemspec.extensions.any?), info)
   end
 end