mnenv 0.1.0 → 0.1.1

data/lib/mnenv/commands/snap_command.rb

@@ -4,12 +4,14 @@ require 'thor'
 require 'json'
 
 module Mnenv
+  autoload :SnapRepository, 'mnenv/snap_repository'
+  autoload :JsonFormatter, 'mnenv/json_formatter'
+  autoload :Snap, 'mnenv/snap'
+
   class SnapCommand < Thor
     desc 'list', 'List all Snap versions'
     method_option :format, type: :string, aliases: '-f', default: 'text'
     def list
-      require_relative '../snap_repository'
-      require_relative '../json_formatter'
       repo = SnapRepository.new
       versions = repo.all
 
@@ -25,8 +27,6 @@ module Mnenv
 
     desc 'refresh', 'Fetch and add new Snap versions (incremental)'
     def refresh
-      require_relative '../snap/fetcher'
-      require_relative '../snap_repository'
       fetcher = Snap::Fetcher.new
       repo = fetcher.repository
 
@@ -50,7 +50,6 @@ module Mnenv
 
     desc 'revamp', 'Re-fetch all Snap versions'
     def revamp
-      require_relative '../snap/fetcher'
       fetcher = Snap::Fetcher.new
       versions = fetcher.fetch_and_save
       puts "Revamped #{versions.size} Snap versions"
@@ -58,14 +57,13 @@ module Mnenv
 
     desc 'update VERSION', 'Update a specific Snap version (all arch/channel combinations)'
     def update(version)
-      require_relative '../snap/fetcher'
       fetcher = Snap::Fetcher.new
       versions = fetcher.fetch_all
       targets = versions.select { |v| v.version == version }
 
       if targets.empty?
         puts "Snap version #{version} not found in current channel-map"
-        puts "Note: Historical versions no longer in Snap API cannot be updated"
+        puts 'Note: Historical versions no longer in Snap API cannot be updated'
         exit 1
       end
 

data/lib/mnenv/commands/uninstall_command.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'tty/prompt'
+require_relative '../installer'
+
+module Mnenv
+  class UninstallCommand < Thor
+    namespace :uninstall
+
+    class_option :force, type: :boolean, aliases: '-f', default: false,
+                         desc: 'Force uninstallation without confirmation'
+
+    desc 'VERSION', 'Uninstall a specific Metanorma version'
+    method_option :force, type: :boolean, aliases: '-f', default: false
+    def uninstall(version)
+      version_dir = File.expand_path("~/.mnenv/versions/#{version}")
+
+      unless Dir.exist?(version_dir)
+        puts "Version #{version} is not installed."
+        return
+      end
+
+      unless options[:force]
+        prompt = TTY::Prompt.new
+        unless prompt.yes?("Uninstall Metanorma #{version}? This cannot be undone.")
+          puts 'Uninstallation cancelled.'
+          return
+        end
+      end
+
+      FileUtils.rm_rf(version_dir)
+
+      # Regenerate shims
+      ShimManager.new.regenerate_all
+
+      puts "Uninstalled Metanorma #{version}"
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+  end
+end

data/lib/mnenv/commands/version_command.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'tty/prompt'
+require 'json'
+require_relative '../installer'
+require_relative '../binary_repository'
+
+module Mnenv
+  class VersionCommand < Thor
+    namespace :version
+
+    class_option :source, type: :string, enum: %w[gemfile binary],
+                          desc: 'Source type (gemfile or binary)'
+    class_option :interactive, type: :boolean, aliases: '-i', default: false,
+                               desc: 'Interactive mode for version selection'
+
+    desc 'use VERSION', 'Set Metanorma version for current shell session'
+    method_option :source, type: :string, enum: %w[gemfile binary]
+    method_option :interactive, type: :boolean, aliases: '-i', default: false
+    def use(version = nil)
+      version, source = resolve_version_and_source(version, options[:source], options[:interactive])
+
+      puts "export METANORMA_VERSION=#{version}"
+      puts "export METANORMA_SOURCE=#{source}" if source
+      puts "# Run this in your shell, or use: eval \"$(mnenv use #{version}#{" --source #{source}" if source})\""
+    end
+
+    desc 'global VERSION', 'Set default Metanorma version globally'
+    method_option :source, type: :string, enum: %w[gemfile binary]
+    method_option :interactive, type: :boolean, aliases: '-i', default: false
+    def global(version = nil)
+      version, source = resolve_version_and_source(version, options[:source], options[:interactive])
+      verify_installed!(version, source)
+
+      File.write(Paths::VERSION_FILE, version)
+      File.write(Paths::SOURCE_FILE, source) if source
+      puts "Global Metanorma version set to #{version}#{source ? " (source: #{source})" : ''}"
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc 'local VERSION', 'Set Metanorma version for current directory'
+    method_option :source, type: :string, enum: %w[gemfile binary]
+    method_option :interactive, type: :boolean, aliases: '-i', default: false
+    def local(version = nil)
+      version, source = resolve_version_and_source(version, options[:source], options[:interactive])
+      verify_installed!(version, source)
+
+      File.write('.metanorma-version', version)
+      File.write('.metanorma-source', source) if source
+      puts "Local Metanorma version set to #{version}#{source ? " (source: #{source})" : ''}"
+      puts "Created .metanorma-version#{source ? ' and .metanorma-source' : ''}"
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc 'versions', 'List all installed Metanorma versions'
+    method_option :format, type: :string, aliases: '-f', default: 'text',
+                           desc: 'Output format (text or json)'
+    def versions
+      installed = list_installed_versions
+
+      if installed.empty?
+        puts 'No versions installed.'
+        puts "\nRun: mnenv install --list"
+        return
+      end
+
+      current_version, current_source = resolve_current
+
+      case options[:format]
+      when 'json'
+        output = {
+          'current_version' => current_version,
+          'current_source' => current_source,
+          'installed' => installed.map do |version, sources|
+            sources.map do |source|
+              {
+                'version' => version,
+                'source' => source,
+                'current' => version == current_version && source == current_source
+              }
+            end
+          end.flatten
+        }
+        puts JSON.pretty_generate(output)
+      else
+        puts 'Installed Metanorma versions:'
+
+        installed.sort.reverse.each do |version, sources|
+          sources.sort.each do |source|
+            is_current = version == current_version && source == current_source
+            marker = is_current ? '* ' : '  '
+            puts "  #{marker}#{version} (source: #{source})"
+          end
+        end
+
+        puts "\nCurrent version: #{current_version || 'none'}"
+        puts "Current source: #{current_source || 'none'}"
+        puts "\nTo see available versions, run: mnenv install --list"
+      end
+    end
+
+    private
+
+    # List installed versions with their sources
+    # Uses Paths::INSTALLED_DIR with new naming convention: <version>-<source>
+    def list_installed_versions
+      return {} unless Dir.exist?(Paths::INSTALLED_DIR)
+
+      versions = Hash.new { |h, k| h[k] = [] }
+
+      Dir.glob(File.join(Paths::INSTALLED_DIR, '*')).each do |dir|
+        next unless File.directory?(dir)
+
+        dir_name = File.basename(dir)
+        version, source = Paths.parse_version_dir(dir_name)
+
+        # Only include valid version-source directories
+        next unless version && source
+
+        versions[version] << source
+      end
+
+      versions
+    end
+
+    def resolve_version_and_source(version, source, interactive)
+      version, source = select_version_interactive if interactive || version.nil?
+      source ||= default_source
+      [version, source]
+    end
+
+    def select_version_interactive
+      prompt = TTY::Prompt.new
+      installed = list_installed_versions
+
+      raise 'No versions installed. Run: mnenv install --list' if installed.empty?
+
+      choices = installed.flat_map do |version, sources|
+        sources.map do |source|
+          { name: "#{version} (#{source})", value: [version, source] }
+        end
+      end
+
+      version, source = prompt.select('Select a version:', choices)
+
+      [version, source]
+    end
+
+    def verify_installed!(version, source)
+      version_dir = Paths.version_install_dir(version, source)
+      return if Dir.exist?(version_dir)
+
+      raise "Version #{version} (source: #{source}) is not installed. Run: mnenv install #{version} --source #{source}"
+    end
+
+    def installed_versions
+      list_installed_versions.keys.sort
+    end
+
+    def default_source
+      if File.exist?(Paths::SOURCE_FILE)
+        File.read(Paths::SOURCE_FILE).strip
+      else
+        'gemfile'
+      end
+    end
+
+    def resolve_version
+      return ENV['METANORMA_VERSION'] if ENV['METANORMA_VERSION']
+
+      dir = Dir.pwd
+      loop do
+        return File.read(File.join(dir, '.metanorma-version')).strip if File.exist?(File.join(dir,
+                                                                                              '.metanorma-version'))
+
+        parent = File.dirname(dir)
+        break if parent == dir # Reached root
+
+        dir = parent
+      end
+
+      return File.read(Paths::VERSION_FILE).strip if File.exist?(Paths::VERSION_FILE)
+
+      nil
+    end
+
+    def resolve_source
+      return ENV['METANORMA_SOURCE'] if ENV['METANORMA_SOURCE']
+
+      dir = Dir.pwd
+      loop do
+        return File.read(File.join(dir, '.metanorma-source')).strip if File.exist?(File.join(dir, '.metanorma-source'))
+
+        parent = File.dirname(dir)
+        break if parent == dir # Reached root
+
+        dir = parent
+      end
+
+      return File.read(Paths::SOURCE_FILE).strip if File.exist?(Paths::SOURCE_FILE)
+
+      'gemfile'
+    end
+
+    def resolve_current
+      [resolve_version, resolve_source]
+    end
+  end
+end

data/lib/mnenv/commands.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'commands/gemfile_command'
-require_relative 'commands/snap_command'
-require_relative 'commands/homebrew_command'
-require_relative 'commands/chocolatey_command'
+module Mnenv
+  autoload :GemfileCommand, 'mnenv/commands/gemfile_command'
+  autoload :SnapCommand, 'mnenv/commands/snap_command'
+  autoload :HomebrewCommand, 'mnenv/commands/homebrew_command'
+  autoload :ChocolateyCommand, 'mnenv/commands/chocolatey_command'
+  autoload :InstallCommand, 'mnenv/commands/install_command'
+  autoload :VersionCommand, 'mnenv/commands/version_command'
+  autoload :UninstallCommand, 'mnenv/commands/uninstall_command'
+end

data/lib/mnenv/gemfile/extractor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'English'
 require_relative '../logger'
 require_relative '../gemfile_repository'
 require_relative './fetcher'
@@ -36,7 +37,7 @@ module Mnenv
 
       def extract_incremental
         remote_versions = fetcher.fetch_all
-        existing_versions = repository.all.select { |v| v.exists_locally? }.map(&:version)
+        existing_versions = repository.all.select(&:exists_locally?).map(&:version)
 
         missing = remote_versions.reject { |v| existing_versions.include?(v.version) }
 
@@ -74,12 +75,18 @@ module Mnenv
 
         cleanup_docker_image(version.version)
 
+        # Update version metadata after successful extraction
+        version.gemfile_exists = true
+        # Store relative paths (relative to data/gemfile directory)
+        version.gemfile_path = "v#{version.version}/Gemfile"
+        version.gemfile_lock_path = "v#{version.version}/Gemfile.lock.archived"
+
         repository.save(version)
       end
 
       def pull_docker_image(version_number)
         system('docker', 'pull', "#{Fetcher::DOCKER_IMAGE}:#{version_number}", out: File::NULL)
-        raise 'Failed to pull Docker image' unless $?.success?
+        raise 'Failed to pull Docker image' unless $CHILD_STATUS.success?
       end
 
       def extract_gemfiles(version)
@@ -89,7 +96,7 @@ module Mnenv
         cmd = "docker run --rm --entrypoint sh #{Fetcher::DOCKER_IMAGE}:#{version.version} -c '#{script}'"
         output = `#{cmd}`
 
-        raise "Extraction failed for #{version.version}" unless $?.success?
+        raise "Extraction failed for #{version.version}" unless $CHILD_STATUS.success?
 
         gemfile, gemfile_lock = parse_gemfile_output(output)
 

data/lib/mnenv/gemfile.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Gemfile
+    autoload :Extractor, 'mnenv/gemfile/extractor'
+    autoload :Fetcher, 'mnenv/gemfile/fetcher'
+  end
+end

data/lib/mnenv/gemfile_repository.rb

@@ -7,7 +7,5 @@ module Mnenv
   class GemfileRepository < Repository
     def version_class = GemfileVersion
     def source_name = :gemfile
-
-    def default_data_dir = File.join(__dir__, '..', '..', 'data', 'gemfile')
   end
 end

data/lib/mnenv/homebrew.rb

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

data/lib/mnenv/installer/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Mnenv
+  class Installer
+    class InstallationError < StandardError; end
+    class DevelopmentToolsMissing < InstallationError; end
+
+    attr_reader :version, :source
+
+    def initialize(version, source: nil, target_dir: nil)
+      @version = version
+      @source = source || default_source
+      @target_dir = target_dir || default_target_dir
+    end
+
+    def install
+      verify_prerequisites!
+      create_install_directory
+      perform_installation
+      regenerate_shims
+    end
+
+    def installed?
+      Dir.exist?(version_dir)
+    end
+
+    private
+
+    def default_target_dir
+      @default_target_dir ||= Paths.version_install_dir(version, source)
+    end
+
+    def version_dir
+      @target_dir
+    end
+
+    def verify_prerequisites!
+      raise NotImplementedError, "#{self.class} must implement verify_prerequisites!"
+    end
+
+    def perform_installation
+      raise NotImplementedError, "#{self.class} must implement perform_installation!"
+    end
+
+    def create_install_directory
+      FileUtils.mkdir_p(version_dir)
+    end
+
+    def regenerate_shims
+      ShimManager.new.regenerate_all
+    end
+
+    def default_source
+      # Try to read from ~/.mnenv/source, else default to gemfile
+      if File.exist?(Paths::SOURCE_FILE)
+        File.read(Paths::SOURCE_FILE).strip
+      else
+        'gemfile' # Default: faster for devs
+      end
+    end
+  end
+end

data/lib/mnenv/installer/factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mnenv
+  class InstallerFactory
+    def self.create(version, source:)
+      case source.to_s
+      when 'gemfile'
+        Installers::GemfileInstaller.new(version, source: source)
+      when 'binary'
+        Installers::BinaryInstaller.new(version, source: source)
+      else
+        raise Installer::InstallationError,
+              "Unknown source: #{source}. Use: gemfile or binary"
+      end
+    end
+  end
+end

data/lib/mnenv/installer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Mnenv
+  autoload :Installer, 'mnenv/installer/base'
+  autoload :InstallerFactory, 'mnenv/installer/factory'
+  autoload :ShimManager, 'mnenv/shim_manager'
+
+  module Installers
+    autoload :GemfileInstaller, 'mnenv/installers/gemfile_installer'
+    autoload :BinaryInstaller, 'mnenv/installers/binary_installer'
+  end
+end