mnenv 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '090048897f563d0162ceda95dd4f727cda725916b40e7150d815280dc9592ef6'
-  data.tar.gz: 0fbf4dfbbff09224c9672fef91b5607289848166bb58eaeb904d6633eecfcfdf
+  metadata.gz: 9bb839d75925723bae3de1d40012914fc768b8f981d4be837247ea0b8de8bf2d
+  data.tar.gz: 1335ac68fba15671370c1c42f4d6999707915fd3ec884d33ee47759f3ba95863
 SHA512:
-  metadata.gz: 4695512492c103578d75100163c8201407473f73d53c67e1ebf684e7b6f248d29012caf1f17b504e5f1b4167de34199f07b5c04b09e6749fcc0634c7bcc53a8c
-  data.tar.gz: cea3fa81d4e70f8516d5866b5ee144ae8e734deccc09d80a3269d1deb98207f8af9468c82c89ef2e68256f9336d8e607968c9b59116d9f5644ca1c5cdf962c40
+  metadata.gz: b09af8fc57ec321e46c1b4976ff69e73f00b9443168659b7e343cb8a1f527ef64eaa0ea9dc0265fda6e4d8b678d351bca6fe1adca4b35ded707ddc1e4b895b18
+  data.tar.gz: 68a851a68c5a2feafe61cb47b0e68f98dc328d78c7e5459b31440250048c03fd19724cf2fcdf2462e46c6b00c6fdf6e33514d1c24569929d539fdaa8fe7efb69

data/lib/mnenv/commands/uninstall_command.rb

@@ -7,36 +7,105 @@ module Mnenv
   class UninstallCommand < Thor
     namespace :uninstall
 
+    class_option :source, type: :string, enum: %w[gemfile binary],
+                          desc: 'Source type to uninstall (gemfile or binary). If not specified, uninstalls all sources.'
     class_option :force, type: :boolean, aliases: '-f', default: false,
                          desc: 'Force uninstallation without confirmation'
 
     desc 'VERSION', 'Uninstall a specific Metanorma version'
+    method_option :source, type: :string, enum: %w[gemfile binary]
     method_option :force, type: :boolean, aliases: '-f', default: false
     def uninstall(version)
-      version_dir = File.expand_path("~/.mnenv/versions/#{version}")
+      source = options[:source]
+
+      if source
+        # Uninstall specific source
+        uninstall_source(version, source)
+      else
+        # Uninstall all sources for this version
+        uninstall_all_sources(version)
+      end
+
+      # Regenerate shims after uninstallation
+      ShimManager.new.regenerate_all
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def uninstall_source(version, source)
+      version_dir = Paths.version_install_dir(version, source)
 
       unless Dir.exist?(version_dir)
+        puts "Version #{version} (source: #{source}) is not installed."
+        return
+      end
+
+      confirm_and_remove(version, source, version_dir)
+    end
+
+    def uninstall_all_sources(version)
+      # Find all installed sources for this version
+      installed_sources = find_installed_sources(version)
+
+      if installed_sources.empty?
         puts "Version #{version} is not installed."
         return
       end
 
-      unless options[:force]
+      if installed_sources.length == 1
+        # Only one source, uninstall directly
+        source = installed_sources.first
+        version_dir = Paths.version_install_dir(version, source)
+        confirm_and_remove(version, source, version_dir)
+      else
+        # Multiple sources, ask which to uninstall
+        puts "Version #{version} has multiple sources installed:"
+        installed_sources.each do |src|
+          puts "  - #{src}"
+        end
+        puts ''
+
+        prompt = TTY::Prompt.new
+        choices = installed_sources.map { |s| { name: s, value: s } }
+        choices << { name: 'All sources', value: 'all' }
+
+        selected = prompt.select('Which source(s) to uninstall?', choices)
+
+        if selected == 'all'
+          installed_sources.each do |src|
+            version_dir = Paths.version_install_dir(version, src)
+            confirm_and_remove(version, src, version_dir, skip_confirm: options[:force])
+          end
+        else
+          version_dir = Paths.version_install_dir(version, selected)
+          confirm_and_remove(version, selected, version_dir)
+        end
+      end
+    end
+
+    def find_installed_sources(version)
+      sources = []
+      %w[gemfile binary].each do |source|
+        version_dir = Paths.version_install_dir(version, source)
+        sources << source if Dir.exist?(version_dir)
+      end
+      sources
+    end
+
+    def confirm_and_remove(version, source, version_dir, skip_confirm: false)
+      unless skip_confirm || options[:force]
         prompt = TTY::Prompt.new
-        unless prompt.yes?("Uninstall Metanorma #{version}? This cannot be undone.")
+        unless prompt.yes?("Uninstall Metanorma #{version} (#{source})? 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
+      puts "Uninstalled Metanorma #{version} (source: #{source})"
     end
   end
 end

data/lib/mnenv/commands/version_command.rb

@@ -3,7 +3,7 @@
 require 'tty/prompt'
 require 'json'
 require_relative '../installer'
-require_relative '../binary_repository'
+require_relative '../version_resolver'
 
 module Mnenv
   class VersionCommand < Thor
@@ -68,7 +68,7 @@ module Mnenv
         return
       end
 
-      current_version, current_source = resolve_current
+      current_version, current_source = resolver.resolve
 
       case options[:format]
       when 'json'
@@ -105,6 +105,11 @@ module Mnenv
 
     private
 
+    # Get the shared resolver instance
+    def resolver
+      @resolver ||= VersionResolver.new
+    end
+
     # List installed versions with their sources
     # Uses Paths::INSTALLED_DIR with new naming convention: <version>-<source>
     def list_installed_versions
@@ -129,7 +134,7 @@ module Mnenv
 
     def resolve_version_and_source(version, source, interactive)
       version, source = select_version_interactive if interactive || version.nil?
-      source ||= default_source
+      source ||= resolver.resolve_source
       [version, source]
     end
 
@@ -140,14 +145,12 @@ module Mnenv
       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] }
+        sources.map do |src|
+          { name: "#{version} (#{src})", value: [version, src] }
         end
       end
 
-      version, source = prompt.select('Select a version:', choices)
-
-      [version, source]
+      prompt.select('Select a version:', choices)
     end
 
     def verify_installed!(version, source)
@@ -160,54 +163,5 @@ module Mnenv
     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/installer/factory.rb

@@ -1,17 +1,46 @@
 # frozen_string_literal: true
 
+require_relative '../source_registry'
+
 module Mnenv
+  # Factory for creating installer instances based on source type
+  # Uses SourceRegistry for extensibility - new sources just need to register
   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
+    class UnknownSourceError < StandardError; end
+
+    # Create an installer for the given version and source
+    # @param version [String] The version to install
+    # @param source [String] The source type (e.g., 'gemfile', 'binary')
+    # @param target_dir [String, nil] Optional custom target directory
+    # @return [Installer] An installer instance
+    # @raise [UnknownSourceError] If source is not registered
+    def self.create(version, source:, target_dir: nil)
+      installer_class = SourceRegistry.installer(source.to_s)
+
+      unless installer_class
+        available = SourceRegistry.all_names.join(', ')
         raise Installer::InstallationError,
-              "Unknown source: #{source}. Use: gemfile or binary"
+              "Unknown source: #{source}. Available sources: #{available}"
       end
+
+      installer_class.new(version, source: source, target_dir: target_dir)
+    rescue SourceRegistry::UnknownSourceError
+      available = SourceRegistry.all_names.join(', ')
+      raise Installer::InstallationError,
+            "Unknown source: #{source}. Available sources: #{available}"
+    end
+
+    # Check if a source is supported
+    # @param source [String] The source type
+    # @return [Boolean]
+    def self.supported?(source)
+      SourceRegistry.registered?(source.to_s)
+    end
+
+    # Get list of supported sources
+    # @return [Array<String>]
+    def self.supported_sources
+      SourceRegistry.all_names
     end
   end
 end

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/sources.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'source_registry'
+require_relative 'gemfile_repository'
+require_relative 'binary_repository'
+require_relative 'models/gemfile_version'
+require_relative 'models/binary_version'
+require_relative 'installers/gemfile_installer'
+require_relative 'installers/binary_installer'
+
+module Mnenv
+  # Auto-registration of built-in sources
+  # This enables the plugin architecture - new sources just need to register themselves
+  module Sources
+    class << self
+      # Register all built-in sources
+      def setup
+        register_gemfile
+        register_binary
+      end
+
+      private
+
+      def register_gemfile
+        SourceRegistry.register(
+          name: 'gemfile',
+          repository: GemfileRepository,
+          model: GemfileVersion,
+          installer: Installers::GemfileInstaller
+        )
+      end
+
+      def register_binary
+        SourceRegistry.register(
+          name: 'binary',
+          repository: BinaryRepository,
+          model: BinaryVersion,
+          installer: Installers::BinaryInstaller
+        )
+      end
+    end
+  end
+end
+
+# Auto-setup on load
+Mnenv::Sources.setup

data/lib/mnenv/version.rb

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

data/lib/mnenv/version_resolver.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Centralized version and source resolution with clear precedence:
+  # 1. Environment variables (METANORMA_VERSION, METANORMA_SOURCE)
+  # 2. Local files (.metanorma-version, .metanorma-source) - walk up tree
+  # 3. Global files (~/.mnenv/version, ~/.mnenv/source)
+  # 4. Defaults (gemfile for source)
+  #
+  # This class is the single source of truth for version resolution.
+  # The Bash resolver (lib/mnenv/resolver) is kept for shims only.
+  class VersionResolver
+    # Resolve the current Metanorma version
+    # @return [String, nil] The resolved version or nil if not set
+    def resolve_version
+      from_env('METANORMA_VERSION') ||
+        from_local_file('.metanorma-version') ||
+        from_global_file(Paths::VERSION_FILE)
+    end
+
+    # Resolve the current Metanorma source
+    # @return [String] The resolved source (defaults to 'gemfile')
+    def resolve_source
+      from_env('METANORMA_SOURCE') ||
+        from_local_file('.metanorma-source') ||
+        from_global_file(Paths::SOURCE_FILE) ||
+        'gemfile'
+    end
+
+    # Resolve both version and source
+    # @return [Array<String, String>] Tuple of [version, source]
+    def resolve
+      [resolve_version, resolve_source]
+    end
+
+    # Check if a version is set anywhere
+    # @return [Boolean]
+    def version_set?
+      !resolve_version.nil?
+    end
+
+    # Check if a source is explicitly set (not default)
+    # @return [Boolean]
+    def source_set?
+      from_env('METANORMA_SOURCE') ||
+        from_local_file('.metanorma-source') ||
+        from_global_file(Paths::SOURCE_FILE)
+    end
+
+    # Get the source of version resolution (for debugging)
+    # @return [Symbol] :environment, :local, :global, or :none
+    def version_source
+      return :environment if from_env('METANORMA_VERSION')
+      return :local if from_local_file('.metanorma-version')
+      return :global if from_global_file(Paths::VERSION_FILE)
+
+      :none
+    end
+
+    # Get the source of source resolution (for debugging)
+    # @return [Symbol] :environment, :local, :global, or :default
+    def source_source
+      return :environment if from_env('METANORMA_SOURCE')
+      return :local if from_local_file('.metanorma-source')
+      return :global if from_global_file(Paths::SOURCE_FILE)
+
+      :default
+    end
+
+    private
+
+    # Read from environment variable
+    # @param var [String] Environment variable name
+    # @return [String, nil] Value or nil if not set/empty
+    def from_env(var)
+      value = ENV[var]
+      value&.strip&.then { |v| v unless v.empty? }
+    end
+
+    # Read from local file, walking up directory tree
+    # @param filename [String] Filename to look for
+    # @return [String, nil] File contents or nil if not found
+    def from_local_file(filename)
+      dir = Dir.pwd
+
+      loop do
+        path = File.join(dir, filename)
+        return File.read(path).strip if File.exist?(path)
+
+        parent = File.dirname(dir)
+        break if parent == dir # Reached root
+
+        dir = parent
+      end
+
+      nil
+    end
+
+    # Read from global file
+    # @param path [String] Full path to file
+    # @return [String, nil] File contents or nil if not found
+    def from_global_file(path)
+      File.read(path).strip if File.exist?(path)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/mnenv.rb

@@ -4,8 +4,11 @@ require 'lutaml/model'
 require 'thor'
 
 require_relative 'mnenv/paths'
+require_relative 'mnenv/platform_detector'
+require_relative 'mnenv/version_resolver'
 require_relative 'mnenv/models'
+require_relative 'mnenv/source_registry'
+require_relative 'mnenv/sources'
 require_relative 'mnenv/commands'
 require_relative 'mnenv/installer'
-require_relative 'mnenv/source_registry'
 require_relative 'mnenv/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mnenv
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -209,6 +209,7 @@ files:
 - lib/mnenv/models/snap_version.rb
 - lib/mnenv/models/version.rb
 - lib/mnenv/paths.rb
+- lib/mnenv/platform_detector.rb
 - lib/mnenv/repository.rb
 - lib/mnenv/resolver
 - lib/mnenv/shells/base.rb
@@ -221,7 +222,9 @@ files:
 - lib/mnenv/snap/fetcher.rb
 - lib/mnenv/snap_repository.rb
 - lib/mnenv/source_registry.rb
+- lib/mnenv/sources.rb
 - lib/mnenv/version.rb
+- lib/mnenv/version_resolver.rb
 - lib/mnenv/versions_manager.rb
 - mnenv.gemspec
 - scripts/cross-source-switching-test.sh