mnenv 0.1.0 → 0.1.1

data/lib/mnenv/shim_manager.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'shells/factory'
+
+module Mnenv
+  class ShimManager
+    RESOLVER_SCRIPT = File.expand_path('resolver', __dir__).freeze
+
+    attr_reader :shims_dir, :installed_dir
+
+    def initialize(shims_dir: nil, installed_dir: nil)
+      @shims_dir = shims_dir || Paths::SHIMS_DIR
+      @installed_dir = installed_dir || Paths::INSTALLED_DIR
+    end
+
+    def regenerate_all
+      FileUtils.mkdir_p(@shims_dir)
+      FileUtils.mkdir_p(Paths::LIB_DIR)
+
+      # Copy resolver script to mnenv lib directory (for Unix shells)
+      if File.exist?(RESOLVER_SCRIPT)
+        FileUtils.cp(RESOLVER_SCRIPT, File.join(Paths::LIB_DIR, 'resolver'))
+        File.chmod(0o755, File.join(Paths::LIB_DIR, 'resolver'))
+      end
+
+      executables = discover_executables
+
+      executables.each do |exe|
+        create_shims(exe)
+      end
+
+      remove_obsolete_shims(executables)
+    end
+
+    def create_shims(executable_name)
+      # Create shims for all platform-appropriate shells
+      Shells::ShellFactory.platform_shells.each do |shell|
+        create_shim_for_shell(executable_name, shell)
+      end
+    end
+
+    private
+
+    def create_shim_for_shell(executable_name, shell)
+      # For bash, no extension; for PowerShell, .ps1; for CMD, .bat
+      extension = shell.shim_extension
+      shim_name = executable_name + extension
+      shim_path = File.join(@shims_dir, shim_name)
+
+      File.write(shim_path, shell.shim_content(executable_name))
+      File.chmod(0o755, shim_path) unless shell.windows?
+    end
+
+    def discover_executables
+      executables = Set.new
+
+      # Scan installed directories with new naming convention: <version>-<source>
+      Dir.glob(File.join(@installed_dir, '*')).each do |version_dir|
+        next unless File.directory?(version_dir)
+
+        dir_name = File.basename(version_dir)
+        version, source = Paths.parse_version_dir(dir_name)
+        next unless version && source
+
+        case source
+        when 'gemfile'
+          # Discover binstubs from bundle install
+          bin_dir = File.join(version_dir, 'bin')
+          next unless Dir.exist?(bin_dir)
+
+          Dir.glob(File.join(bin_dir, '*')).each do |bin_path|
+            next if File.directory?(bin_path)
+
+            basename = File.basename(bin_path)
+
+            # On Windows, bundler creates both 'command' and 'command.cmd'
+            # Skip .cmd and .bat files - we'll create shims from the base name
+            next if windows? && (basename.end_with?('.cmd') || basename.end_with?('.bat'))
+
+            executables << basename if windows? || File.executable?(bin_path)
+          end
+
+        when 'binary'
+          # Binary installations have a single metanorma binary
+          binary_path = File.join(version_dir, 'metanorma')
+          exe_path = File.join(version_dir, 'metanorma.exe')
+
+          if File.exist?(binary_path) && (File.executable?(binary_path) || windows?)
+            executables << 'metanorma'
+          elsif File.exist?(exe_path)
+            executables << 'metanorma'
+          end
+        end
+      end
+
+      executables.to_a.sort
+    end
+
+    def remove_obsolete_shims(valid_executables)
+      # Build list of valid shim names (with extensions)
+      valid_shim_names = Set.new
+      Shells::ShellFactory.platform_shells.each do |shell|
+        valid_executables.each do |exe|
+          valid_shim_names << exe + shell.shim_extension
+        end
+      end
+
+      Dir.glob(File.join(@shims_dir, '*')).each do |shim_path|
+        next if File.directory?(shim_path)
+
+        shim_name = File.basename(shim_path)
+        File.delete(shim_path) unless valid_shim_names.include?(shim_name)
+      end
+    end
+
+    def windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+    end
+  end
+end

data/lib/mnenv/snap.rb

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

data/lib/mnenv/snap_repository.rb

@@ -8,16 +8,10 @@ module Mnenv
     def version_class = SnapVersion
     def source_name = :snap
 
-    # Override save and save_all to use composite key for Snap
+    # Override cache_version to use composite key for Snap
     # Since same version can have multiple revisions/arch/channels
-    def save(version)
+    def cache_version(version)
       @versions_cache[snap_key(version)] = version
-      persist
-    end
-
-    def save_all(versions)
-      versions.each { |v| @versions_cache[snap_key(v)] = v }
-      persist
     end
 
     # Override find to work with composite keys
@@ -55,16 +49,5 @@ module Mnenv
         raise ArgumentError, 'snap_key requires 1 or 4 arguments'
       end
     end
-
-    # Override load to handle snap composite keys
-    def load
-      data = YAML.load_file(versions_file_path)
-      return if data.nil? || data['versions'].nil?
-
-      data['versions'].each do |version_hash|
-        version = version_class.new(version_hash)
-        @versions_cache[snap_key(version)] = version
-      end
-    end
   end
 end

data/lib/mnenv/source_registry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Registry for version sources (gemfile, binary, snap, homebrew, chocolatey)
+  # Enables plugin architecture - new sources just need to register themselves
+  class SourceRegistry
+    class DuplicateSourceError < StandardError; end
+    class UnknownSourceError < StandardError; end
+
+    # Register a new source
+    # @param name [String] the source identifier (e.g., 'gemfile', 'binary')
+    # @param repository [Class] the repository class for this source
+    # @param model [Class] the version model class for this source
+    # @param installer [Class, nil] the installer class (optional)
+    def self.register(name:, repository:, model:, installer: nil)
+      name = name.to_s
+      raise DuplicateSourceError, "Source '#{name}' is already registered" if sources.key?(name)
+
+      sources[name] = {
+        repository: repository,
+        model: model,
+        installer: installer
+      }
+    end
+
+    # Get repository class for a source
+    def self.repository(name)
+      source = sources[name.to_s]
+      raise UnknownSourceError, "Unknown source: #{name}" unless source
+
+      source[:repository]
+    end
+
+    # Get model class for a source
+    def self.model(name)
+      source = sources[name.to_s]
+      raise UnknownSourceError, "Unknown source: #{name}" unless source
+
+      source[:model]
+    end
+
+    # Get installer class for a source
+    def self.installer(name)
+      source = sources[name.to_s]
+      raise UnknownSourceError, "Unknown source: #{name}" unless source
+
+      source[:installer]
+    end
+
+    # Get all registered source names
+    def self.all_names
+      sources.keys.sort
+    end
+
+    # Check if a source is registered
+    def self.registered?(name)
+      sources.key?(name.to_s)
+    end
+
+    # Clear all registrations (useful for testing)
+    def self.clear
+      @sources = nil
+    end
+
+    def self.sources
+      @sources ||= {}
+    end
+  end
+end

data/lib/mnenv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mnenv
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/mnenv/versions_manager.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'git'
+
+module Mnenv
+  # Manages the local clone of the metanorma/versions repository
+  # Similar to how Homebrew manages its core tap
+  class VersionsManager
+    VERSIONS_REPO = 'https://github.com/metanorma/versions.git'
+    DEFAULT_MNENV_DIR = File.expand_path('~/.mnenv')
+    VERSIONS_DIR = 'versions'
+
+    attr_reader :mnenv_dir, :versions_path
+
+    def initialize(mnenv_dir: nil)
+      @mnenv_dir = mnenv_dir || DEFAULT_MNENV_DIR
+      @versions_path = File.join(@mnenv_dir, VERSIONS_DIR)
+    end
+
+    # Ensure versions repository is cloned and up to date
+    # @param update [Boolean] Force update (git fetch) even if already cloned
+    # @return [String] Path to the versions data directory
+    def ensure_versions_data(update: false)
+      if cloned?
+        update_clone if update || stale?
+      else
+        clone_repo
+      end
+
+      data_path
+    end
+
+    # Check if versions repository is cloned
+    def cloned?
+      File.directory?(File.join(versions_path, '.git'))
+    end
+
+    # Check if the clone is stale (older than 24 hours)
+    def stale?
+      return true unless cloned?
+
+      last_update_file = File.join(versions_path, '.mnenv_last_update')
+      return true unless File.exist?(last_update_file)
+
+      last_update = File.mtime(last_update_file)
+      Time.now - last_update > 86_400 # 24 hours
+    end
+
+    # Path to the data directory within the versions repository
+    def data_path
+      File.join(versions_path, 'data')
+    end
+
+    # Clone the versions repository using the git gem
+    def clone_repo
+      FileUtils.mkdir_p(mnenv_dir)
+      Git.clone(VERSIONS_REPO, VERSIONS_DIR, path: mnenv_dir, depth: 1)
+      touch_update_marker
+    rescue Git::GitExecuteError => e
+      raise "Failed to clone versions repository: #{e.message}"
+    end
+
+    # Update the versions repository using the git gem
+    def update_clone
+      return unless cloned?
+
+      g = Git.open(versions_path)
+      g.fetch
+      g.reset_hard('origin/main')
+      touch_update_marker
+    rescue Git::GitExecuteError => e
+      warn "Warning: Failed to update versions repository: #{e.message}"
+    end
+
+    # Force update the versions repository
+    def update
+      if cloned?
+        update_clone
+      else
+        clone_repo
+      end
+      data_path
+    end
+
+    private
+
+    def touch_update_marker
+      FileUtils.touch(File.join(versions_path, '.mnenv_last_update'))
+    end
+  end
+end

data/lib/mnenv.rb

@@ -3,6 +3,9 @@
 require 'lutaml/model'
 require 'thor'
 
+require_relative 'mnenv/paths'
 require_relative 'mnenv/models'
 require_relative 'mnenv/commands'
+require_relative 'mnenv/installer'
+require_relative 'mnenv/source_registry'
 require_relative 'mnenv/cli'

data/mnenv.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'Unified interface for discovering and managing Metanorma ' \
                        'versions from Gemfile (Docker), Snap, Homebrew, and Chocolatey sources. ' \
                        'Provides mnenv CLI command for querying version information.'
-  spec.homepage      = 'https://github.com/metanorma/versions'
+  spec.homepage      = 'https://github.com/metanorma/mnenv'
   spec.license       = 'MIT'
 
   spec.required_ruby_version = '>= 3.1'
@@ -34,10 +34,13 @@ Gem::Specification.new do |spec|
 
   # Runtime dependencies
   spec.add_dependency 'activesupport'
+  spec.add_dependency 'git'
   spec.add_dependency 'lutaml-model', '~> 0.7'
   spec.add_dependency 'lutaml-xsd', '~> 1.0'
   spec.add_dependency 'moxml'
   spec.add_dependency 'nokogiri'
+  spec.add_dependency 'octokit'
   spec.add_dependency 'paint'
   spec.add_dependency 'thor', '~> 1.0'
+  spec.add_dependency 'tty-prompt'
 end

data/scripts/cross-source-switching-test.sh

@@ -0,0 +1,214 @@
+#!/bin/bash
+# Local cross-source switching test script for mnenv
+# Tests switching between gemfile and binary for the same version
+# Usage: ./scripts/cross-source-switching-test.sh [VERSION]
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+log_step() {
+    echo -e "${BLUE}=== $1 ===${NC}"
+}
+
+# Version to test
+VERSION="${1:-1.14.3}"
+
+# Check if we're in the mnenv directory
+if [ ! -f "mnenv.gemspec" ]; then
+    log_error "Please run this script from the mnenv root directory"
+    exit 1
+fi
+
+# Install mnenv
+log_step "Installing mnenv"
+bundle install > /dev/null 2>&1
+rake install > /dev/null 2>&1
+log_info "mnenv $(mnenv version) installed"
+
+# Add mnenv to PATH
+export PATH="$HOME/.mnenv/shims:$PATH"
+
+# Clean up any existing test state
+log_step "Cleaning up previous test state"
+rm -f ~/.mnenv/version ~/.mnenv/source
+rm -rf "/tmp/mnenv-cross-test-$VERSION"
+mkdir -p "/tmp/mnenv-cross-test-$VERSION"
+
+# Check binary availability
+log_step "Checking binary availability for version $VERSION"
+BINARY_URL="https://github.com/metanorma/packed-mn/releases/download/v${VERSION}/metanorma-$(uname -s | tr '[:upper:]' '[:lower:]')"
+BINARY_AVAILABLE=false
+
+if curl -s -f -L -o /dev/null "$BINARY_URL" 2>/dev/null; then
+    BINARY_AVAILABLE=true
+    log_info "Binary is available for $VERSION"
+else
+    log_warn "Binary NOT available for $VERSION"
+    log_info "Will test gemfile installation only"
+fi
+
+# Install with gemfile
+log_step "Installing Metanorma $VERSION (gemfile)"
+if mnenv install "$VERSION" --source gemfile > /dev/null 2>&1; then
+    log_info "✓ Gemfile installation successful"
+else
+    log_warn "⚠ Gemfile installation may have failed (may already be installed)"
+fi
+
+# Install with binary
+if [ "$BINARY_AVAILABLE" = true ]; then
+    log_step "Installing Metanorma $VERSION (binary)"
+    if mnenv install "$VERSION" --source binary > /dev/null 2>&1; then
+        log_info "✓ Binary installation successful"
+    else
+        log_warn "⚠ Binary installation may have failed (may already be installed)"
+    fi
+
+    # Show both installations
+    log_step "Installation structure"
+    echo "Gemfile installation:"
+    ls -lah ~/.mnenv/versions/"$VERSION"/gemfile/ 2>/dev/null || echo "  Not found"
+
+    echo ""
+    echo "Binary installation:"
+    ls -lah ~/.mnenv/versions/"$VERSION"/binary/ 2>/dev/null || echo "  Not found"
+fi
+
+# Show installed versions
+log_step "Installed versions"
+mnenv versions
+
+if [ "$BINARY_AVAILABLE" = false ]; then
+    echo ""
+    log_warn "Binary not available - skipping cross-source tests"
+    log_info "Binary tests require packed-mn releases"
+    exit 0
+fi
+
+# Test 1: Switch from gemfile to binary
+log_step "Test 1: Switch from gemfile to binary"
+mnenv global "$VERSION" --source gemfile
+v_gemfile=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+log_info "Gemfile source: metanorma --version = $v_gemfile"
+
+mnenv global "$VERSION" --source binary
+v_binary=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+log_info "Binary source: metanorma --version = $v_binary"
+
+if [ "$v_gemfile" = "$VERSION" ] && [ "$v_binary" = "$VERSION" ]; then
+    log_info "✓ Both sources produce correct version $VERSION"
+else
+    log_error "✗ Version mismatch: gemfile=$v_gemfile, binary=$v_binary"
+    exit 1
+fi
+
+# Test 2: Switch from binary to gemfile
+log_step "Test 2: Switch from binary to gemfile"
+mnenv global "$VERSION" --source binary
+v1=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+mnenv global "$VERSION" --source gemfile
+v2=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+if [ "$v1" = "$VERSION" ] && [ "$v2" = "$VERSION" ]; then
+    log_info "✓ Bidirectional switching works"
+else
+    log_error "✗ Version mismatch: binary=$v1, gemfile=$v2"
+    exit 1
+fi
+
+# Test 3: Rapid switching
+log_step "Test 3: Rapid source switching (5 rounds)"
+for i in {1..5}; do
+    mnenv global "$VERSION" --source gemfile > /dev/null
+    v_g=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+    mnenv global "$VERSION" --source binary > /dev/null
+    v_b=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+    if [ "$v_g" != "$VERSION" ] || [ "$v_b" != "$VERSION" ]; then
+        log_error "✗ Round $i failed: gemfile=$v_g, binary=$v_b"
+        exit 1
+    fi
+done
+log_info "✓ Rapid switching test passed"
+
+# Test 4: Local override with different source
+log_step "Test 4: Local override with source change"
+cd "/tmp/mnenv-cross-test-$VERSION"
+
+# Set global to gemfile
+mnenv global "$VERSION" --source gemfile > /dev/null
+v_global=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+# Set local to binary
+mnenv local "$VERSION" --source binary > /dev/null
+v_local=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+if [ "$v_global" = "$VERSION" ] && [ "$v_local" = "$VERSION" ]; then
+    log_info "✓ Local override works with different source"
+else
+    log_error "✗ Local override failed"
+    exit 1
+fi
+
+# Test 5: Shell override takes precedence
+log_step "Test 5: Shell session override"
+# Local is binary
+export METANORMA_VERSION="$VERSION"
+export METANORMA_SOURCE=gemfile
+v_env=$(metanorma --version 2>&1 | grep -oP '\d+\.\d+\.\d+' || echo "failed")
+
+if [ "$v_env" = "$VERSION" ]; then
+    log_info "✓ Environment variable overrides local file"
+else
+    log_error "✗ Environment override failed"
+    exit 1
+fi
+unset METANORMA_VERSION METANORMA_SOURCE
+
+# Test 6: Version list shows both sources
+log_step "Test 6: Version list shows both sources"
+if mnenv versions | grep -q "$VERSION.*gemfile"; then
+    log_info "✓ Gemfile source shown in version list"
+else
+    log_error "✗ Gemfile source not in version list"
+    exit 1
+fi
+
+if mnenv versions | grep -q "$VERSION.*binary"; then
+    log_info "✓ Binary source shown in version list"
+else
+    log_error "✗ Binary source not in version list"
+    exit 1
+fi
+
+# Final state
+log_step "All tests passed!"
+echo ""
+echo "Final state:"
+echo "  Global version: $(cat ~/.mnenv/version 2>/dev/null || echo 'not set')"
+echo "  Global source: $(cat ~/.mnenv/source 2>/dev/null || echo 'not set')"
+echo "  Current metanorma: $(metanorma --version 2>&1 | head -1)"
+
+# Clean up
+cd /
+rm -rf "/tmp/mnenv-cross-test-$VERSION"

data/scripts/integration-test.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+# Local integration test script for mnenv
+# Usage: ./scripts/integration-test.sh [gemfile|binary]
+
+set -e
+
+# Configuration
+METANORMA_VERSION="${METANORMA_VERSION:-1.14.4}"
+METHOD="${1:-gemfile}"
+SAMPLES_REPO="${SAMPLES_REPO:-metanorma/mn-samples-cc}"
+SAMPLES_DIR="/tmp/mn-samples-cc"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check if we're in the mnenv directory
+if [ ! -f "mnenv.gemspec" ]; then
+    log_error "Please run this script from the mnenv root directory"
+    exit 1
+fi
+
+# Check if mnenv is installed
+if ! command -v mnenv &> /dev/null; then
+    log_info "Installing mnenv..."
+    bundle install
+    rake install
+else
+    log_info "mnenv is already installed"
+fi
+
+# Install Metanorma
+log_info "Installing Metanorma ${METANORMA_VERSION} (method: ${METHOD})..."
+mnenv install "${METANORMA_VERSION}" --source "${METHOD}"
+mnenv global "${METANORMA_VERSION}" --source "${METHOD}"
+
+# Show installed versions
+log_info "Installed versions:"
+mnenv versions
+
+# Clone or update samples repository
+if [ -d "$SAMPLES_DIR" ]; then
+    log_info "Updating samples repository..."
+    cd "$SAMPLES_DIR"
+    git pull
+else
+    log_info "Cloning samples repository..."
+    git clone "https://github.com/${SAMPLES_REPO}.git" "$SAMPLES_DIR"
+    cd "$SAMPLES_DIR"
+fi
+
+# Test single document compilation
+log_info "Testing single document compilation..."
+if metanorma compile sources/cc-18011.adoc; then
+    log_info "Document compilation successful"
+    ls -lah sources/cc-18011.* 2>/dev/null || true
+else
+    log_error "Document compilation failed"
+    exit 1
+fi
+
+# Test site generation
+log_info "Testing site generation..."
+if metanorma site generate --agree-to-terms; then
+    log_info "Site generation successful"
+    if [ -d "site" ]; then
+        log_info "Site contents:"
+        ls -lah site/ | head -20
+    fi
+else
+    log_error "Site generation failed"
+    exit 1
+fi
+
+log_info "All tests passed!"