herve 0.1.1

data/lib/herve/cli/ruby_commands/uninstall.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Herve
+  module CLI
+    module RubyCommands
+      class Uninstall < BaseCommand
+        desc "uninstall given ruby version"
+        argument :version, desc: "version to uninstall", required: true
+        option :install_dir, desc: "installation directory", default: DEFAULT_RUBIES
+
+        def call(version:, **options)
+          install_dir = Herve.expand_path(options[:install_dir])
+          raise ConfigError, "install_dir does not exist" unless File.directory?(install_dir)
+
+          config.ruby_dirs = [install_dir] unless install_dir.nil?
+          ruby = RubyCommands.find_ruby(config, version)
+          raise RubyError, "no matching ruby" if ruby.nil?
+
+          uninstall_ruby(ruby)
+        end
+
+        private
+
+        def uninstall_ruby(ruby)
+          FileUtils.remove_dir(ruby.path)
+          logger.info { "Ruby #{Rainbow(ruby.version).cyan} uninstalled" }
+        end
+      end
+    end
+  end
+end

data/lib/herve/cli/ruby_commands.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module RubyCommands
+      def self.find_ruby(config, request)
+        req = request.nil? ? config.ruby_request : Herve::Ruby::Request.parse(request)
+        config.matching_ruby(req)
+      end
+
+      def self.current_platform_string
+        platform = ENV["HERVE_TEST_PLATFORM"] || RUBY_PLATFORM
+        case platform
+        when "x86_64-linux"
+          "x86_64_linux"
+        when "aarch64-darwin"
+          "arm64_sonoma"
+        when "aarch64-linux"
+          "arm64_linux"
+        else
+          raise Error, "herve does not support #{platform}"
+        end
+      end
+    end
+
+    require_relative "ruby_commands/find"
+    require_relative "ruby_commands/install"
+    require_relative "ruby_commands/list"
+    require_relative "ruby_commands/pin"
+    require_relative "ruby_commands/run"
+    require_relative "ruby_commands/uninstall"
+
+    CLI.register "ruby" do |cli|
+      cli.register "find", RubyCommands::Find
+      cli.register "install", RubyCommands::Install
+      cli.register "list", RubyCommands::List
+      cli.register "pin", RubyCommands::Pin
+      cli.register "run", RubyCommands::Run
+      cli.register "uninstall", RubyCommands::Uninstall
+    end
+
+    %w[find install list pin run uninstall].each do |cmd|
+      before("ruby #{cmd}") do |args|
+        setup_config(args)
+        setup_logger(args)
+      end
+    end
+  end
+end

data/lib/herve/cli/shell_commands/completion.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "completely"
+
+module Herve
+  module CLI
+    module ShellCommands
+      class Completion < BaseCommand
+        desc "generate completion for your shell"
+        argument :shell, desc: "your shell", required: true, values: SUPPORTED_SHELLS
+
+        def call(shell:, **_args)
+          raise Error, "unsupported shell '#{shell}'" unless SUPPORTED_SHELLS.include?(shell)
+
+          if shell == "zsh"
+            puts "autoload -Uz +X compinit && compinit"
+            puts "autoload -Uz +X bashcompinit && bashcompinit"
+          end
+
+          puts Completely::Completions.new(generate_completion_data).script
+        end
+
+        private
+
+        def generate_completion_data
+          data = {}
+          update_data_with_commands(data, cli_root_node)
+          program_name = Dry::CLI::ProgramName.call
+          data[program_name] = data.keys.reject { |k| k.include?(" ") } << "help"
+          data
+        end
+
+        def update_data_with_commands(data, node, prefix: nil)
+          node.children.each do |name, subnode|
+            key = prefix.nil? ? name : "#{prefix} #{name}"
+            if subnode.command
+              arguments, options = command(subnode.command)
+              update_data_with_arguments(data, key, arguments)
+              update_data_with_options(data, key, options)
+            elsif subnode.children
+              data[key] = subnode.children.keys
+              update_data_with_commands(data, subnode, prefix: key)
+            end
+          end
+        end
+
+        def cli_root_node
+          CLI.get({}).instance_variable_get(:@node)
+        end
+
+        def command(command)
+          args = command.arguments.map { |arg| argument_values(arg) }
+          options = command.options.to_h { |opt| ["--#{opt.name.to_s.gsub("_", "-")}", option_values(opt)] }
+          options["--help"] = []
+          [args, options]
+        end
+
+        def argument_values(argument)
+          return ["<directory>"] if argument.name.to_s.end_with?("dir")
+
+          argument.values
+        end
+
+        def option_values(option)
+          return ["<directory>"] if option.name.to_s.end_with?("dir")
+          return option.values if option.values
+
+          []
+        end
+
+        def update_data_with_arguments(data, name, arguments)
+          values = arguments.shift || []
+          data[name] = values.dup
+          values.each { |v| update_data_with_arguments(data, "#{name}*#{v}", arguments) }
+        end
+
+        def update_data_with_options(data, name, options)
+          data[name] ||= []
+          data[name].concat(options.keys)
+          options.each do |opt, values|
+            next if values.empty?
+
+            data["#{name}*#{opt}"] = values
+          end
+        end
+      end
+    end
+  end
+end

data/lib/herve/cli/shell_commands/env.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module ShellCommands
+      class Env < BaseCommand
+        desc "generate environment to configure your shell"
+        argument :shell, desc: "your shell", required: true, values: SUPPORTED_SHELLS
+
+        def call(shell:, **_args)
+          ruby = config.project_ruby
+          env = Config.env_for(ruby)
+          unset = env.select { |_k, v| v.nil? }.keys
+          set = env.compact
+          case shell
+          when "bash", "zsh"
+            env_bash(unset, set)
+          else
+            raise Error, "unsupported shell '#{shell}'"
+          end
+        end
+
+        private
+
+        def env_bash(unset, set)
+          puts "unset #{unset.join(" ")}" unless unset.empty?
+          set.each do |var, val|
+            puts "export #{var}=#{val}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/herve/cli/shell_commands/init.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module ShellCommands
+      class Init < BaseCommand
+        desc "generate environment to configure your shell"
+        argument :shell, desc: "your shell", required: true, values: SUPPORTED_SHELLS
+
+        def call(shell:, **)
+          case shell
+          when "bash"
+            init_bash
+          when "zsh"
+            init_zsh
+          else
+            raise Error, "unsupported shell '#{shell}'"
+          end
+        end
+
+        private
+
+        def init_bash
+          puts <<~ENDOFTEXT
+            _herve_autoload_hook() {
+                eval "$(#{config.current_exe} shell env bash)"
+            }
+            _herve_autoload_hook
+            chpwd_hook() {
+                if [[ "$PWD" != "$_OLDPWD" ]]; then
+                    _herve_autoload_hook
+                    _OLDPWD="$PWD"
+                fi
+            }
+            _OLDPWD="$PWD"
+            PROMPT_COMMAND="_chpwd_hook${PROMPT_COMMAND:*; $PROMPT_COMMAND}"
+          ENDOFTEXT
+        end
+
+        def init_zsh
+          puts <<~ENDOFTEXT
+            autoload -U add-zsh-hook
+            _herve_autoload_hook() {
+              eval "$(#{config.current_exe} shell env zsh)"
+            }
+            add-zsh-hook chpwd _herve_autoload_hook
+            _herve_autoload_hook
+          ENDOFTEXT
+        end
+      end
+    end
+  end
+end

data/lib/herve/cli/shell_commands.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module ShellCommands
+      # Supported shells
+      # @return [Array<String>]
+      SUPPORTED_SHELLS = %w[bash zsh].freeze
+    end
+
+    require_relative "shell_commands/completion"
+    require_relative "shell_commands/env"
+    require_relative "shell_commands/init"
+
+    CLI.register "shell" do |cli|
+      cli.register "completion", ShellCommands::Completion
+      cli.register "env", ShellCommands::Env
+      cli.register "init", ShellCommands::Init
+    end
+
+    %w[env init].each do |cmd|
+      before("shell #{cmd}") do |args|
+        setup_config(args)
+      end
+    end
+  end
+end

data/lib/herve/cli.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "logger"
+require "rainbow"
+require "dry/cli"
+
+module Herve
+  module CLI
+    extend Dry::CLI::Registry
+
+    class BaseCommand < Dry::CLI::Command
+      # @return [Config]
+      attr_reader :config
+      # @return [Logger]
+      attr_reader :logger
+
+      class << self
+        def inherited(klass)
+          super
+
+          klass.option :ruby_dir, desc: "ruby directories to use"
+          klass.option :project_dir, desc: "project directory to use"
+          klass.option :verbose, desc: "Add verbosity", type: :flag, aliases: %w[-v]
+        end
+      end
+
+      private
+
+      def setup_config(options)
+        # Unfortunately, Rainbow checks STDOUT and STDERR
+        Rainbow.enabled = $stdout.tty? && $stderr.tty?
+
+        config = Config.from_env_and_options(ENV, options)
+
+        ruby_dir = options[:ruby_dir]
+        ruby_dirs = if ruby_dir.nil?
+                      config.default_ruby_dirs
+                    else
+                      ruby_dir.split(":").map { |rd| config.root_dir.join(rd) }
+                    end
+        config.ruby_dirs = ruby_dirs
+        @config = config
+      end
+
+      def setup_logger(options)
+        logger = Logger.new($stdout)
+        logger.level = options[:verbose] ? Logger::DEBUG : Logger::INFO
+        logger.formatter = proc do |severity, _datetime, _progname, msg|
+          colored_msg = case severity
+                        when "FATAL", "ERROR"
+                          Rainbow(msg).red
+                        when "DEBUG"
+                          Rainbow(msg).darkslategray
+                        else
+                          msg
+                        end
+          "#{colored_msg}\n"
+        end
+        @logger = logger
+      end
+    end
+
+    require_relative "cli/gem_command"
+    require_relative "cli/ruby_commands"
+    require_relative "cli/shell_commands"
+  end
+end

data/lib/herve/config.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "xdg"
+require "json"
+
+module Herve
+  # @private environment variables handle by herve
+  ENV_VARS = (%w[RUBY_ROOT RUBY_ENGINE RUBY_VERSION RUBYLIB RUBYOPT] +
+              ENV.keys.select { |v| v.start_with?("GEM_") || v.start_with?("BUNDLE") }).freeze
+  # Base URL to fetch releases
+  RELEASES_URL = "https://api.github.com"
+
+  class ConfigError < Error; end
+
+  class Config
+    DEFAULT_ROOT_DIR = "/"
+    DEFAULT_SEARCH_RUBIES = %w[$HOME/.rubies /opt/rubies /usr/local/rubies].freeze
+
+    attr_reader :root_dir, :project_dir, :current_exe, :gemfile, :cache, :release_base_url
+    attr_accessor :ruby_dirs
+
+    class << self
+      def from_env_and_options(env, options)
+        root_dir = Pathname.new(env["RV_ROOT_DIR"] || DEFAULT_ROOT_DIR)
+        project_dir = if options.key?(:project_dir) && !options[:project_dir].nil?
+                        Pathname.new(options[:project_dir])
+                      else
+                        find_project_dir(Pathname.pwd, root_dir)
+                      end
+        bundle_gemfile = env.fetch("BUNDLE_GEMFILE", nil)
+        gemfile = bundle_gemfile ? Pathname.new(bundle_gemfile) : nil
+        env.fetch("HERVE_RELEASES_URL", RELEASES_URL)
+        new(root_dir, project_dir, gemfile)
+      end
+
+      # @param [Ruby,nil] ruby
+      # @return [Array(Array<String>, Hash(String => String)>)]
+      def env_for(ruby)
+        env = ENV_VARS.to_h { |var| [var, nil] }
+        paths = split_path(ENV["PATH"])
+
+        old_ruby_paths = %w[RUBY_ROOT GEM_ROOT GEM_HOME].map { |v| ENV[v] }
+                                                        .compact
+                                                        .map { |p| File.join(p, "bin") }
+        old_gem_paths = split_path(ENV["GEM_PATH"])
+
+        # Remove old Ruby and Gem paths from PATH
+        paths.delete_if { |p| old_ruby_paths.include?(p) || old_gem_paths.include?(p) }
+        set_env_for(ruby, env, paths) unless ruby.nil?
+        env["PATH"] = paths.join(":")
+        env
+      end
+
+      private
+
+      def find_project_dir(cwd, root_dir)
+        project_dir = cwd
+        loop do
+          ruby_version = project_dir.join(".ruby-version")
+          return project_dir if ruby_version.exist?
+          return nil if project_dir == root_dir
+
+          parent = project_dir.parent
+          return nil if parent == project_dir
+
+          project_dir = parent
+        end
+      end
+
+      def split_path(path)
+        (path || "").split(":")
+      end
+
+      def set_env_for(ruby, env, paths)
+        gem_paths = []
+        paths.insert(0, ruby.bin_path.to_s)
+        env["RUBY_ROOT"] = ruby.path.to_s
+        ruby_request = ruby.version
+        env["RUBY_ENGINE"] = ruby_request.engine.name
+        env["RUBY_VERSION"] = ruby_request.version_number
+        if ruby.gem_home
+          gem_home = ruby.gem_home
+          gem_home_bin = gem_home.join("bin").to_s
+          paths.insert(0, gem_home_bin)
+          gem_paths.insert(0, gem_home_bin)
+          env["GEM_HOME"] = gem_home.to_s
+        end
+        if ruby.gem_root
+          gem_root = ruby.gem_root
+          gem_root_bin = gem_root.join("bin").to_s
+          paths.insert(0, gem_root_bin)
+          gem_paths.insert(0, gem_root_bin)
+          env["GEM_ROOT"] = gem_root.to_s
+        end
+        env["GEM_PATH"] = gem_paths.join(":")
+      end
+    end
+
+    def initialize(root_dir, project_dir, gemfile, release_base_url = RELEASES_URL)
+      @root_dir = root_dir
+      @project_dir = project_dir
+      @current_exe = Pathname.new($PROGRAM_NAME).realpath
+      @gemfile = gemfile
+      @release_base_url = release_base_url
+      @cache = Cache.new(Pathname.new(XDG::Cache.new.home).join("herve"))
+    end
+
+    def default_ruby_dirs
+      DEFAULT_SEARCH_RUBIES.map do |dir|
+        path = Herve.expand_path(dir)
+        joinable_path = path.relative_path_from("/")
+        joined_path = root_dir.join(joinable_path)
+        if joined_path.split.last.to_s == ".rubies"
+          # Ensure ~/.rubies is in list, even if it does not exist yet
+          joined_path
+        else
+          begin
+            joined_path.realpath
+          rescue SystemCallError
+            nil
+          end
+        end
+      end.compact
+    end
+
+    def rubies
+      discover_rubies
+    end
+
+    def project_ruby
+      matching_ruby(ruby_request)
+    end
+
+    # @return [Ruby::Request,nil]
+    def ruby_request
+      return nil if project_dir.nil?
+
+      begin
+        file = project_dir.join(".ruby-version")
+        Ruby::Request.parse(File.read(file))
+      rescue Error
+        nil
+      rescue SystemCallError => e
+        raise Error, e.message
+      end
+    end
+
+    def matching_ruby(request)
+      return nil if request.nil?
+
+      rubies.reverse.find { |ruby| request.satisfied_by(ruby) }
+    end
+
+    def ruby_version
+      file = project_dir.join(".ruby-version")
+      raise ConfigError, "no .ruby-version file in #{project_dir}" unless file.exist?
+
+      file.read
+    end
+
+    def ruby_version=(version)
+      dir = project_dir || Dir.cwd
+      dir.join(".ruby-version").write("#{version}\n")
+    end
+
+    private
+
+    def discover_rubies
+      paths = []
+      ruby_dirs.select(&:exist?).map do |dir|
+        dir.children.select do |child|
+          paths += child.children.select(&:directory?) if child.directory? && child.readable?
+        end
+      end
+
+      paths.map do |path|
+        cached_ruby(path) || Ruby.from_directory(path)
+      end
+    end
+
+    def cached_ruby(path)
+      key = cache_key_from_path(path)
+      return nil if key.nil?
+
+      entry = cache.entry(:ruby, "interpreters", key)
+      begin
+        content = File.read(entry.path)
+        cached_ruby = JSON.parse(content)
+      rescue SystemCallError, JSON::ParserError
+        return nil
+      end
+      return cached_ruby if cached_ruby.valid?
+
+      entry.path.delete
+      nil
+    end
+
+    def cache_key_from_path(path)
+      bin = path.join("bin").join("ruby")
+      return nil unless bin.exist?
+
+      timestamp = Cache::Timestamp.path(bin)
+      Cache.digest("#{timestamp}#{bin}")
+    end
+  end
+end

data/lib/herve/release.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Herve
+  VERSION = "0.1.1"
+end

data/lib/herve/ruby/engine.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Herve
+  class Ruby
+    class Engine
+      # Known engines, in priority order
+      KINDS = %i[ruby jruby truffleruby mruby].freeze
+
+      attr_reader :kind
+
+      def initialize(name)
+        @name = name
+        @kind = KINDS.find { |k| k.to_s == name } || :unknown
+      end
+
+      def name
+        @name.dup
+      end
+      alias to_s name
+
+      def <=>(other)
+        priority(kind) <=> priority(other.kind)
+      end
+
+      def ==(other)
+        kind == other.kind
+      end
+
+      private
+
+      def priority(kind)
+        return 100 if kind == :unknown
+
+        KINDS.index(kind)
+      end
+    end
+  end
+end