gel 0.2.0

data/lib/gel/command/help.rb

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

data/lib/gel/command/install.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Gel::Command::Install < Gel::Command
+  def run(command_line)
+    Gel::Environment.activate(install: true, output: $stderr)
+  end
+end

data/lib/gel/command/install_gem.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Gel::Command::InstallGem < Gel::Command
+  def run(command_line)
+    gem_name, gem_version = command_line
+
+    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)
+
+      Gel::Environment.install_gem([catalog], gem_name, gem_version, output: $stderr)
+    end
+  end
+end

data/lib/gel/command/lock.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Gel::Command::Lock < Gel::Command
+  def run(command_line)
+    options = {}
+
+    mode = :hold
+    strict = false
+    overrides = {}
+
+    until command_line.empty?
+      case argument = command_line.shift
+      when "--strict"; strict = true
+      when "--major"; mode = :major
+      when "--minor"; mode = :minor
+      when "--patch"; mode = :patch
+      when "--hold"; mode = :hold
+      when /\A--lockfile(?:=(.*))?\z/
+        options[:lockfile] = $1 || command_line.shift
+      when /\A((?!-)[A-Za-z0-9_-]+)(?:(?:[\ :\/]|(?=[<>~=]))([<>~=,\ 0-9A-Za-z.-]+))?\z/x
+        overrides[$1] = Gel::Support::GemRequirement.new($2 ? $2.split(/\s+(?=[0-9])|\s*,\s*/) : [])
+      else
+        raise "Unknown argument #{argument.inspect}"
+      end
+    end
+
+    require_relative "../pub_grub/preference_strategy"
+    options[:preference_strategy] = lambda do |loader|
+      Gel::PubGrub::PreferenceStrategy.new(loader, overrides, bump: mode, strict: strict)
+    end
+
+    Gel::Environment.lock(output: $stderr, **options)
+  end
+end

data/lib/gel/command/ruby.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Gel::Command::Ruby < Gel::Command
+  def run(command_line)
+    command = Gel::Command::Exec.new
+    command.run(["ruby", *command_line])
+  ensure
+    self.reraise = command.reraise if command
+  end
+end

data/lib/gel/command/shell_setup.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Gel::Command::ShellSetup < Gel::Command
+  def run(command_line)
+    require "shellwords"
+
+    variables = []
+
+    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"
+    end
+
+    lib_dir = File.expand_path("../compatibility", __dir__)
+    unless ENV.fetch("RUBYLIB", "").split(File::PATH_SEPARATOR).include?(lib_dir)
+      puts "RUBYLIB=\"#{Shellwords.shellescape lib_dir}:$RUBYLIB\""
+      variables << "RUBYLIB"
+    end
+
+    unless variables.empty?
+      puts "export #{variables.join(" ")}"
+    end
+  end
+end

data/lib/gel/command/stub.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Gel::Command::Stub < Gel::Command
+  def run(command_line)
+    stub_command, _path, *arguments = command_line
+
+    command = Gel::Command::Exec.new
+    command.run([stub_command, *arguments], from_stub: true)
+  ensure
+    self.reraise = command.reraise if command
+  end
+end

data/lib/gel/command/update.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Gel::Command::Update < Gel::Command
+  def run(command_line)
+    # Mega update mode
+    command_line = ["--major"] if command_line.empty?
+
+    Gel::Command::Lock.new.run(command_line)
+    Gel::Environment.activate(install: true, output: $stderr)
+  end
+end

data/lib/gel/compatibility.rb

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

data/lib/gel/compatibility/bundler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Bundler
+  def self.setup
+    Gel::Environment.activate(output: $stderr)
+  end
+
+  def self.require(*groups)
+    Gel::Environment.require_groups(*groups)
+  end
+
+  def self.default_lockfile
+    Pathname.new(Gel::Environment.lockfile_name)
+  end
+
+  module Rubygems
+    def self.loaded_specs(gem_name)
+      Gem::Specification.new(Gel::Environment.activated_gems[gem_name])
+    end
+  end
+
+  # This is only emulated for bin/spring: we really don't want to try to
+  # actually reproduce Bundler's API
+  class LockfileParser
+    def initialize(content)
+    end
+
+    def specs
+      []
+    end
+  end
+
+  def self.rubygems
+    Rubygems
+  end
+
+  def self.with_original_env
+    # TODO
+    yield
+  end
+
+  def self.with_clean_env
+    # TODO
+    yield
+  end
+
+  def self.settings
+    if gemfile = Gel::Environment.gemfile
+      { "gemfile" => gemfile.filename }
+    else
+      {}
+    end
+  end
+end

data/lib/gel/compatibility/bundler/cli.rb

@@ -0,0 +1,6 @@
+# We assume this file is only required by the `bundle` executable: if we
+# get here, we need to re-exec it without Gel on the path, to ensure it
+# has a full and proper Rubygems environment to work with.
+
+ENV["RUBYLIB"] = Gel::Environment.original_rubylib
+exec RbConfig.ruby, "--", $0, *ARGV

data/lib/gel/compatibility/bundler/friendly_errors.rb

@@ -0,0 +1,3 @@
+def Bundler.with_friendly_errors
+  yield
+end

data/lib/gel/compatibility/bundler/setup.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "../bundler"
+Bundler.setup

data/lib/gel/compatibility/rubygems.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+# The goal here is not to be a full drop-in replacement of RubyGems'
+# API.
+#
+# 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 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
+
+require "rubygems/deprecate"

data/lib/gel/compatibility/rubygems/command.rb

@@ -0,0 +1,4 @@
+module Gem::Command
+  def self.build_args=(value)
+  end
+end

data/lib/gel/compatibility/rubygems/gem_runner.rb

@@ -0,0 +1,6 @@
+# We assume this file is only required by the `gem` executable: if we
+# get here, we need to re-exec it without Gel on the path, to ensure it
+# has a full and proper Rubygems environment to work with.
+
+ENV["RUBYLIB"] = Gel::Environment.original_rubylib
+exec RbConfig.ruby, "--", $0, *ARGV

data/lib/gel/config.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class Gel::Config
+  def initialize
+    @root = File.expand_path("~/.config/gel")
+    @path = File.join(@root, "config")
+    @config = nil
+  end
+
+  def config
+    @config ||= read
+  end
+
+  def [](group = nil, key)
+    if group.nil?
+      group, key = key.split(".", 2)
+    end
+
+    (group ? (config[group.to_s] || {}) : config)[key.to_s]
+  end
+
+  def []=(group = nil, key, value)
+    if group.nil?
+      group, key = key.split(".", 2)
+    end
+
+    (group ? (config[group.to_s] ||= {}) : config)[key.to_s] = value.to_s
+
+    write(config)
+  end
+
+  private
+
+  def read
+    result = {}
+    if File.exist?(@path)
+      context = nil
+      File.read(@path).each_line do |line|
+        line.chomp!
+        if line =~ /\A(\S[^:]*):\z/
+          context = result[$1] = {}
+        elsif line =~ /\A  ([^:]*): (.*)\z/
+          context[$1] = $2
+        elsif line =~ /\A([^:]*): (.*)\z/
+          result[$1] = $2
+        elsif line =~ /\A\s*(?:#|\z)/
+          # comment / empty
+        else
+          raise "Unexpected config line #{line.inspect}"
+        end
+      end
+    end
+    result
+  end
+
+  def write(data)
+    Dir.mkdir(@root) unless Dir.exist?(@root)
+
+    tempfile = File.join(@root, ".config.#{Process.pid}")
+    File.open(tempfile, "w", 0644) do |f|
+      data.each do |key, value|
+        next if value.is_a?(Hash)
+        f.puts("#{key}: #{value}")
+      end
+
+      data.each do |key, value|
+        next unless value.is_a?(Hash)
+        f.puts
+        f.puts("#{key}:")
+        value.each do |subkey, subvalue|
+          f.puts("  #{subkey}: #{subvalue}")
+        end
+      end
+    end
+
+    File.rename(tempfile, @path)
+  ensure
+    File.unlink(tempfile) if File.exist?(tempfile)
+  end
+end