herve 0.1.1

data/lib/herve/ruby/request.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Herve
+  class Ruby
+    # Error on Request
+    class RequestError < Error; end
+
+    Request = Data.define(:engine, :major, :minor, :patch, :tiny, :prerelease)
+
+    class Request
+      # @private Version fields
+      VERSION_FIELDS = %i[major minor patch tiny prerelease].freeze
+      # @private Regex to check a character is alphabetic
+      ALPHA_RE = /^[[:alpha:]]/
+
+      class << self
+        def parse(str)
+          raise RequestError, "invalid string" if str.empty?
+
+          str = str.strip
+          engine, version = if str[0] =~ ALPHA_RE
+                              str.split("-", 2)
+                            else
+                              ["ruby", str]
+                            end
+
+          major, minor, patch, tiny, pre = dissect_version(version)
+          new(Engine.new(engine), major, minor, patch, tiny, pre)
+        end
+
+        def dissect_version(version)
+          return [nil] * 4 if version.nil?
+
+          number = nil
+          pre = nil
+          if version[0] =~ ALPHA_RE
+            raise RequestError, "invalid version" unless version == "dev"
+
+            pre = version
+          else
+            number, pre = version.split("-", 2)
+          end
+
+          numbers = if number
+                      number.split(".").map(&:to_i)
+                    else
+                      []
+                    end
+          raise RequestError, "too many numbers in version #{version}" if numbers.size > 4
+
+          numbers.concat([nil] * (4 - numbers.size))
+          numbers << pre
+        end
+      end
+
+      def to_s # rubocop:disable Metrics/AbcSize
+        str = engine.to_s
+        unless major.nil?
+          str << "-#{major}"
+          unless minor.nil?
+            str << ".#{minor}"
+            unless patch.nil?
+              str << ".#{patch}"
+              str << ".#{tiny}" unless tiny.nil?
+            end
+          end
+        end
+
+        str << "-#{prerelease}" if prerelease
+        str
+      end
+
+      def find_match_in(rubies)
+        rubies.find { |ruby| satisfied_by(ruby) }
+      end
+
+      def satisfied_by(ruby)
+        other = ruby.version
+
+        (engine == other.engine) && check_fields(other, VERSION_FIELDS)
+      end
+
+      def version_number
+        VERSION_FIELDS.map { |m| send(m) }.compact.join(".")
+      end
+
+      def <=>(other)
+        res = engine <=> other.engine
+        return res if res != 0
+
+        return 1 if !major.nil? && other.major.nil?
+        return 1 if !major.nil? && (major > other.major)
+        return -1 if !major.nil? && (major < other.major)
+        return 1 if !minor.nil? && other.minor.nil?
+        return 1 if !minor.nil? && (minor > other.minor)
+        return -1 if !minor.nil? && (minor < other.minor)
+        return 1 if !patch.nil? && other.patch.nil?
+        return 1 if !patch.nil? && (patch > other.patch)
+        return -1 if !patch.nil? && (patch < other.patch)
+        return 1 if !tiny.nil? && other.tiny.nil?
+        return 1 if !tiny.nil? && (tiny > other.tiny)
+        return -1 if !tiny.nil? && (tiny < other.tiny)
+        return 1 if prerelease.nil? && !other.prerelease.nil?
+        return -1 if !prerelease.nil? && other.prerelease.nil?
+        return 1 if !prerelease.nil? && (prerelease > other.prerelease)
+        return -1 if !prerelease.nil? && (prerelease < other.prerelease)
+
+        0
+      end
+
+      private
+
+      def check_fields(other, fields)
+        fields.all? do |field|
+          value = send(field)
+          value.nil? || (value == other.send(field))
+        end
+      end
+    end
+  end
+end

data/lib/herve/ruby.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Herve
+  # Error on Ruby
+  class RubyError < Error; end
+
+  class Ruby
+    attr_reader :key, :version, :path, :symlink, :arch, :os, :gem_root
+
+    RUBY_EXTRACT_SCRIPT = <<~ENDOFSCRIPT
+      puts(Object.const_defined?(:RUBY_ENGINE) ? RUBY_ENGINE : 'ruby')
+      puts(RUBY_VERSION)
+      puts(Object.const_defined?(:RUBY_PLATFORM) ? RUBY_PLATFORM : 'unknown')
+      puts(Object.const_defined?(:RbConfig) && RbConfig::CONFIG['host_cpu'] ? RbConfig::CONFIG['host_cpu'] : 'unknown')
+      puts(Object.const_defined?(:RbConfig) && RbConfig::CONFIG['host_os'] ? RbConfig::CONFIG['host_os'] : 'unknown')
+      puts(begin; require 'rubygems'; Gem.default_dir; rescue ScriptError, NoMethodError; end)
+    ENDOFSCRIPT
+
+    class << self
+      def from_directory(directory)
+        dir = Pathname.new(directory)
+        raise RubyError, "invalid directory #{directory}" if !dir.exist? || dir.empty?
+
+        ruby_bin = dir.join("bin", "ruby")
+        raise RubyError, "no ruby executable found" unless ruby_bin.executable?
+
+        extract_info(ruby_bin, dir)
+      end
+
+      private
+
+      def extract_info(ruby_bin, path)
+        symlink = find_symlink_target(ruby_bin)
+
+        data = run_ruby_with_script(ruby_bin, RUBY_EXTRACT_SCRIPT)
+        ruby_engine = data[0]
+        ruby_version = data[1]
+        ruby_platform = data[2]
+        host_cpu = data[3]
+        host_os = data[4]
+        gem_root = data[5].empty? ? nil : Pathname.new(data[5])
+
+        version = Request.parse("#{ruby_engine}-#{ruby_version}")
+        host_cpu = extract_arch_from_platform(ruby_platform) if host_cpu == "unknown"
+        host_os = extract_os_from_platform(ruby_platform) if host_os == "unknown"
+
+        new("#{version}-#{host_os}-#{host_cpu}",
+            version,
+            path,
+            symlink,
+            normalize_arch(host_cpu),
+            normalize_os(host_os),
+            gem_root)
+      end
+
+      def find_symlink_target(ruby_bin)
+        ruby_bin.realpath if ruby_bin.symlink?
+      end
+
+      def run_ruby_with_script(ruby_bin, script)
+        output = nil
+        # clean up env to run ruby
+        env = Config.env_for(nil)
+        IO.popen(env, [ruby_bin.to_s, "-e", script]) do |io|
+          output = io.read
+        end
+
+        raise RubyError, "running ruby failed with status #{$CHILD_STATUS}" if output.nil? || output.empty?
+
+        output.lines.map(&:strip)
+      end
+
+      def extract_arch_from_platform(platform)
+        if platform.include?("aarch64") || platform.include?("arm64")
+          "aarch64"
+        elsif platform.include?("x86_64") || platform.include?("amd64")
+          "x86_64"
+        elsif platform.include?("i386") || platform.include?("i686")
+          "x86"
+        else
+          "unknown"
+        end
+      end
+
+      def extract_os_from_platform(platform)
+        if platform.include?("darwin")
+          "darwin"
+        elsif platform.include?("linux")
+          "linux"
+        elsif platform.include?("mingw") || platform.include?("mswin")
+          "windows"
+        else
+          "unknown"
+        end
+      end
+
+      def normalize_arch(arch)
+        case arch
+        when "aarch64", "arm64"
+          "aarch64"
+        when "x86_64", "amd64"
+          "x86_64"
+        when "i386", "i686"
+          "x86"
+        else
+          arch
+        end
+      end
+
+      def normalize_os(os)
+        if os.include?("darwin")
+          "macos"
+        elsif os.include?("linux")
+          "linux"
+        elsif os.include?("mingw") || os.include?("mswin") || os.include?("window")
+          "windows"
+        elsif os.include?("freebsd")
+          "freebsd"
+        elsif os.include?("netbsd")
+          "netbsd"
+        elsif os.include?("openbsd")
+          "openbsd"
+        else
+          os
+        end
+      end
+    end
+
+    def initialize(key, version, path, symlink, arch, os, gem_root)
+      @key = key
+      @version = version
+      @path = path
+      @symlink = symlink
+      @arch = arch
+      @os = os
+      @gem_root = gem_root
+    end
+
+    def display_name
+      version.to_s
+    end
+
+    def valid?
+      executable_path.exist?
+    end
+
+    def executable_path
+      bin_path.join("ruby")
+    end
+
+    def bin_path
+      path.join("bin")
+    end
+
+    def gem_home
+      Pathname.new(Dir.home).join(".gem", version.engine.name, version.version_number)
+    end
+
+    def to_json(state = nil, *)
+      hsh = {
+        key: key,
+        version: display_name,
+        path: path.to_s,
+        arch: arch,
+        os: os,
+        gem_root: gem_root.to_s
+      }
+      hsh[:symlink] = symlink.to_s if symlink
+      JSON::State.from_state(state).generate(hsh)
+    end
+
+    # Sort by version
+    # @return [-1, 0, 1, nil]
+    def <=>(other)
+      version <=> other.version
+    end
+
+    # Check equality. +other+ must be a {Ruby} with same {#version}, {#os}, {#arch} and {#path}.
+    # @param [Object] other
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Ruby) && (version == other.version) && (arch == other.arch) && (os == other.os) && (path == other.path)
+    end
+  end
+end
+
+require_relative "ruby/engine"
+require_relative "ruby/request"

data/lib/herve/version.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Herve
+  # Error while handling version
+  class VersionError < Error; end
+
+  # Version handling
+  class Version
+    include Comparable
+
+    # Full version, as String
+    attr_reader :version
+    # Version segments
+    attr_reader :segments
+
+    def initialize(version)
+      @version = normalized = normalize_version(version)
+      @segments = parse_segments(normalized)
+    end
+
+    def initialize_copy(_other)
+      @version = @version.dup
+      @segments = @segments.dup
+    end
+
+    # Say if self is a prerelase
+    def prerelease?
+      @segments.any? { |s| s.is_a?(String) }
+    end
+
+    # Get segments with trailing zeros in release and prerelease parts removed
+    def canonical_segments
+      cseg = @segments.dup
+      pre_index = pre_index_in_segments || cseg.size
+      (pre_index - 1).downto(1) do |i|
+        break unless cseg[i].zero?
+
+        cseg.delete_at(i)
+      end
+
+      if pre_index < cseg.size
+        (cseg.size - 1).downto(pre_index + 1) do |i|
+          break unless cseg[i].zero?
+
+          cseg.delete_at(i)
+        end
+      end
+
+      cseg
+    end
+
+    # Give a new version from self without prerelease part
+    def release
+      pre_index = pre_index_in_segments
+      return clone if pre_index.nil?
+
+      new_segments = @segments[0...pre_index]
+      Version.new(new_segments.join("."))
+    end
+
+    # eql? is strict equality. Versions are eql? if, and only if, hey have same version, with same precision
+    def eql?(other)
+      (self.class == other.class) && (segments == other.segments)
+    end
+
+    # Compares this version with +other+ returning -1, 0, or 1 if the
+    # other version is larger, the same, or smaller than this
+    # one. Attempts to compare to something that's not a
+    # Herve::Version or a valid version String return +nil+.
+    def <=>(other)
+      begin
+        return self <=> self.class.new(other) if other.is_a?(String)
+      rescue VersionError # rubocop:disable Lint/SuppressedException
+      end
+      return nil unless other.is_a?(Version)
+
+      compare_segments(canonical_segments, other.canonical_segments)
+    end
+
+    def inspect
+      "#<#{self.class} #{version.inspect}>"
+    end
+
+    private
+
+    def normalize_version(version)
+      nver = version.strip
+      return "0" if nver.empty?
+
+      if nver.include?("\n") && (nver.split("\n").size > 1)
+        raise VersionError, "version cannot contain new lines (#{version})"
+      end
+
+      raise VersionError, "version cannot contain consecutive dots (#{version})" if nver.include?("..")
+      raise VersionError, "version cannot end with a dot (#{version})" if nver.end_with?(".")
+      raise VersionError, "version cannot contain spaces (#{version})" if nver.include?(" ")
+
+      nver.to_s.freeze
+    end
+
+    def parse_segments(version)
+      version = version.sub("-", ".pre.")
+      segments = version.scan(/[0-9]+|[a-z]+/i).map do |s|
+        s =~ /^\d+$/ ? s.to_i : s
+      end
+      segments = [0] if segments.empty?
+      segments.freeze
+    end
+
+    def pre_index_in_segments
+      @segments.each_with_index do |segment, i|
+        return i if segment.is_a?(String)
+      end
+      nil
+    end
+
+    def compare_segments(lcs, rcs)
+      return 0 if lcs == rcs
+
+      limit = [lcs.size, rcs.size].max
+
+      limit.times do |i|
+        left = lcs[i] || 0
+        right = rcs[i] || 0
+        next if left == right
+        return -1 if left.is_a?(String) && right.is_a?(Numeric)
+        return 1 if left.is_a?(Numeric) && right.is_a?(String)
+
+        return left <=> right
+      end
+
+      0
+    end
+  end
+end

data/lib/herve.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Herve
+  # Base Herve error class
+  class Error < StandardError; end
+
+  DEFAULT_RUBIES = "$HOME/.rubies"
+
+  # Expand a path containing environment variables
+  # @param [String] path
+  # @return [Pathname] expanded path, or +path+ if nothing to expand
+  def self.expand_path(path)
+    return Pathname.new(path) unless path.include?("$")
+
+    new_path = path.gsub(/\$\w+/) do |envvar|
+      ENV[envvar[1..]] || ""
+    end
+    Pathname.new(new_path)
+  end
+end
+
+require_relative "herve/version"
+require_relative "herve/cache"
+require_relative "herve/config"
+require_relative "herve/ruby"
+require_relative "herve/cli"

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: herve
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- sd77
+bindir: exe
+cert_chain: []
+date: 2025-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: completely
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+- !ruby/object:Gem::Dependency
+  name: digest-xxhash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: xdg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+email:
+- sd77@ld77.eu
+executables:
+- herve
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/herve
+- lib/herve.rb
+- lib/herve/cache.rb
+- lib/herve/cache/entry.rb
+- lib/herve/cache/shard.rb
+- lib/herve/cache/timestamp.rb
+- lib/herve/cli.rb
+- lib/herve/cli/gem_command.rb
+- lib/herve/cli/ruby_commands.rb
+- lib/herve/cli/ruby_commands/find.rb
+- lib/herve/cli/ruby_commands/install.rb
+- lib/herve/cli/ruby_commands/list.rb
+- lib/herve/cli/ruby_commands/pin.rb
+- lib/herve/cli/ruby_commands/run.rb
+- lib/herve/cli/ruby_commands/uninstall.rb
+- lib/herve/cli/shell_commands.rb
+- lib/herve/cli/shell_commands/completion.rb
+- lib/herve/cli/shell_commands/env.rb
+- lib/herve/cli/shell_commands/init.rb
+- lib/herve/config.rb
+- lib/herve/release.rb
+- lib/herve/ruby.rb
+- lib/herve/ruby/engine.rb
+- lib/herve/ruby/request.rb
+- lib/herve/version.rb
+homepage: https://codeberg.org/sd77/herve
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://codeberg.org/sd77/herve
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://codeberg.org/sd77/herve
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Herve is like rv, but pure ruby
+test_files: []