mnenv 0.1.0 → 0.1.2

data/lib/mnenv/platform_detector.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Centralized platform detection for consistent OS/architecture/variant detection
+  # across the codebase. Used by binary installer, repository, and CLI.
+  class PlatformDetector
+    class UnsupportedPlatform < StandardError; end
+
+    class << self
+      # Detect the current operating system
+      # @return [String] 'linux', 'darwin', or 'windows'
+      # @raise [UnsupportedPlatform] if platform is not supported
+      def os
+        case RbConfig::CONFIG['host_os']
+        when /linux/
+          'linux'
+        when /darwin/
+          'darwin'
+        when /mswin|mingw|cygwin/
+          'windows'
+        else
+          raise UnsupportedPlatform, "Unsupported platform: #{RbConfig::CONFIG['host_os']}"
+        end
+      end
+
+      # Detect the current CPU architecture
+      # @return [String] 'arm64' or 'x86_64'
+      def arch
+        case RbConfig::CONFIG['host_cpu']
+        when /arm64|aarch64/
+          'arm64'
+        when /x86_64|x64/
+          'x86_64'
+        else
+          'x86_64' # Default fallback
+        end
+      end
+
+      # Detect libc variant (for Linux)
+      # @return [String, nil] 'musl' for Alpine/musl systems, nil for glibc
+      def variant
+        return nil unless os == 'linux'
+
+        'musl' if musl?
+      end
+
+      # Check if running on a musl-based system (Alpine Linux)
+      # @return [Boolean]
+      def musl?
+        File.exist?('/etc/alpine-release') ||
+          File.symlink?('/lib/libc.musl-x86_64.so.1')
+      rescue StandardError
+        false
+      end
+
+      # Check if running on Windows
+      # @return [Boolean]
+      def windows?
+        os == 'windows'
+      end
+
+      # Check if running on macOS
+      # @return [Boolean]
+      def macos?
+        os == 'darwin'
+      end
+
+      # Check if running on Linux
+      # @return [Boolean]
+      def linux?
+        os == 'linux'
+      end
+
+      # Get platform info as a hash
+      # @return [Hash] With keys :os, :arch, :variant
+      def to_h
+        {
+          os: os,
+          arch: arch,
+          variant: variant
+        }
+      end
+
+      # Get a human-readable platform string
+      # @return [String] e.g., "linux-x86_64", "darwin-arm64", "linux-musl-x86_64"
+      def platform_string
+        parts = [os]
+        parts << variant if variant
+        parts << arch
+        parts.join('-')
+      end
+
+      # Get all possible platform strings for binary matching
+      # (includes variant-specific and generic versions)
+      # @return [Array<String>] List of platform strings in order of preference
+      def platform_candidates
+        candidates = []
+
+        # With variant (if applicable)
+        candidates << "#{os}-#{variant}-#{arch}" if variant
+
+        # Without variant
+        candidates << "#{os}-#{arch}"
+
+        candidates
+      end
+    end
+  end
+end

data/lib/mnenv/repository.rb

@@ -2,16 +2,32 @@
 
 require 'yaml'
 require 'fileutils'
+require_relative 'versions_manager'
 
 module Mnenv
   class Repository
+    # Default versions manager (shared across all repositories)
+    class << self
+      def versions_manager
+        @versions_manager ||= VersionsManager.new
+      end
+
+      attr_writer :versions_manager
+
+      # Force update the versions data
+      def update_versions
+        versions_manager.update
+      end
+    end
+
     attr_reader :data_dir, :versions_file_path
 
-    def initialize(data_dir: nil)
-      @data_dir = data_dir || default_data_dir
+    def initialize(data_dir: nil, update: false)
+      @data_dir = data_dir || cli_data_dir || default_data_dir
       @versions_file_path = File.join(@data_dir, 'versions.yaml')
       @versions_cache = {}
-      load if File.file?(versions_file_path)
+      @update = update
+      load
     end
 
     def find(version_number) = @versions_cache[version_number]
@@ -37,22 +53,29 @@ module Mnenv
     protected
 
     def load
-      data = YAML.load_file(versions_file_path)
+      data = fetch_versions_data
       return if data.nil? || data['versions'].nil?
 
       data['versions'].each do |version_hash|
         version = version_class.new(version_hash)
-        @versions_cache[version.version] = version
+        cache_version(version)
       end
     end
 
+    # Override in subclasses for custom caching (e.g., SnapRepository uses composite keys)
+    def cache_version(version)
+      @versions_cache[version.version] = version
+    end
+
     def persist
-      FileUtils.mkdir_p(data_dir)
+      return unless @data_dir
+
+      FileUtils.mkdir_p(@data_dir)
       output = {
         'metadata' => metadata,
-        'versions' => @versions_cache.values.sort.map { |v| version_to_hash(v) }
+        'versions' => @versions_cache.values.sort.map(&:to_hash)
       }
-      File.write(versions_file_path, output.to_yaml)
+      File.write(@versions_file_path, output.to_yaml)
     end
 
     def metadata
@@ -68,38 +91,30 @@ module Mnenv
 
     def source_name = raise NotImplementedError
 
-    def default_data_dir = File.join(__dir__, '..', '..', 'data', source_name.to_s)
-
     private
 
-    def version_to_hash(version)
-      hash = {
-        'version' => version.version,
-        'published_at' => format_timestamp(version.published_at),
-        'parsed_at' => format_timestamp(version.parsed_at)
-      }
+    def cli_data_dir
+      # Check if a data directory was specified via CLI option
+      return nil unless defined?(Mnenv::Cli) && Mnenv::Cli.data_dir
 
-      # Add subclass-specific fields
-      case version
-      when GemfileVersion
-        hash['gemfile_exists'] = version.gemfile_exists
-        hash['gemfile_path'] = version.gemfile_path
-        hash['gemfile_lock_path'] = version.gemfile_lock_path
-      when SnapVersion
-        hash['revision'] = version.revision
-        hash['arch'] = version.arch
-        hash['channel'] = version.channel
-      when HomebrewVersion
-        hash['tag_name'] = version.tag_name
-        hash['commit_sha'] = version.commit_sha
-      when ChocolateyVersion
-        hash['package_name'] = version.package_name
-        hash['is_pre_release'] = version.is_pre_release
-      end
+      source_dir = Mnenv::Cli.data_dir
+      # If the CLI data-dir is specified, use it directly with the source name
+      File.join(source_dir, source_name.to_s)
+    end
 
-      hash
+    def default_data_dir
+      # Use the versions manager to ensure data is available
+      data_path = self.class.versions_manager.ensure_versions_data(update: @update)
+      File.join(data_path, source_name.to_s)
     end
 
-    def format_timestamp(t) = t&.strftime('%Y-%m-%dT%H:%M:%SZ')
+    def fetch_versions_data
+      return unless File.file?(@versions_file_path)
+
+      YAML.safe_load(File.read(@versions_file_path), permitted_classes: [Time, Symbol, Date])
+    rescue StandardError => e
+      warn "Warning: Failed to load versions from #{@versions_file_path}: #{e.message}"
+      nil
+    end
   end
 end

data/lib/mnenv/resolver

@@ -0,0 +1,72 @@
+#!/bin/bash
+# Version and source resolver for mnenv shims
+# Usage: ./resolver "version" | ./resolver "source"
+
+set -e
+
+export MNENV_ROOT="${MNENV_ROOT:-$HOME/.mnenv}"
+
+resolve_version() {
+    # 1. Check METANORMA_VERSION environment variable
+    if [ -n "$METANORMA_VERSION" ]; then
+        echo "$METANORMA_VERSION"
+        return 0
+    fi
+
+    # 2. Check .metanorma-version file (walk up directory tree)
+    local dir="$PWD"
+    while [ -n "$dir" ] && [ "$dir" != "/" ]; do
+        if [ -f "$dir/.metanorma-version" ]; then
+            cat "$dir/.metanorma-version"
+            return 0
+        fi
+        dir="${dir%/*}"
+    done
+
+    # 3. Check ~/.mnenv/version (global default)
+    if [ -f "$MNENV_ROOT/version" ]; then
+        cat "$MNENV_ROOT/version"
+        return 0
+    fi
+
+    # 4. No version found
+    return 1
+}
+
+resolve_source() {
+    # 1. Check METANORMA_SOURCE environment variable
+    if [ -n "$METANORMA_SOURCE" ]; then
+        echo "$METANORMA_SOURCE"
+        return 0
+    fi
+
+    # 2. Check .metanorma-source file (walk up directory tree)
+    local dir="$PWD"
+    while [ -n "$dir" ] && [ "$dir" != "/" ]; do
+        if [ -f "$dir/.metanorma-source" ]; then
+            cat "$dir/.metanorma-source"
+            return 0
+        fi
+        dir="${dir%/*}"
+    done
+
+    # 3. Check ~/.mnenv/source (global default)
+    if [ -f "$MNENV_ROOT/source" ]; then
+        cat "$MNENV_ROOT/source"
+        return 0
+    fi
+
+    # 4. Default to gemfile (faster for devs)
+    echo "gemfile"
+    return 0
+}
+
+# Main dispatch
+case "$1" in
+    version) resolve_version ;;
+    source)  resolve_source ;;
+    *)
+        echo "Usage: $0 {version|source}" >&2
+        exit 1
+        ;;
+esac

data/lib/mnenv/shells/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Shells
+    # Base class for shell-specific behavior
+    class BaseShell
+      def name
+        raise NotImplementedError
+      end
+
+      def shim_extension
+        raise NotImplementedError
+      end
+
+      def shim_content(executable_name)
+        raise NotImplementedError
+      end
+
+      def use_output(version, source)
+        raise NotImplementedError
+      end
+
+      def config_file
+        raise NotImplementedError
+      end
+
+      def windows?
+        false
+      end
+    end
+  end
+end

data/lib/mnenv/shells/bash.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Mnenv
+  module Shells
+    # Bash shell implementation (also works for sh, dash, zsh)
+    class BashShell < BaseShell
+      def name
+        'bash'
+      end
+
+      def shim_extension
+        '' # No extension for bash scripts
+      end
+
+      def shim_content(executable_name)
+        <<~SHIM
+          #!/bin/bash
+          set -e
+
+          export MNENV_ROOT="${MNENV_ROOT:-$HOME/.mnenv}"
+
+          # Resolve version and source using mnenv resolver
+          VERSION="$("$MNENV_ROOT/lib/mnenv/resolver" "version")"
+          SOURCE="$("$MNENV_ROOT/lib/mnenv/resolver" "source")"
+
+          if [ -z "$VERSION" ]; then
+            echo "mnenv: version not set or invalid" >&2
+            echo "Set a version with: mnenv global <version> or mnenv local <version>" >&2
+            exit 1
+          fi
+
+          if [ -z "$SOURCE" ]; then
+            echo "mnenv: source not set or invalid" >&2
+            exit 1
+          fi
+
+          # Determine executable path based on source
+          # Installed versions are in $MNENV_ROOT/installed/<version>-<source>/
+          if [ "$SOURCE" = "binary" ]; then
+            # Binary: single self-contained binary
+            EXECUTABLE="$MNENV_ROOT/installed/$VERSION-$SOURCE/metanorma"
+          else
+            # Gemfile: binstub from bundle install
+            EXECUTABLE="$MNENV_ROOT/installed/$VERSION-$SOURCE/bin/#{executable_name}"
+          fi
+
+          if [ ! -f "$EXECUTABLE" ]; then
+            echo "mnenv: #{executable_name} not installed for version $VERSION (source: $SOURCE)" >&2
+            echo "Install it with: mnenv install $VERSION --source $SOURCE" >&2
+            exit 1
+          fi
+
+          exec "$EXECUTABLE" "$@"
+        SHIM
+      end
+
+      def use_output(version, source)
+        lines = []
+        lines << "export METANORMA_VERSION=#{version}"
+        lines << "export METANORMA_SOURCE=#{source}" if source
+        lines << "# Run this in your shell, or use: eval \"$(mnenv use #{version}#{" --source #{source}" if source})\""
+        lines.join("\n")
+      end
+
+      def config_file
+        File.expand_path('~/.bashrc')
+      end
+    end
+  end
+end

data/lib/mnenv/shells/cmd.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Mnenv
+  module Shells
+    # CMD/Batch shell implementation (Windows)
+    class CmdShell < BaseShell
+      def name
+        'cmd'
+      end
+
+      def shim_extension
+        '.bat'
+      end
+
+      def shim_content(executable_name)
+        <<~SHIM
+          @echo off
+          rem mnenv shim for CMD
+
+          if defined MNENV_ROOT (
+            set "MNENV_ROOT=%MNENV_ROOT%"
+          ) else (
+            set "MNENV_ROOT=%USERPROFILE%\\.mnenv"
+          )
+
+          rem Resolve version and source
+          set "VERSION="
+          set "SOURCE="
+
+          rem Check environment variables first
+          if defined METANORMA_VERSION set "VERSION=%METANORMA_VERSION%"
+          if defined METANORMA_SOURCE set "SOURCE=%METANORMA_SOURCE%"
+
+          rem Check local .metanorma-version file
+          if not defined VERSION (
+            set "DIR=%CD%"
+            :loop
+            if exist "%DIR%\\.metanorma-version" (
+              set /p VERSION=<"%DIR%\\.metanorma-version"
+              goto :found_version
+            )
+            for %%I in ("%DIR%\\..") do set "PARENT=%%~fI"
+            if "%PARENT%"=="%DIR%" goto :check_global
+            set "DIR=%PARENT%"
+            goto :loop
+          )
+
+          :check_global
+          if not defined VERSION (
+            if exist "%MNENV_ROOT%\\version" (
+              set /p VERSION=<"%MNENV_ROOT%\\version"
+            )
+          )
+
+          :found_version
+          if not defined SOURCE (
+            if exist "%MNENV_ROOT%\\source" (
+              set /p SOURCE=<"%MNENV_ROOT%\\source"
+            )
+          )
+
+          rem Default source
+          if not defined SOURCE set "SOURCE=gemfile"
+
+          if not defined VERSION (
+            echo mnenv: version not set or invalid 1>&2
+            echo Set a version with: mnenv global ^<version^> or mnenv local ^<version^> 1>&2
+            exit /b 1
+          )
+
+          rem Determine executable path based on source
+          rem Installed versions are in %MNENV_ROOT%\\installed\\<version>-<source>\\
+          if "%SOURCE%"=="binary" (
+            set "EXECUTABLE=%MNENV_ROOT%\\installed\\%VERSION%-%SOURCE%\\metanorma.exe"
+          ) else (
+            set "EXECUTABLE=%MNENV_ROOT%\\installed\\%VERSION%-%SOURCE%\\bin\\#{executable_name}.cmd"
+          )
+
+          if not exist "%EXECUTABLE%" (
+            echo mnenv: #{executable_name} not installed for version %VERSION% ^(source: %SOURCE%^) 1>&2
+            echo Install it with: mnenv install %VERSION% --source %SOURCE% 1>&2
+            exit /b 1
+          )
+
+          call "%EXECUTABLE%" %*
+        SHIM
+      end
+
+      def use_output(version, source)
+        lines = []
+        lines << "set METANORMA_VERSION=#{version}"
+        lines << "set METANORMA_SOURCE=#{source}" if source
+        lines << 'rem Run this in your CMD session'
+        lines.join("\n")
+      end
+
+      def config_file
+        nil # CMD doesn't have a standard config file
+      end
+
+      def windows?
+        true
+      end
+    end
+  end
+end

data/lib/mnenv/shells/factory.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'bash'
+require_relative 'power_shell'
+require_relative 'cmd'
+
+module Mnenv
+  module Shells
+    # Factory for detecting and creating shell instances
+    class ShellFactory
+      SHELLS = {
+        'bash' => BashShell,
+        'sh' => BashShell,
+        'dash' => BashShell,
+        'zsh' => BashShell,
+        'fish' => BashShell, # Fish can run bash scripts in compatibility mode
+        'powershell' => PowerShellShell,
+        'pwsh' => PowerShellShell,
+        'cmd' => CmdShell
+      }.freeze
+
+      class << self
+        # Detect the current shell from environment
+        def detect
+          shell_env = ENV['SHELL'] || ENV['COMSPEC'] || ''
+
+          if windows?
+            detect_windows_shell(shell_env)
+          else
+            detect_unix_shell(shell_env)
+          end
+        end
+
+        # Get shell by name
+        def get(shell_name)
+          shell_class = SHELLS[shell_name.downcase]
+          raise ArgumentError, "Unknown shell: #{shell_name}" unless shell_class
+
+          shell_class.new
+        end
+
+        # Get all shells for the current platform
+        def platform_shells
+          if windows?
+            [PowerShellShell.new, CmdShell.new]
+          else
+            [BashShell.new]
+          end
+        end
+
+        private
+
+        def windows?
+          RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+        end
+
+        def detect_unix_shell(shell_env)
+          # Extract shell name from path
+          shell_name = File.basename(shell_env) if shell_env
+
+          # Default to bash if we can't determine
+          shell_name ||= 'bash'
+
+          get(shell_name)
+        rescue ArgumentError
+          # Default to bash for unknown shells
+          BashShell.new
+        end
+
+        def detect_windows_shell(comspec)
+          if comspec =~ /powershell|pwsh/i
+            PowerShellShell.new
+          else
+            # Default to CMD on Windows, but also create PowerShell shim
+            CmdShell.new
+          end
+        end
+      end
+    end
+  end
+end