mnenv 0.1.0 → 0.1.1

data/Rakefile

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
 
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  # rspec not available, skip spec task
+end

data/bin/Install-Mnenv.ps1

@@ -0,0 +1,145 @@
+# One-line installer for mnenv (Windows)
+# Install: Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/metanorma/mnenv/main/bin/Install-Mnenv.ps1'))
+
+# Copyright 2024 Metanorma mnenv project
+# Licensed under Apache License 2.0
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $false)]
+    [string]$MnenvRoot = $env:MNENV_ROOT,
+
+    [Parameter(Mandatory = $false)]
+    [string]$RepoUrl = "https://github.com/metanorma/mnenv"
+)
+
+$ErrorActionPreference = "Stop"
+
+# Set TLS 1.2 (required for GitHub)
+try {
+    Write-Host "Forcing web requests to allow TLS v1.2 (Required for GitHub)"
+    [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+}
+catch {
+    Write-Warning "Unable to set TLS 1.2. Installation may fail on older systems."
+}
+
+function Get-Downloader {
+    param(
+        [string]$Url,
+        [string]$ProxyUrl
+    )
+
+    $downloader = New-Object System.Net.WebClient
+    $defaultCreds = [System.Net.CredentialCache]::DefaultCredentials
+    if ($defaultCreds) {
+        $downloader.Credentials = $defaultCreds
+    }
+
+    if ($ProxyUrl) {
+        Write-Host "Using proxy server: $ProxyUrl"
+        $proxy = New-Object System.Net.WebProxy -ArgumentList $ProxyUrl, $true
+        $proxy.Credentials = $defaultCreds
+        if (-not $proxy.IsBypassed($Url)) {
+            $downloader.Proxy = $proxy
+        }
+    }
+
+    $downloader
+}
+
+function Test-MnenvInstalled {
+    $checkPath = if ($MnenvRoot) { $MnenvRoot } else { Join-Path $env:USERPROFILE ".mnenv" }
+
+    if (Test-Path $checkPath) {
+        $files = Get-ChildItem $checkPath -ErrorAction SilentlyContinue
+        if ($files) {
+            Write-Warning "Files from a previous mnenv installation were found at '$checkPath'."
+            Write-Host "To reinstall, remove the directory and run this script again."
+            return $true
+        }
+    }
+    $false
+}
+
+function Main {
+    $actualMnenvRoot = if ($MnenvRoot) { $MnenvRoot } else { Join-Path $env:USERPROFILE ".mnenv" }
+
+    Write-Host "==> Installing mnenv to $actualMnenvRoot"
+
+    # Check for existing installation
+    if (Test-MnenvInstalled) {
+        Write-Host "Existing installation detected. Aborting."
+        Write-Host "To reinstall, first remove: $actualMnenvRoot"
+        return
+    }
+
+    # Clone or update repository
+    if (Test-Path $actualMnenvRoot) {
+        Write-Host "==> Updating existing installation"
+        Set-Location $actualMnenvRoot
+        & git pull
+    }
+    else {
+        Write-Host "==> Cloning repository from $RepoUrl"
+        & git clone $RepoUrl $actualMnenvRoot
+    }
+
+    # Create directory structure
+    $versionsDir = Join-Path $actualMnenvRoot "versions"
+    $shimsDir = Join-Path $actualMnenvRoot "shims"
+    $cacheDir = Join-Path $actualMnenvRoot "cache"
+    $completionsDir = Join-Path $actualMnenvRoot "completions"
+
+    @($versionsDir, $shimsDir, $cacheDir, $completionsDir) | ForEach-Object {
+        if (-not (Test-Path $_)) {
+            New-Item -ItemType Directory -Path $_ -Force | Out-Null
+        }
+    }
+
+    # Setup PowerShell profile
+    Setup-PowerShell $actualMnenvRoot
+
+    Write-Host "==> Installation complete!"
+    Write-Host "==> Reload your shell: . `$PROFILE"
+    Write-Host "==> Then run: mnenv install --list"
+}
+
+function Setup-PowerShell {
+    param([string]$RootPath)
+
+    $profilePath = $PROFILE.CurrentUserCurrentHost
+    $shimsPath = Join-Path $RootPath "shims"
+    $completionsPath = Join-Path $RootPath "completions\powershell.ps1"
+    $initLine = "`$env:PATH = `"$shimsPath;`$env:PATH`""
+    $completionLine = ". `"$completionsPath`""
+
+    # Ensure profile exists
+    if (-not (Test-Path $profilePath)) {
+        New-Item -ItemType File -Path $profilePath -Force | Out-Null
+    }
+
+    $profileContent = Get-Content $profilePath -Raw
+
+    # Add shims to PATH if not already present
+    if ($profileContent -notlike "*$shimsPath*") {
+        Add-Content $profilePath "`n# Mnenv"
+        Add-Content $profilePath $initLine
+        Write-Host "==> Added mnenv shims to PATH in $profilePath"
+    }
+
+    # Add completion if not already present
+    if ($profileContent -notlike "*$completionsPath*") {
+        Add-Content $profilePath $completionLine
+        Write-Host "==> Added mnenv completion to $profilePath"
+    }
+}
+
+try {
+    Main
+}
+catch {
+    Write-Error "Installation failed: $_"
+    Write-Host "For help, visit: https://github.com/metanorma/mnenv"
+    exit 1
+}

data/bin/mnenv-installer

@@ -0,0 +1,72 @@
+#!/bin/bash
+# One-line installer for mnenv (Unix/macOS)
+# Install: curl -fsSL https://raw.githubusercontent.com/metanorma/mnenv/main/bin/mnenv-installer | bash
+
+set -e
+
+MNENV_ROOT="${MNENV_ROOT:-$HOME/.mnenv}"
+REPO_URL="https://github.com/metanorma/mnenv"
+
+main() {
+    echo "==> Installing mnenv to $MNENV_ROOT"
+
+    # Clone or update repository
+    if [ -d "$MNENV_ROOT" ]; then
+        echo "==> Updating existing installation"
+        cd "$MNENV_ROOT"
+        git pull
+    else
+        echo "==> Cloning repository"
+        git clone "$REPO_URL" "$MNENV_ROOT"
+    fi
+
+    # Setup shell integration
+    setup_shell
+
+    # Create directory structure
+    mkdir -p "$MNENV_ROOT/versions"
+    mkdir -p "$MNENV_ROOT/shims"
+    mkdir -p "$MNENV_ROOT/cache"
+
+    echo "==> Installation complete!"
+    echo "==> Reload your shell or run: source ~/.mnenv-init"
+    echo "==> Then run: mnenv install --list"
+}
+
+setup_shell() {
+    local shell_name="$(basename "$SHELL")"
+
+    case "$shell_name" in
+        bash)
+            add_to_shell_config ~/.bashrc "source \"$MNENV_ROOT/completions/bash\""
+            ;;
+        zsh)
+            add_to_shell_config ~/.zshrc "source \"$MNENV_ROOT/completions/zsh\""
+            ;;
+        fish)
+            add_to_shell_config ~/.config/fish/config.fish "source \"$MNENV_ROOT/completions/fish\""
+            ;;
+        *)
+            echo "==> Unsupported shell: $shell_name"
+            echo "==> Manually add: source $MNENV_ROOT/completions/$shell_name"
+            ;;
+    esac
+}
+
+add_to_shell_config() {
+    local config_file="$1"
+    local init_line="$2"
+
+    if [ -f "$config_file" ] && ! grep -q "$MNENV_ROOT" "$config_file" 2>/dev/null; then
+        echo "" >> "$config_file"
+        echo "# Mnenv" >> "$config_file"
+        echo "$init_line" >> "$config_file"
+        echo "==> Added mnenv to $config_file"
+    elif [ ! -f "$config_file" ]; then
+        echo "# Mnenv" >> "$config_file"
+        echo "$init_line" >> "$config_file"
+        echo "==> Created $config_file and added mnenv"
+    fi
+}
+
+main "$@"

data/completions/bash

@@ -0,0 +1,47 @@
+# Mnenv Bash completion
+
+_mnenv_install() {
+    local cur="${COMP_WORDS[COMP_CWORD]}"
+    local versions=$(/Users/mulgogi/.gem/ruby/3.3.0/bin/mnenv gemfile list 2>/dev/null | grep -E '^v[0-9]' | awk '{print $1}')
+    COMPREPLY=($(compgen -W "$versions --list --interactive" -- "$cur"))
+}
+
+_mnenv_use() {
+    local cur="${COMP_WORDS[COMP_CWORD]}"
+    local versions=$(ls -1 ~/.mnenv/versions/ 2>/dev/null)
+    COMPREPLY=($(compgen -W "$versions --interactive" -- "$cur"))
+}
+
+_mnenv_global() {
+    _mnenv_use
+}
+
+_mnenv_local() {
+    _mnenv_use
+}
+
+_mnenv_uninstall() {
+    _mnenv_use
+}
+
+_mnenv() {
+    local cur="${COMP_WORDS[COMP_CWORD]}"
+    local prev="${COMP_WORDS[COMP_CWORD-1]}"
+    local commands="install use global local versions uninstall help gemfile snap homebrew chocolatey info list list-all version"
+
+    case "$prev" in
+        install) _mnenv_install ;;
+        use) _mnenv_use ;;
+        global) _mnenv_global ;;
+        local) _mnenv_local ;;
+        uninstall) _mnenv_uninstall ;;
+        *) COMPREPLY=($(compgen -W "$commands" -- "$cur")) ;;
+    esac
+}
+
+complete -F _mnenv mnenv
+
+# Add ~/.mnenv/shims to PATH if not already present
+if [[ ":$PATH:" != *":$HOME/.mnenv/shims:"* ]]; then
+    export PATH="$HOME/.mnenv/shims:$PATH"
+fi

data/completions/fish

@@ -0,0 +1,29 @@
+# Mnenv Fish completion
+
+complete -c mnenv -f
+
+complete -c mnenv -n __fish_use_subcommand -a install -d "Install a Metanorma version"
+complete -c mnenv -n "__fish_seen_subcommand_from install" -l list -d "List all available versions"
+complete -c mnenv -n "__fish_seen_subcommand_from install" -l interactive -s i -d "Interactive selection"
+complete -c mnenv -n "__fish_seen_subcommand_from install" -a "(ls -1 ~/.mnenv/versions/)"
+
+complete -c mnenv -n __fish_use_subcommand -a use -d "Set version for current shell"
+complete -c mnenv -n "__fish_seen_subcommand_from use" -l interactive -s i -d "Interactive selection"
+complete -c mnenv -n "__fish_seen_subcommand_from use" -a "(ls -1 ~/.mnenv/versions/)"
+
+complete -c mnenv -n __fish_use_subcommand -a global -d "Set default version globally"
+complete -c mnenv -n "__fish_seen_subcommand_from global" -l interactive -s i -d "Interactive selection"
+complete -c mnenv -n "__fish_seen_subcommand_from global" -a "(ls -1 ~/.mnenv/versions/)"
+
+complete -c mnenv -n __fish_use_subcommand -a local -d "Set version for current directory"
+complete -c mnenv -n "__fish_seen_subcommand_from local" -l interactive -s i -d "Interactive selection"
+complete -c mnenv -n "__fish_seen_subcommand_from local" -a "(ls -1 ~/.mnenv/versions/)"
+
+complete -c mnenv -n __fish_use_subcommand -a versions -d "List installed versions"
+complete -c mnenv -n __fish_use_subcommand -a uninstall -d "Uninstall a version"
+complete -c mnenv -n "__fish_seen_subcommand_from uninstall" -a "(ls -1 ~/.mnenv/versions/)"
+
+# Add ~/.mnenv/shims to PATH if not already present
+if not contains -- ~/.mnenv/shims $PATH
+    set -gx PATH ~/.mnenv/shims $PATH
+end

data/completions/powershell.ps1

@@ -0,0 +1,94 @@
+# Mnenv PowerShell completion
+# Add this to your $PROFILE: . "$env:USERPROFILE\.mnenv\completions\powershell.ps1"
+
+if ($null -eq (Get-Command Register-ArgumentCompleter -ErrorAction SilentlyContinue)) {
+    # PowerShell 5.0 or earlier - use old-style completion
+    function mnenvCompletion {
+        param($commandName, $wordToComplete, $cursorPosition)
+
+        $commands = @('install', 'use', 'global', 'local', 'versions', 'uninstall', 'help',
+                     'gemfile', 'snap', 'homebrew', 'chocolatey', 'info', 'list', 'list-all', 'version')
+
+        # Get installed versions
+        $versionsDir = Join-Path $env:USERPROFILE ".mnenv\versions"
+        if (Test-Path $versionsDir) {
+            $versions = Get-ChildItem $versionsDir -Directory | Select-Object -ExpandProperty Name
+        } else {
+            $versions = @()
+        }
+
+        # Command completion
+        $commandLine = $wordToComplete
+        $commandParts = $commandLine -split '\s+'
+        $commandCount = $commandParts.Count
+
+        if ($commandCount -eq 1 -or $commandLine.Trim().EndsWith(' ')) {
+            # Completing command
+            $commands | Where-Object { $_ -like "$wordToComplete*" }
+        }
+        # Subcommand completion
+        elseif ($commandCount -eq 2) {
+            $subcommand = $commandParts[1]
+
+            switch ($subcommand) {
+                { $_ -in @('install', 'use', 'global', 'local', 'uninstall') } {
+                    $versions | Where-Object { $_ -like "$wordToComplete*" }
+                }
+                default {
+                    @()
+                }
+            }
+        }
+        else {
+            @()
+        }
+    }
+
+    Register-ArgumentCompleter -CommandName 'mnenv' -ScriptBlock $function:mnenvCompletion
+}
+else {
+    # PowerShell 6+ - use modern completion
+    $script:block = {
+        param($wordToComplete, $commandAst, $cursorPosition)
+
+        $commands = @('install', 'use', 'global', 'local', 'versions', 'uninstall', 'help',
+                     'gemfile', 'snap', 'homebrew', 'chocolatey', 'info', 'list', 'list-all', 'version')
+
+        # Get installed versions
+        $versionsDir = Join-Path $env:USERPROFILE ".mnenv\versions"
+        if (Test-Path $versionsDir) {
+            $versions = Get-ChildItem $versionsDir -Directory | Select-Object -ExpandProperty Name
+        } else {
+            $versions = @()
+        }
+
+        # Command completion
+        if ($commandAst.CommandElements.Count -eq 1) {
+            $commands | Where-Object { $_ -like "$wordToComplete*" }
+        }
+        # Subcommand completion
+        elseif ($commandAst.CommandElements.Count -eq 2) {
+            $subcommand = $commandAst.CommandElements[1].Value
+
+            switch ($subcommand) {
+                { $_ -in @('install', 'use', 'global', 'local', 'uninstall') } {
+                    $versions | Where-Object { $_ -like "$wordToComplete*" }
+                }
+                default {
+                    @()
+                }
+            }
+        }
+        else {
+            @()
+        }
+    }
+
+    Register-ArgumentCompleter -CommandName 'mnenv' -ScriptBlock $script:block
+}
+
+# Add ~/.mnenv/shims to PATH if not already present
+$shimsPath = Join-Path $env:USERPROFILE ".mnenv\shims"
+if ($env:PATH -notlike "*$shimsPath*") {
+    $env:PATH = "$shimsPath;$env:PATH"
+}

data/completions/zsh

@@ -0,0 +1,43 @@
+# Mnenv Zsh completion
+
+#compdef mnenv
+
+_mnenv() {
+    local -a commands
+    commands=(
+        'install:Install a Metanorma version'
+        'use:Set Metanorma version for current shell session'
+        'global:Set default Metanorma version globally'
+        'local:Set Metanorma version for current directory'
+        'versions:List all installed Metanorma versions'
+        'uninstall:Uninstall a Metanorma version'
+        'help:Show help'
+        'gemfile:Gemfile-related commands'
+        'snap:Snap-related commands'
+        'homebrew:Homebrew-related commands'
+        'chocolatey:Chocolatey-related commands'
+        'info:Show information about a version'
+        'list:List available versions'
+        'list-all:List all available versions across sources'
+        'version:Show mnenv version'
+    )
+
+    if (( CURRENT == 2 )); then
+        _describe 'command' commands
+    else
+        case "${words[2]}" in
+            install|use|global|local|uninstall)
+                local -a versions
+                versions=($(ls -1 ~/.mnenv/versions/ 2>/dev/null))
+                _describe 'version' versions
+                ;;
+        esac
+    fi
+}
+
+_mnenv "$@"
+
+# Add ~/.mnenv/shims to PATH if not already present
+if [[ ":$PATH:" != *":$HOME/.mnenv/shims:"* ]]; then
+    export PATH="$HOME/.mnenv/shims:$PATH"
+fi

data/lib/mnenv/binary_repository.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'octokit'
+require 'yaml'
+require_relative 'models/binary_version'
+
+module Mnenv
+  # Repository for Binary (packed-mn) GitHub releases
+  # Supports both cached YAML data (from versions repo) and live API fallback
+  class BinaryRepository
+    PACKED_MN_REPO = 'metanorma/packed-mn'
+
+    attr_reader :data_dir
+
+    def initialize(data_dir: nil, update: false)
+      @data_dir = data_dir || default_data_dir
+      @update = update
+      @versions_cache = {}
+      load
+    end
+
+    # Get all available binary versions
+    def all
+      # If cache is empty and not loaded from YAML, fall back to live API
+      @versions_cache = fetch_from_api if @versions_cache.empty? && !@loaded_from_yaml
+      @versions_cache.values.sort.reverse
+    end
+
+    # Find a specific version
+    def find(version_number)
+      version_number = normalize_version(version_number)
+      all.find { |v| v.version == version_number }
+    end
+
+    # Check if a version is available for the current platform
+    def available_for_platform?(version_number)
+      version = find(version_number)
+      return false unless version
+
+      platform = detect_platform
+      binary_name = "metanorma-#{platform}"
+      version.assets.any? { |a| a == binary_name || a.include?(platform) }
+    end
+
+    # Get the latest version
+    def latest
+      all.first
+    end
+
+    # Count of available versions
+    def count
+      @versions_cache.size
+    end
+
+    private
+
+    # Create Octokit client with GitHub token if available
+    # Uses GITHUB_TOKEN (GitHub Actions) or GH_TOKEN (GitHub CLI) for higher rate limits
+    # Falls back to unauthenticated client (60 req/hour) if no token is available
+    def client
+      @client ||= begin
+        token = github_token
+        if token
+          Octokit::Client.new(access_token: token)
+        else
+          Octokit::Client.new
+        end
+      end
+    end
+
+    # Detect GitHub token from environment variables
+    # Priority: GITHUB_TOKEN (GitHub Actions), GH_TOKEN (GitHub CLI)
+    def github_token
+      ENV['GITHUB_TOKEN'] || ENV['GH_TOKEN']
+    end
+
+    def default_data_dir
+      # Check if CLI data_dir is specified
+      if defined?(Mnenv::Cli) && Mnenv::Cli.data_dir
+        File.join(Mnenv::Cli.data_dir, 'binary')
+      else
+        # Use versions manager to get data path
+        require_relative 'versions_manager'
+        data_path = Mnenv::Repository.versions_manager.ensure_versions_data(update: @update)
+        File.join(data_path, 'binary')
+      end
+    end
+
+    def load
+      versions_file = File.join(@data_dir, 'versions.yaml')
+
+      if File.exist?(versions_file)
+        @loaded_from_yaml = true
+        data = YAML.safe_load(File.read(versions_file), permitted_classes: [Time, Symbol, Date])
+        return unless data && data['versions']
+
+        data['versions'].each do |version_hash|
+          version = parse_cached_version(version_hash)
+          @versions_cache[version.version] = version if version
+        end
+      else
+        @loaded_from_yaml = false
+      end
+    rescue StandardError => e
+      warn "Warning: Failed to load binary versions from cache: #{e.message}"
+      @loaded_from_yaml = false
+    end
+
+    def parse_cached_version(hash)
+      return nil unless hash['version']
+
+      # Extract assets from platforms array (for backward compatibility)
+      assets = (hash['platforms'] || []).map { |p| p['filename'] }.compact
+
+      # Store full platforms data including URLs
+      platforms = hash['platforms'] || []
+
+      BinaryVersion.new(
+        version: hash['version'],
+        display_name: hash['version'],
+        published_at: parse_date(hash['published_at']),
+        parsed_at: parse_date(hash['parsed_at']),
+        metadata: {
+          'tag_name' => hash['tag_name'] || "v#{hash['version']}",
+          'html_url' => hash['html_url'],
+          'assets' => assets,
+          'platforms' => platforms
+        }
+      )
+    end
+
+    def fetch_from_api
+      releases = fetch_releases
+      result = {}
+      releases.each do |release|
+        version = parse_release(release)
+        result[version.version] = version if version
+      end
+      result
+    end
+
+    def fetch_releases
+      client.releases(PACKED_MN_REPO)
+    rescue Octokit::Error => e
+      warn "Warning: Failed to fetch binary releases: #{e.message}"
+      []
+    end
+
+    def parse_release(release)
+      return nil unless release.tag_name =~ /^v(\d+\.\d+\.\d+)/
+
+      version = release.tag_name.sub(/^v/, '')
+      published_at = release.published_at
+
+      BinaryVersion.new(
+        version: version,
+        display_name: version,
+        published_at: published_at,
+        parsed_at: Time.now.utc,
+        metadata: {
+          'tag_name' => release.tag_name,
+          'html_url' => release.html_url,
+          'assets' => release.assets.map(&:name)
+        }
+      )
+    end
+
+    def parse_date(date_string)
+      return nil unless date_string
+
+      Time.parse(date_string)
+    rescue ArgumentError
+      nil
+    end
+
+    def detect_platform
+      case RbConfig::CONFIG['host_os']
+      when /linux/   then 'linux'
+      when /darwin/  then 'macos'
+      when /mswin|mingw|cygwin/ then 'windows'
+      else 'unknown'
+      end
+    end
+
+    def normalize_version(version)
+      version.sub(/^v/, '')
+    end
+  end
+end

data/lib/mnenv/chocolatey.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Chocolatey
+    autoload :Fetcher, 'mnenv/chocolatey/fetcher'
+  end
+end