herve 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec25d37bb470a28f6173a95457d5c8c375e9a63c2904579d64a0a2324f05f4fa
+  data.tar.gz: fa49ed9155893e3d74682842834cd5cd93656baee1e8ec26d57c06484ead7a75
+SHA512:
+  metadata.gz: 4e876114eaa14969974614e29f0f7408a0889379f663b8146b3407c57c4b29de92b5efdc4f480a8d41f86e799d0548cd7d8508a3e4af8289e28893bbdf2d4aa5
+  data.tar.gz: 7820104f12d2c484251f6d58d36b86102ed52e8531cc8da5ef2a4c5fadfe84b82e0d483f35a37d861ad01bfd049ac72c925a500586c2eabbaa31befd21314ab4

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,30 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.2
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 20
+
+Style/Documentation:
+  Enabled: false
+
+Style/FetchEnvVar:
+  Enabled: false
+
+Style/StderrPuts:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-08-26
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 sd77
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# Herve
+
+Welcome to Herve, a Ruby version manager.
+
+Do you knwon [rv](https://github.com/spinel-coop/rv-ruby/), a Ruby version manager with high ambitions? It seems so cool, but unfortunately, it is written in Rust;-)
+
+Herve is a reimplementation in Ruby. My first goal is to be compatible with `rv`, and second one is to have fun.
+
+## Installation
+
+```bash
+gem install herve
+
+#bash
+echo 'eval "$(herve shell init bash)"' >> ~/.bashrc
+eval "$(herve shell init bash)"
+```
+
+## Usage
+
+```bash
+echo "3.4.1" > .ruby-version
+herve ruby install 3.4.1
+```
+
+## Why Herve
+
+Herve is a French first name. It sounds like "rv" in French.
+
+## Contributing
+
+Bug reports and pull requests are welcome on Codeberg at <https://codeberg.org/sd77/herve>.
+
+## License
+
+Herve is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/herve

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "dry/cli"
+require "herve"
+
+begin
+  Dry::CLI.new(Herve::CLI).call
+rescue Herve::Error, Gem::Exception => e
+  $stderr.puts "#{Rainbow("Error:").red} #{e}"
+end

data/lib/herve/cache/entry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+module Herve
+  class Cache
+    class Entry
+      attr_reader :path
+
+      def initialize(dir, file)
+        @path = dir.join(file)
+      end
+
+      def dir
+        @path.parent
+      end
+
+      def shard
+        Shard.new(dir)
+      end
+
+      def read
+        exist? ? File.read(path) : nil
+      end
+
+      def read_json
+        data = read
+        return nil if data.nil?
+
+        begin
+          JSON.parse(data)
+        rescue JSON::ParserError => e
+          raise CacheError, "entry #{path} should be JSON but is not: #{e.message}"
+        end
+      end
+
+      def write(data)
+        @path.parent.mkpath unless @path.parent.exist?
+        File.write(path, data)
+      end
+
+      def write_json(data)
+        write(data.to_json)
+      end
+
+      def exist?
+        path.exist?
+      end
+    end
+  end
+end

data/lib/herve/cache/shard.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Herve
+  class Cache
+    class Shard
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def entry(file)
+        Entry.new(path, file)
+      end
+    end
+  end
+end

data/lib/herve/cache/timestamp.rb

@@ -0,0 +1,26 @@
+module Herve
+  class Cache
+    class Timestamp
+      # @return [Time]
+      attr_reader :time
+
+      class << self
+        # @param [Pathname] path
+        # @return [Timestamp]
+        def path(path)
+          new(path.ctime)
+        end
+
+        # @return [Timestamp]
+        def now
+          new(Time.now)
+        end
+      end
+
+      # @param [Time] time
+      def initialize(time)
+        @time = time
+      end
+    end
+  end
+end

data/lib/herve/cache.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "digest/xxhash"
+
+module Herve
+  class CacheError < Error; end
+
+  class Cache
+    attr_reader :root
+
+    class << self
+      def digest(data)
+        Digest::XXH3_64bits.hexdigest(data)
+      end
+    end
+
+    def initialize(root)
+      @root = root
+    end
+
+    def bucket(bucket_type)
+      root.join(bucket_path(bucket_type))
+    end
+
+    def shard(bucket_type, dir)
+      Shard.new(bucket(bucket_type).join(dir))
+    end
+
+    def entry(bucket_type, dir, file)
+      Entry.new(bucket(bucket_type).join(dir), file)
+    end
+
+    private
+
+    def bucket_path(type)
+      case type
+      when :ruby
+        "ruby-v0"
+      else
+        raise CacheError, "unknown bucket type"
+      end
+    end
+  end
+end
+
+require_relative "cache/entry"
+require_relative "cache/shard"
+require_relative "cache/timestamp"

data/lib/herve/cli/gem_command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    class GemCommand < BaseCommand
+      desc "build a gem from project's gemspec"
+      argument :gemspec, desc: "gemspec to use"
+      option :force, desc: "skip validation of the spec", type: :flag
+      option :strict, desc: "consider warnings as errors when validating the spec", type: :flag
+      option :output, desc: "output gem with the given filename", aliases: %w[-o]
+
+      def call(gemspec: nil, **options)
+        @options = options
+        build_gem(config.project_dir, gemspec)
+      end
+
+      private
+
+      def build_gem(project_dir, gemspec)
+        require "rubygems/package"
+        require "rubygems/specification"
+
+        Dir.chdir(project_dir) do
+          gemspec ||= find_gemspec
+          spec = Gem::Specification.load(gemspec)
+          raise Error, "Error loading gemspec" unless spec
+
+          Gem::Package.build(spec, @options[:force], @options[:strict], @options[:output])
+        end
+      end
+
+      def find_gemspec
+        gemspecs = Dir.glob("*.gemspec")
+
+        raise Error, "Multiple gemspecs found: #{gemspecs}, please specify one" if gemspecs.size > 1
+
+        gemspecs.first
+      end
+    end
+
+    register "gem", GemCommand
+    before("gem") do |args|
+      setup_config(args)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module RubyCommands
+      class Find < BaseCommand
+        desc "search for a ruby installation"
+        argument :version, desc: "specific version to search for"
+
+        def call(version: nil, **)
+          ruby = RubyCommands.find_ruby(config, version)
+          raise RubyError, "no matching ruby" if ruby.nil?
+
+          puts ruby.executable_path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/follow_redirects"
+# require "minitar"
+require "zlib"
+
+module Herve
+  module CLI
+    module RubyCommands
+      class Install < BaseCommand
+        desc "install given ruby version"
+        argument :version, desc: "version to install", required: true
+        option :install_dir, desc: "installation directory", default: DEFAULT_RUBIES
+
+        def call(version:, **options)
+          install_dir = Herve.expand_path(options[:install_dir])
+          logger.info { "Installing ruby #{Rainbow(version).cyan} into #{Rainbow(install_dir).cyan}" }
+          requested = Herve::Ruby::Request.parse(version)
+          if requested.patch.nil?
+            raise VersionError,
+                  "major, minor and patch are required in version, but get #{version}"
+          end
+
+          url = ruby_url(requested.to_s)
+          tarball_path = local_tarball_path(config, url)
+          download_ruby_tarball_if_needed(url, tarball_path)
+
+          extract_ruby_tarball(tarball_path, install_dir)
+          logger.info { "Ruby #{Rainbow(version).cyan} installed" }
+        end
+
+        private
+
+        def ruby_url(version)
+          number = version.delete_prefix("ruby-")
+          platform = RubyCommands.current_platform_string
+
+          "https://github.com/spinel-coop/rv-ruby/releases/download/#{number}/portable-#{version}.#{platform}.bottle.tar.gz"
+        end
+
+        def local_tarball_path(config, url)
+          cache_key = Cache.digest(url)
+          config.cache.shard(:ruby, "tarballs").path.join("#{cache_key}.tar.gz")
+        end
+
+        def download_ruby_tarball_if_needed(url, tarball_path)
+          tarball_path.parent.mkpath unless tarball_path.parent.exist?
+
+          if tarball_path.exist?
+            logger.warn { "tarball #{tarball_path} already exists, skipping download" }
+          else
+            download_ruby_tarball(url, tarball_path)
+          end
+        end
+
+        def download_ruby_tarball(url, path)
+          logger.debug { "download #{url} into #{path}" }
+          client = Faraday.new(url) do |faraday|
+            faraday.response :follow_redirects
+          end
+          resp = client.get
+          File.write(path, resp.body)
+        end
+
+        def extract_ruby_tarball(tarball_path, dir)
+          dir.mkpath
+          # Do not use minitar: speed 7x
+          # Minitar.unpack(Zlib::GzipReader.new(File.open(tarball_path, "rb")), dir.to_s)
+          logger.debug { "extract ruby tarball into #{dir}" }
+          system("tar", "-C", dir.to_s, "-xf", tarball_path.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/follow_redirects"
+require "time"
+
+module Herve
+  module CLI
+    module RubyCommands
+      class List < BaseCommand
+        desc "list available ruby installations"
+        option :format, desc: "list output format", default: "text", values: %w[json text]
+        option :installed_only, desc: "only list installed rubies", type: :boolean, default: false
+
+        # @private
+        # Max age to use when there is no info in HTTP response
+        DEFAULT_MAX_AGE = 60
+        # @private
+        # Minimum cache duration to not check less than every minute
+        MINIMUM_CACHE_TTL = 60
+        # @private
+        ARCH_REGEX = /portable-ruby-[\d.]+\.(?<arch>[a-zA-Z0-9_]+)\.bottle\.tar\.gz/
+
+        # @private
+        # Associate a ruby name with its assets
+        Release = Data.define(:name, :assets)
+        # @private
+        # Ruby entry: Ruby + metadata
+        Entry = Data.define(:installed, :active, :details) do
+          def to_json(state = nil, *)
+            hsh = {
+              installed: installed,
+              active: active,
+              details: details
+            }
+            JSON::State.from_state(state).generate(hsh)
+          end
+        end
+
+        def call(**options)
+          installed_rubies = config.rubies
+          active_ruby = config.project_ruby
+
+          if options[:installed_only]
+            if installed_rubies.empty?
+              logger.warn { "No Ruby installation found." }
+              logger.info do
+                "Try installin Ruby with '#{Rainbow("herve ruby install").cyan}' or check your configuration"
+              end
+              return
+            end
+
+            print_rubies(installed_rubies, active_ruby, options[:format])
+            return
+          end
+
+          all_releases = fetch_available_releases(config.cache)
+
+          rubies_map = {}
+          installed_rubies.each do |ruby|
+            rubies_map[ruby.display_name] ||= []
+            rubies_map[ruby.display_name] << ruby
+          end
+
+          desired_od, desired_arch = parse_arch_string(RubyCommands.current_platform_string)
+          available_rubies = all_releases.map do |release|
+            release["assets"].map do |asset|
+              ruby_from_release(release, asset)
+            end
+          end.flatten
+          available_rubies.filter! { |ruby| (ruby.os == desired_od) && (ruby.arch == desired_arch) }
+
+          available_rubies.each do |ruby|
+            display_name = ruby.display_name
+            next if rubies_map.key?(display_name)
+
+            rubies_map[display_name] ||= []
+            rubies_map[display_name] << ruby
+          end
+
+          if rubies_map.empty? && options[:format] == "text"
+            logger.warn { "No rubies found for your platform" }
+            return
+          end
+
+          print_rubies(rubies_map.values.flatten, active_ruby, options[:format])
+        end
+
+        private
+
+        def print_rubies(rubies, active_ruby, format)
+          entries = rubies.sort.map do |ruby|
+            Entry.new(!ruby.path.to_s.start_with?("http"), active_ruby == ruby, ruby)
+          end
+
+          case format
+          when "text"
+            width = rubies.max { |a, b| a.display_name.length <=> b.display_name.length }.display_name.length
+            entries.each do |entry|
+              puts format_ruby_entry(entry, width)
+            end
+          when "json"
+            puts entries.to_json
+          end
+        end
+
+        def format_ruby_entry(entry, width)
+          ruby = entry.details
+          marker = entry.active ? "*" : " "
+          if entry.installed
+            format("#{marker} %#{width}s  %s  (%s)", Rainbow(ruby.version.to_s).cyan, Rainbow("[installed]").green,
+                   ruby.path)
+          else
+            format("  %#{width}s  %s", Rainbow(ruby.version.to_s).cyan, Rainbow("[available]").dark)
+          end
+        end
+
+        def fetch_available_releases(cache)
+          cache_entry = cache.entry(:ruby, "releases", "available_rubies.json")
+
+          cached_data = cache_entry.read_json
+          if cached_data
+            if Time.now < Time.strptime(cached_data["expire_at"], "%Y-%m-%d %H:%M:%S %z")
+              logger.debug { "Using cached list of releases" }
+              return cached_data["releases"]
+            end
+            logger.debug { "Cached ruby list is stale, re-validating with server" }
+          else
+            logger.debug { "No cached data" }
+          end
+
+          # No data in cache, or cache is stale
+          etag = cached_data&.fetch("etag", nil)
+          api_base = config.release_base_url
+          headers = { "User-Agent" => "herve-cli", "Accept" => "application/vnd.github+json" }
+          if etag
+            logger.debug { "Using Etag to make a conditional request: #{etag}" }
+            headers["If-None-Match"] = etag
+          end
+
+          client = Faraday.new("#{api_base}/repos/spinel-coop/rv-ruby", headers: headers) do |faraday|
+            faraday.response :raise_error
+            faraday.response :json
+          end
+          response = client.get("releases")
+
+          case response.status
+          when 304 # NotModified
+            logger.debug { "releases list is unchanged" }
+            max_age = parse_max_age(response.headers["Cache-Control"])
+            cached_data["expire_at"] = Time.now + [max_age, MINIMUM_CACHE_TTL].max
+            File.write(cache_entry.path, cached_data.to_json)
+            cached_data["releases"]
+          when 200 # OK
+            logger.debug { "Received new releases list" }
+            etag = response.headers["Etag"]
+            max_age = parse_max_age(response.headers["Cache-Control"])
+            releases = response.body
+            logger.debug { "Fetched #{releases.size} releases" }
+
+            cached_data = {
+              "expire_at" => Time.now + [max_age, MINIMUM_CACHE_TTL].max,
+              "etag" => etag,
+              "releases" => releases
+            }
+            cache_entry.write_json(cached_data)
+            releases
+          else
+            raise Faraday::Error, "Failed to fetch release (status: #{response.status})"
+          end
+        end
+
+        def parse_max_age(cache_control)
+          m = cache_control.match(/max-age=(\d+)/)
+          return DEFAULT_MAX_AGE unless m
+
+          m[1].to_i
+        end
+
+        def parse_arch_string(platform)
+          case platform
+          when "x86_64_linux"
+            %w[linux x86_64]
+          when "arm64_sonoma"
+            %w[macos aarch64]
+          when "arm64_linux"
+            %w[linux aarch64]
+          else
+            %w[unknown unknown]
+          end
+        end
+
+        def ruby_from_release(release, asset)
+          version = Herve::Ruby::Request.parse("ruby-#{release["name"]}")
+          display_name = version.to_s
+
+          m = asset["name"].match(ARCH_REGEX)
+          platform = m["arch"] || "unknown"
+          os, arch = parse_arch_string(platform)
+
+          Herve::Ruby.new("#{display_name}-#{os}-#{arch}", version, Pathname.new(asset["browser_download_url"]), nil,
+                          arch, os, nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module RubyCommands
+      class Pin < BaseCommand
+        desc "show or set ruby version for the current project"
+        argument :version, desc: "version to pin"
+
+        def call(version: nil, **)
+          if version.nil?
+            show_pinned_ruby
+          else
+            pin_ruby(version)
+          end
+        end
+
+        private
+
+        def show_pinned_ruby
+          project_dir = config.project_dir
+          raise ConfigError, "no project dir" if project_dir.nil?
+
+          version = config.ruby_version
+          logger.info { "#{Rainbow(project_dir).cyan} is pinned to Ruby #{Rainbow(version).cyan}" }
+        end
+
+        def pin_ruby(version)
+          pinned = Herve::Ruby::Request.parse(version).version_number
+          config.ruby_version = pinned
+          logger.info { "#{Rainbow(config.project_dir).cyan} pinned to Ruby #{Rainbow(version).cyan}" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Herve
+  module CLI
+    module RubyCommands
+      class Run < BaseCommand
+        desc "run a specific ruby version"
+        argument :version, desc: "ruby version to run", required: true
+
+        def call(version:, **args)
+          ruby = RubyCommands.find_ruby(config, version)
+          env = Config.env_for(ruby)
+          raise Herve::Ruby::RequestError, "no version #{request} installed" if ruby.nil?
+
+          cmd = [ruby.executable_path.to_s] + args[:args]
+          Kernel.exec(env, *cmd)
+        end
+      end
+    end
+  end
+end