mnenv 0.1.0 → 0.1.1

data/lib/mnenv/installers/binary_installer.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'json'
+require 'net/http'
+require 'rubygems/package'
+require 'zlib'
+require 'tempfile'
+require_relative '../installer/base'
+require_relative '../binary_repository'
+
+module Mnenv
+  module Installers
+    class BinaryInstaller < Installer
+      PACKED_MN_REPO = 'metanorma/packed-mn'
+      RELEASES_URL = "https://api.github.com/repos/#{PACKED_MN_REPO}/releases".freeze
+
+      def verify_prerequisites!
+        verify_version_available!
+      end
+
+      def perform_installation
+        download_binary
+        make_executable
+      end
+
+      def make_executable
+        # Linux/macOS: make the binary executable
+        binary_path = File.join(version_dir, 'metanorma')
+        FileUtils.chmod(0o755, binary_path) if File.exist?(binary_path)
+
+        # Windows: .exe files don't need chmod
+        exe_path = File.join(version_dir, 'metanorma.exe')
+        nil unless File.exist?(exe_path)
+      end
+
+      private
+
+      def verify_version_available!
+        repo = BinaryRepository.new
+        binary_version = repo.find(version)
+
+        return if binary_version
+
+        available = repo.all.map(&:version).first(5).join(', ')
+        raise InstallationError, "Binary version #{version} not found.\n" \
+                                "Available: #{available}...\n" \
+                                "Or use: mnenv install #{version} --source=gemfile"
+      end
+
+      def download_binary
+        url, format = binary_url_and_format
+        warn "Downloading #{url}..."
+
+        tempfile = download_to_tempfile(url)
+
+        case format
+        when 'tgz'
+          extract_tgz(tempfile)
+        when 'zip'
+          extract_zip(tempfile)
+        when 'exe'
+          # Windows .exe - just copy directly
+          FileUtils.cp(tempfile.path, File.join(version_dir, 'metanorma.exe'))
+        else
+          raise InstallationError, "Unknown binary format: #{format}"
+        end
+      rescue OpenURI::HTTPError => e
+        raise InstallationError, "Failed to download binary: #{e.message}"
+      ensure
+        tempfile&.close&.unlink
+      end
+
+      def binary_url_and_format
+        repo = BinaryRepository.new
+        binary_version = repo.find(version)
+
+        raise InstallationError, "Binary version #{version} not found in repository" unless binary_version
+
+        platform, arch, variant = detect_platform_arch_variant
+
+        # Try to find a matching platform in the version data
+        # Priority: exe for Windows, tgz for Unix, then zip as fallback
+        formats = platform == 'windows' ? %w[exe zip] : %w[tgz]
+
+        formats.each do |fmt|
+          platform_data = binary_version.find_platform(
+            name: platform,
+            arch: arch,
+            variant: variant,
+            format: fmt
+          )
+
+          return [platform_data['url'], fmt] if platform_data && platform_data['url']
+
+          # Try without variant (for non-musl systems)
+          platform_data = binary_version.find_platform(
+            name: platform,
+            arch: arch,
+            variant: nil,
+            format: fmt
+          )
+
+          return [platform_data['url'], fmt] if platform_data && platform_data['url']
+        end
+
+        # Fallback: construct URL manually (for backward compatibility)
+        warn 'Warning: Platform data not found in cache, constructing URL manually'
+        fallback_url_and_format(platform, arch, variant)
+      end
+
+      def fallback_url_and_format(platform, arch, variant)
+        tag_name = "v#{version}"
+
+        if platform == 'windows'
+          url_exe = "https://github.com/#{PACKED_MN_REPO}/releases/download/#{tag_name}/metanorma-#{platform}-#{arch}.exe"
+          return [url_exe, 'exe'] if url_exists?(url_exe)
+
+          url_zip = "https://github.com/#{PACKED_MN_REPO}/releases/download/#{tag_name}/metanorma-#{platform}-#{arch}.zip"
+          return [url_zip, 'zip'] if url_exists?(url_zip)
+
+          raise InstallationError, "No Windows binary found for version #{version}"
+        else
+          # Try with variant (e.g., musl)
+          if variant
+            url_variant = "https://github.com/#{PACKED_MN_REPO}/releases/download/#{tag_name}/metanorma-#{platform}-#{variant}-#{arch}.tgz"
+            return [url_variant, 'tgz'] if url_exists?(url_variant)
+          end
+
+          url_with_arch = "https://github.com/#{PACKED_MN_REPO}/releases/download/#{tag_name}/metanorma-#{platform}-#{arch}.tgz"
+          return [url_with_arch, 'tgz'] if url_exists?(url_with_arch)
+
+          raise InstallationError, "No binary found for #{platform}/#{arch} version #{version}"
+        end
+      end
+
+      def download_to_tempfile(url)
+        tempfile = Tempfile.new(['mnenv-binary', '.tmp'])
+        URI.open(url, 'rb') do |io|
+          IO.copy_stream(io, tempfile)
+        end
+        tempfile.rewind
+        tempfile
+      end
+
+      def extract_tgz(tempfile)
+        found = false
+        Gem::Package::TarReader.new(Zlib::GzipReader.open(tempfile.path)) do |tar|
+          tar.each do |entry|
+            next unless entry.file?
+
+            # Look for the metanorma binary
+            # The archive may contain:
+            # - metanorma (expected)
+            # - metanorma-linux-x86_64 (actual packed-mn naming)
+            # - metanorma-darwin-arm64
+            # etc.
+            filename = File.basename(entry.full_name)
+            next unless filename.start_with?('metanorma') && !filename.include?('.')
+
+            if filename == 'metanorma'
+            else
+              # Rename metanorma-linux-x86_64 to just metanorma
+            end
+            target_name = 'metanorma'
+
+            File.open(File.join(version_dir, target_name), 'wb') do |f|
+              f.write(entry.read)
+            end
+            found = true
+            break
+          end
+        end
+
+        raise InstallationError, 'Could not find metanorma binary in archive' unless found
+      end
+
+      def extract_zip(tempfile)
+        require 'zip'
+
+        Zip::File.open(tempfile.path) do |zip_file|
+          entry = zip_file.find { |e| File.basename(e.name) == 'metanorma.exe' }
+          raise InstallationError, 'Could not find metanorma.exe in zip archive' unless entry
+
+          File.open(File.join(version_dir, 'metanorma.exe'), 'wb') do |f|
+            f.write(entry.get_input_stream.read)
+          end
+        end
+      end
+
+      def url_exists?(url)
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          response = http.head(uri.path)
+          response.is_a?(Net::HTTPSuccess)
+        end
+      rescue StandardError
+        false
+      end
+
+      def detect_platform_arch_variant
+        platform = case RbConfig::CONFIG['host_os']
+                   when /linux/   then 'linux'
+                   when /darwin/  then 'darwin'
+                   when /mswin|mingw|cygwin/ then 'windows'
+                   else raise InstallationError, 'Unsupported platform for binary installations'
+                   end
+
+        # Detect architecture
+        arch = case RbConfig::CONFIG['host_cpu']
+               when /arm64|aarch64/ then 'arm64'
+               when /x86_64|x64/ then 'x86_64'
+               else 'x86_64' # Default to x86_64
+               end
+
+        # Detect variant (e.g., musl for Alpine Linux)
+        variant = detect_variant if platform == 'linux'
+
+        [platform, arch, variant]
+      end
+
+      def detect_variant
+        # Check for musl libc (Alpine Linux)
+        if File.exist?('/etc/alpine-release')
+          'musl'
+        elsif File.symlink?('/lib/libc.musl-x86_64.so.1')
+          'musl'
+        end
+      rescue StandardError
+        nil
+      end
+
+      def fetch_releases
+        URI(RELEASES_URL).open do |io|
+          JSON.parse(io.read)
+        end
+      rescue OpenURI::HTTPError => e
+        raise InstallationError, "Failed to fetch releases: #{e.message}"
+      end
+    end
+  end
+end

data/lib/mnenv/installers/gemfile_installer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../installer/base'
+
+module Mnenv
+  module Installers
+    class GemfileInstaller < Installer
+      def verify_prerequisites!
+        verify_version_exists!
+        verify_development_tools!
+      end
+
+      def perform_installation
+        copy_gemfiles
+        bundle_install
+      end
+
+      private
+
+      def verify_version_exists!
+        repo = GemfileRepository.new
+        return if repo.exists?(version)
+
+        available = repo.all.map(&:display_name).join(', ')
+        raise InstallationError, "Version #{version} not found in Gemfile repository. " \
+                                "Available: #{available}"
+      end
+
+      def verify_development_tools!
+        required_tools = %w[ruby bundle]
+
+        # Use 'where' on Windows, 'which' on Unix
+        which_cmd = Gem.win_platform? ? 'where' : 'which'
+
+        missing_tools = required_tools.reject do |tool|
+          system(which_cmd, tool, out: File::NULL, err: File::NULL)
+        end
+
+        return if missing_tools.empty?
+
+        raise DevelopmentToolsMissing,
+              "Development tools required for Gemfile installation.\n" \
+              "Missing: #{missing_tools.join(', ')}\n" \
+              "Install with: apt-get install ruby bundler build-essential  # Debian/Ubuntu\n" \
+              "             brew install ruby bundler                       # macOS\n" \
+              "Or use: mnenv install #{version} --source=binary"
+      end
+
+      def copy_gemfiles
+        repo = GemfileRepository.new
+        version_obj = repo.find(version)
+
+        raise InstallationError, "Version #{version} not found" unless version_obj
+
+        gemfile_source = version_obj.gemfile_path_calc
+        gemfile_lock_source = version_obj.gemfile_lock_path_calc
+
+        raise InstallationError, "Gemfile not found for #{version}" unless File.exist?(gemfile_source)
+        raise InstallationError, "Gemfile.lock not found for #{version}" unless File.exist?(gemfile_lock_source)
+
+        FileUtils.cp(gemfile_source, File.join(version_dir, 'Gemfile'))
+        FileUtils.cp(gemfile_lock_source, File.join(version_dir, 'Gemfile.lock'))
+      end
+
+      def bundle_install
+        Dir.chdir(version_dir) do
+          # Use system with bundler for proper isolation
+          # Don't suppress output to help debug issues
+          unless system('bundle', 'install', '--path', '.bundle', '--binstubs', 'bin')
+            raise InstallationError, "Bundle install failed for #{version}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mnenv/json_formatter.rb

@@ -5,12 +5,9 @@ require 'json'
 module Mnenv
   class JsonFormatter
     def self.format_version(version)
-      {
-        'version' => version.version,
-        'published_at' => format_timestamp(version.published_at),
-        'parsed_at' => format_timestamp(version.parsed_at),
+      version.to_hash.merge(
         'display_name' => version.display_name
-      }.merge(version_specific_fields(version))
+      ).merge(version_specific_fields(version))
     end
 
     def self.format_versions(versions)
@@ -22,18 +19,11 @@ module Mnenv
     end
 
     class << self
-      def format_timestamp(t) = t&.strftime('%Y-%m-%dT%H:%M:%SZ')
-
+      # Additional fields specific to JSON output format
       def version_specific_fields(version)
         case version
         when GemfileVersion
           { 'gemfile_exists' => version.exists_locally? }
-        when SnapVersion
-          { 'revision' => version.revision, 'channel' => version.channel }
-        when HomebrewVersion
-          { 'tag_name' => version.tag_name, 'commit_sha' => version.commit_sha }
-        when ChocolateyVersion
-          { 'package_name' => version.package_name, 'is_pre_release' => version.is_pre_release }
         else
           {}
         end

data/lib/mnenv/logger.rb

@@ -10,6 +10,7 @@ module Mnenv
       success: '✅',
       warning: '⚠️',
       error: '❌',
+      debug: '🔍',
       pulling: '📥',
       extracting: '📦',
       skipping: '⏭️',
@@ -33,6 +34,13 @@ module Mnenv
         warn Paint["#{EMOJIS[:error]} ERROR: #{message}", :red, :bold]
       end
 
+      # Only outputs when verbose mode is enabled
+      def debug(message)
+        return unless Cli.verbose?
+
+        puts Paint["#{EMOJIS[:debug]} [DEBUG] #{message}", :magenta]
+      end
+
       def pulling(version)
         puts Paint["#{EMOJIS[:pulling]} Pulling metanorma/metanorma:#{version}...", :blue]
       end
@@ -48,7 +56,7 @@ module Mnenv
       end
 
       def header(message)
-        puts "\n" + Paint["=== #{message} ===", :bold, :white] + "\n"
+        puts "\n#{Paint["=== #{message} ===", :bold, :white]}\n"
       end
 
       def section(message)

data/lib/mnenv/models/binary_version.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+
+module Mnenv
+  class BinaryVersion < ArtifactVersion
+    attribute :metadata, :hash, default: {}
+
+    key_value do
+      map 'version', to: :version
+      map 'published_at', to: :published_at
+      map 'parsed_at', to: :parsed_at
+      map 'metadata', to: :metadata
+    end
+
+    # Binary versions use plain version display (no 'v' prefix)
+    def display_name = version
+
+    # Get the release tag name (with 'v' prefix)
+    def tag_name = "v#{version}"
+
+    # Get the GitHub release URL
+    def html_url
+      metadata&.dig('html_url')
+    end
+
+    # Get list of available assets for this release
+    def assets
+      metadata&.dig('assets') || []
+    end
+
+    # Get platforms info (with URLs, format, etc.)
+    def platforms
+      metadata&.dig('platforms') || []
+    end
+
+    # Check if binary is available for a specific platform
+    def binary_for_platform?(platform)
+      assets.any? { |a| a == "metanorma-#{platform}" }
+    end
+
+    # Find the best matching platform entry for current system
+    # Returns the platform hash with url, format, etc.
+    def find_platform(name:, arch:, variant: nil, format: nil)
+      candidates = platforms.select { |p| p['name'] == name && p['arch'] == arch }
+
+      # Filter by variant
+      # - If variant is specified, match platforms with that variant
+      # - If variant is nil, match platforms WITHOUT a variant (glibc, not musl)
+      candidates = if variant
+                     candidates.select { |p| p['variant'] == variant }
+                   else
+                     candidates.select { |p| p['variant'].nil? }
+                   end
+
+      # Filter by format if specified
+      candidates = candidates.select { |p| p['format'] == format } if format
+
+      candidates.first
+    end
+
+    # Get download URL for a specific platform/arch combination
+    def download_url(name:, arch:, variant: nil, format: nil)
+      platform = find_platform(name: name, arch: arch, variant: variant, format: format)
+      platform&.dig('url')
+    end
+
+    # Get available platform names
+    def available_platforms
+      platforms.map { |p| p['name'] }.uniq
+    end
+
+    # Get available architectures for a platform
+    def available_arches_for(platform_name)
+      platforms.select { |p| p['name'] == platform_name }.map { |p| p['arch'] }.uniq
+    end
+  end
+end

data/lib/mnenv/models/chocolatey_version.rb

@@ -14,5 +14,12 @@ module Mnenv
       map 'package_name', to: :package_name
       map 'is_pre_release', to: :is_pre_release
     end
+
+    def to_hash
+      super.merge(
+        'package_name' => package_name,
+        'is_pre_release' => is_pre_release
+      )
+    end
   end
 end

data/lib/mnenv/models/gemfile_version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'version'
+require_relative '../versions_manager'
 
 module Mnenv
   class GemfileVersion < ArtifactVersion
@@ -8,6 +9,15 @@ module Mnenv
     attribute :gemfile_path, :string
     attribute :gemfile_lock_path, :string
 
+    # Class-level versions manager for dependency injection in tests
+    class << self
+      def versions_manager
+        @versions_manager ||= VersionsManager.new
+      end
+
+      attr_writer :versions_manager
+    end
+
     key_value do
       map 'version', to: :version
       map 'published_at', to: :published_at
@@ -17,7 +27,9 @@ module Mnenv
       map 'gemfile_lock_path', to: :gemfile_lock_path
     end
 
-    def data_dir = @data_dir ||= default_data_dir
+    def data_dir
+      @data_dir ||= File.join(self.class.versions_manager.data_path, 'gemfile')
+    end
 
     def directory_path = File.join(data_dir, "v#{version}")
 
@@ -31,10 +43,12 @@ module Mnenv
         File.file?(gemfile_lock_path_calc)
     end
 
-    private
-
-    def default_data_dir
-      @default_data_dir ||= File.join(__dir__, '..', '..', '..', 'data', 'gemfile')
+    def to_hash
+      super.merge(
+        'gemfile_exists' => gemfile_exists,
+        'gemfile_path' => gemfile_path,
+        'gemfile_lock_path' => gemfile_lock_path
+      )
     end
   end
 end

data/lib/mnenv/models/homebrew_version.rb

@@ -19,5 +19,12 @@ module Mnenv
       super
       @tag_name ||= "v#{version}" if version
     end
+
+    def to_hash
+      super.merge(
+        'tag_name' => tag_name,
+        'commit_sha' => commit_sha
+      )
+    end
   end
 end

data/lib/mnenv/models/snap_version.rb

@@ -18,5 +18,13 @@ module Mnenv
     end
 
     def display_name = revision ? "#{version}-#{revision}" : "v#{version}"
+
+    def to_hash
+      super.merge(
+        'revision' => revision,
+        'arch' => arch,
+        'channel' => channel
+      )
+    end
   end
 end

data/lib/mnenv/models/version.rb

@@ -16,6 +16,22 @@ module Mnenv
 
     def display_name = "v#{version}"
 
+    # Serialize version to hash for persistence
+    # Subclasses should override and merge with super
+    def to_hash
+      {
+        'version' => version,
+        'published_at' => format_timestamp(published_at),
+        'parsed_at' => format_timestamp(parsed_at)
+      }
+    end
+
+    private
+
+    def format_timestamp(time)
+      time&.strftime('%Y-%m-%dT%H:%M:%SZ')
+    end
+
     protected
 
     def version_parts = version.split('.').map(&:to_i)

data/lib/mnenv/models.rb

@@ -2,8 +2,10 @@
 
 require 'lutaml/model'
 
-require_relative 'models/version'
-require_relative 'models/gemfile_version'
-require_relative 'models/snap_version'
-require_relative 'models/homebrew_version'
-require_relative 'models/chocolatey_version'
+module Mnenv
+  autoload :ArtifactVersion, 'mnenv/models/version'
+  autoload :GemfileVersion, 'mnenv/models/gemfile_version'
+  autoload :SnapVersion, 'mnenv/models/snap_version'
+  autoload :HomebrewVersion, 'mnenv/models/homebrew_version'
+  autoload :ChocolateyVersion, 'mnenv/models/chocolatey_version'
+end

data/lib/mnenv/paths.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Centralized directory paths for mnenv
+  # This ensures consistency across all components
+  module Paths
+    # Base directory for all mnenv data
+    MNENV_DIR = File.expand_path('~/.mnenv').freeze
+
+    # Directory for the git clone of metanorma/versions (READ-ONLY data)
+    # Contains: data/gemfile/versions.yaml, data/gemfile/v1.14.4/Gemfile, etc.
+    VERSIONS_DATA_DIR = File.join(MNENV_DIR, 'versions').freeze
+
+    # Directory for installed Metanorma versions
+    # Contains: 1.14.3-gemfile/, 1.14.3-binary/, 1.14.4-gemfile/, etc.
+    INSTALLED_DIR = File.join(MNENV_DIR, 'installed').freeze
+
+    # Directory for shim scripts
+    SHIMS_DIR = File.join(MNENV_DIR, 'shims').freeze
+
+    # Directory for mnenv library files (resolver, etc.)
+    LIB_DIR = File.join(MNENV_DIR, 'lib', 'mnenv').freeze
+
+    # Global version file
+    VERSION_FILE = File.join(MNENV_DIR, 'version').freeze
+
+    # Global source file
+    SOURCE_FILE = File.join(MNENV_DIR, 'source').freeze
+
+    class << self
+      # Ensure all required directories exist
+      def ensure_directories
+        FileUtils.mkdir_p(MNENV_DIR)
+        FileUtils.mkdir_p(INSTALLED_DIR)
+        FileUtils.mkdir_p(SHIMS_DIR)
+        FileUtils.mkdir_p(LIB_DIR)
+      end
+
+      # Get the installation directory for a specific version and source
+      # @param version [String] The version number (e.g., "1.14.4")
+      # @param source [String] The source type (e.g., "gemfile", "binary")
+      # @return [String] The full path to the installation directory
+      def version_install_dir(version, source = nil)
+        if source
+          File.join(INSTALLED_DIR, "#{version}-#{source}")
+        else
+          # Backward compatibility: if no source specified, use version only
+          File.join(INSTALLED_DIR, version)
+        end
+      end
+
+      # Get the path to the data directory within the versions repo
+      def versions_data_path
+        File.join(VERSIONS_DATA_DIR, 'data')
+      end
+
+      # Parse a directory name into version and source components
+      # @param dir_name [String] Directory name like "1.14.4-gemfile" or "1.14.4"
+      # @return [Array<String, String>] Tuple of [version, source] where source may be nil
+      def parse_version_dir(dir_name)
+        if dir_name =~ /^(.+)-(gemfile|binary)$/
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        else
+          [dir_name, nil]
+        end
+      end
+    end
+  end
+end