mnenv 0.1.0 → 0.1.1

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

data/lib/mnenv/shells/power_shell.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Mnenv
+  module Shells
+    # PowerShell shell implementation (Windows)
+    class PowerShellShell < BaseShell
+      def name
+        'powershell'
+      end
+
+      def shim_extension
+        '.ps1'
+      end
+
+      def shim_content(executable_name)
+        <<~SHIM
+          # mnenv shim for PowerShell
+          $ErrorActionPreference = "Stop"
+
+          $MNENV_ROOT = if ($env:MNENV_ROOT) { $env:MNENV_ROOT } else { "$env:USERPROFILE\\.mnenv" }
+
+          # Resolve version and source using mnenv resolver
+          $versionFile = "$MNENV_ROOT\\version"
+          $sourceFile = "$MNENV_ROOT\\source"
+
+          # Check environment variables first
+          $VERSION = $env:METANORMA_VERSION
+          $SOURCE = $env:METANORMA_SOURCE
+
+          # Check local .metanorma-version file
+          if (-not $VERSION) {
+            $dir = (Get-Location).Path
+            $root = [System.IO.Path]::GetPathRoot($dir)
+            while ($dir -and $dir -ne $root) {
+              $localVersionFile = Join-Path $dir ".metanorma-version"
+              if (Test-Path $localVersionFile) {
+                $VERSION = Get-Content $localVersionFile -Raw
+                $VERSION = $VERSION.Trim()
+                break
+              }
+              $localSourceFile = Join-Path $dir ".metanorma-source"
+              if (-not $SOURCE -and (Test-Path $localSourceFile)) {
+                $SOURCE = Get-Content $localSourceFile -Raw
+                $SOURCE = $SOURCE.Trim()
+              }
+              $dir = Split-Path $dir -Parent
+            }
+          }
+
+          # Check global version file
+          if (-not $VERSION -and (Test-Path $versionFile)) {
+            $VERSION = Get-Content $versionFile -Raw
+            $VERSION = $VERSION.Trim()
+          }
+
+          if (-not $SOURCE -and (Test-Path $sourceFile)) {
+            $SOURCE = Get-Content $sourceFile -Raw
+            $SOURCE = $SOURCE.Trim()
+          }
+
+          # Default source
+          if (-not $SOURCE) {
+            $SOURCE = "gemfile"
+          }
+
+          if (-not $VERSION) {
+            Write-Error "mnenv: version not set or invalid"
+            Write-Error "Set a version with: mnenv global <version> or mnenv local <version>"
+            exit 1
+          }
+
+          # Determine executable path based on source
+          # Installed versions are in $MNENV_ROOT\\installed\\<version>-<source>\\
+          if ($SOURCE -eq "binary") {
+            $EXECUTABLE = "$MNENV_ROOT\\installed\\$VERSION-$SOURCE\\metanorma.exe"
+          } else {
+            # Bundler creates .cmd files on Windows, not .bat
+            $EXECUTABLE = "$MNENV_ROOT\\installed\\$VERSION-$SOURCE\\bin\\#{executable_name}.cmd"
+          }
+
+          if (-not (Test-Path $EXECUTABLE)) {
+            Write-Error "mnenv: #{executable_name} not installed for version $VERSION (source: $SOURCE)"
+            Write-Error "Install it with: mnenv install $VERSION --source $SOURCE"
+            exit 1
+          }
+
+          & $EXECUTABLE $args
+        SHIM
+      end
+
+      def use_output(version, source)
+        lines = []
+        lines << "$env:METANORMA_VERSION = '#{version}'"
+        lines << "$env:METANORMA_SOURCE = '#{source}'" if source
+        lines << '# Run this in your PowerShell session'
+        lines.join("\n")
+      end
+
+      def config_file
+        File.expand_path('~\Documents\PowerShell\Microsoft.PowerShell_profile.ps1')
+      end
+
+      def windows?
+        true
+      end
+    end
+  end
+end