appraisal2 3.0.0 → 3.0.1

data/lib/appraisal/appraisal.rb

@@ -9,12 +9,11 @@ require "appraisal/gemfile"
 require "appraisal/command"
 require "appraisal/customize"
 require "appraisal/utils"
+require "appraisal/gem_manager"
 
 module Appraisal
   # Represents one appraisal and its dependencies
   class Appraisal
-    DEFAULT_INSTALL_OPTIONS = {"jobs" => 1}.freeze
-
     attr_reader :name, :gemfile
 
     def initialize(name, source_gemfile)
@@ -79,22 +78,15 @@ module Appraisal
     end
 
     def install(options = {})
-      commands = [install_command(options).join(" ")]
-
-      commands.unshift(check_command.join(" ")) if options["without"].nil? || options["without"].empty?
-
-      command = commands.join(" || ")
-
-      if Bundler.settings[:path]
-        env = {"BUNDLE_DISABLE_SHARED_GEMS" => "1"}
-        Command.new(command, :env => env).run
-      else
-        Command.new(command).run
-      end
+      gem_manager = options.delete(:gem_manager) || options.delete("gem_manager") ||
+        options.delete(:"gem-manager") || options.delete("gem-manager")
+      manager = GemManager::Factory.create(gemfile_path, project_root, :manager => gem_manager)
+      manager.install(options)
     end
 
-    def update(gems = [])
-      Command.new(update_command(gems), :gemfile => gemfile_path).run
+    def update(gems = [], gem_manager: nil)
+      manager = GemManager::Factory.create(gemfile_path, project_root, :manager => gem_manager)
+      manager.update(gems)
     end
 
     def gemfile_path
@@ -122,20 +114,6 @@ module Appraisal
 
     private
 
-    def check_command
-      gemfile_option = "--gemfile='#{gemfile_path}'"
-      ["bundle", "check", gemfile_option]
-    end
-
-    def install_command(options = {})
-      gemfile_option = "--gemfile='#{gemfile_path}'"
-      ["bundle", "install", gemfile_option, bundle_options(options)].compact
-    end
-
-    def update_command(gems)
-      ["bundle", "update", *gems].compact
-    end
-
     def gemfile_root
       project_root + "gemfiles"
     end
@@ -156,32 +134,6 @@ module Appraisal
       name.gsub(/[^\w.]/, "_")
     end
 
-    def bundle_options(options)
-      full_options = DEFAULT_INSTALL_OPTIONS.dup.merge(options)
-      options_strings = []
-      jobs = full_options.delete("jobs")
-      if jobs > 1
-        if Utils.support_parallel_installation?
-          options_strings << "--jobs=#{jobs}"
-        else
-          warn("Your current version of Bundler does not support parallel installation. Please " \
-            "upgrade Bundler to version >= 1.4.0, or invoke `appraisal` without `--jobs` option.")
-        end
-      end
-
-      path = full_options.delete("path")
-      if path
-        relative_path = project_root.join(options["path"])
-        options_strings << "--path #{relative_path}"
-      end
-
-      full_options.each do |flag, val|
-        options_strings << "--#{flag} #{val}"
-      end
-
-      options_strings.join(" ") if options_strings != []
-    end
-
     def comment_lines(heading)
       heading.lines.map do |line|
         if line.lstrip.empty?

data/lib/appraisal/appraisal_file.rb

@@ -10,8 +10,10 @@ module Appraisal
   class AppraisalFile
     attr_reader :appraisals, :gemfile
 
-    def self.each(&block)
-      new.each(&block)
+    class << self
+      def each(&block)
+        new.each(&block)
+      end
     end
 
     def initialize

data/lib/appraisal/cli.rb

@@ -8,6 +8,12 @@ module Appraisal
     default_task :install
     map ["-v", "--version"] => "version"
 
+    class_option "gem-manager",
+      :aliases => "-g",
+      :type => :string,
+      :default => "bundler",
+      :desc => "Gem manager to use for install/update (bundler or ore)"
+
     class << self
       # Override help command to print out usage
       def help(shell, subcommand = false)
@@ -74,8 +80,9 @@ module Appraisal
     def install
       invoke(:generate, [], {})
 
+      install_options = options.to_h
       AppraisalFile.each do |appraisal|
-        appraisal.install(options)
+        appraisal.install(install_options)
         appraisal.relativize
       end
     end
@@ -94,10 +101,11 @@ module Appraisal
 
     desc "update [LIST_OF_GEMS]", "Remove all generated gemfiles and lockfiles, resolve, and install dependencies again"
     def update(*gems)
-      invoke(:generate, [])
+      invoke(:generate, [], {})
 
+      gem_manager = options["gem-manager"] || options[:gem_manager]
       AppraisalFile.each do |appraisal|
-        appraisal.update(gems)
+        appraisal.update(gems, :gem_manager => gem_manager)
       end
     end
 
@@ -126,5 +134,12 @@ module Appraisal
         end
       end
     end
+
+    def respond_to_missing?(name, include_private = false)
+      appraisals = AppraisalFile.new.appraisals
+      appraisals.any? { |appraisal| appraisal.name == name.to_s } || super
+    rescue AppraisalsNotFound
+      super
+    end
   end
 end

data/lib/appraisal/customize.rb

@@ -9,32 +9,40 @@ module Appraisal
       @@single_quotes = single_quotes
     end
 
-    def self.heading(gemfile = nil)
-      @@heading ||= nil
-      return @@heading unless gemfile
+    class << self
+      def heading(gemfile = nil)
+        @@heading ||= nil
+        return @@heading unless gemfile
 
-      customize(@@heading, gemfile)
-    end
+        customize(@@heading, gemfile)
+      end
 
-    def self.single_quotes
-      @@single_quotes ||= false
-    end
+      def single_quotes
+        @@single_quotes ||= false
+      end
 
-    def self.customize(topper, gemfile)
-      return unless topper
-
-      format(
-        topper.to_s,
-        :appraisal => gemfile.send(:clean_name),
-        :gemfile => gemfile.send(:gemfile_name),
-        :gemfile_path => gemfile.gemfile_path,
-        :lockfile => "#{gemfile.send(:gemfile_name)}.lock",
-        :lockfile_path => gemfile.send(:lockfile_path),
-        :relative_gemfile_path => gemfile.relative_gemfile_path,
-        :relative_lockfile_path => "#{gemfile.relative_gemfile_path}.lock",
-      )
-    end
+      # Reset class state - useful for testing
+      def reset!
+        @@heading = nil
+        @@single_quotes = false
+      end
 
-    private_class_method :customize
+      private
+
+      def customize(topper, gemfile)
+        return unless topper
+
+        format(
+          topper.to_s,
+          :appraisal => gemfile.send(:clean_name),
+          :gemfile => gemfile.send(:gemfile_name),
+          :gemfile_path => gemfile.gemfile_path,
+          :lockfile => "#{gemfile.send(:gemfile_name)}.lock",
+          :lockfile_path => gemfile.send(:lockfile_path),
+          :relative_gemfile_path => gemfile.relative_gemfile_path,
+          :relative_lockfile_path => "#{gemfile.relative_gemfile_path}.lock",
+        )
+      end
+    end
   end
 end

data/lib/appraisal/errors.rb

@@ -7,4 +7,25 @@ module Appraisal
       "Unable to locate 'Appraisals' file in the current directory."
     end
   end
+
+  # Raises when ore-light gem manager is requested but not installed.
+  class OreNotAvailableError < ArgumentError
+    def message
+      "ore-light is not installed or not in PATH. " \
+        "Install from: https://github.com/contriboss/ore-light"
+    end
+  end
+
+  # Raises when an unknown gem manager is requested.
+  class UnknownGemManagerError < ArgumentError
+    def initialize(manager, available)
+      @manager = manager
+      @available = available
+      super()
+    end
+
+    def message
+      "Unknown gem manager: '#{@manager}'. Available: #{@available.join(", ")}"
+    end
+  end
 end

data/lib/appraisal/gem_manager/base.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Appraisal
+  module GemManager
+    # Abstract base class defining the interface for gem managers.
+    # Subclasses must implement all public methods.
+    class Base
+      attr_reader :gemfile_path, :project_root
+
+      # @param gemfile_path [String] path to the gemfile
+      # @param project_root [Pathname] root directory of the project
+      def initialize(gemfile_path, project_root)
+        @gemfile_path = gemfile_path
+        @project_root = project_root
+      end
+
+      # Install gems for the given gemfile
+      # @param options [Hash] install options (jobs, retry, without, path, etc.)
+      # @return [void]
+      def install(options = {})
+        raise NotImplementedError, "#{self.class}#install must be implemented"
+      end
+
+      # Update gems (all or specific gems)
+      # @param gems [Array<String>] list of gems to update, empty = all
+      # @return [void]
+      def update(gems = [])
+        raise NotImplementedError, "#{self.class}#update must be implemented"
+      end
+
+      # Name of the gem manager for display
+      # @return [String]
+      def name
+        raise NotImplementedError, "#{self.class}#name must be implemented"
+      end
+
+      # Check if the gem manager is available on the system
+      # @return [Boolean]
+      def available?
+        raise NotImplementedError, "#{self.class}#available? must be implemented"
+      end
+
+      # Validate that the gem manager is available, raising an error if not
+      # @raise [OreNotAvailableError] if ore is not available
+      # @return [void]
+      def validate_availability!
+        # Default implementation does nothing (bundler is always available)
+      end
+    end
+  end
+end

data/lib/appraisal/gem_manager/bundler_adapter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Appraisal
+  module GemManager
+    # Bundler adapter for gem management operations.
+    # This is the default gem manager and is always available.
+    class BundlerAdapter < Base
+      DEFAULT_INSTALL_OPTIONS = {"jobs" => 1}.freeze
+
+      def name
+        "bundler"
+      end
+
+      def available?
+        true # Bundler is always available (it's a dependency of appraisal2)
+      end
+
+      def install(options = {})
+        commands = [install_command(options).join(" ")]
+
+        # Only run check command if not using --without option
+        if options["without"].nil? || options["without"].empty?
+          commands.unshift(check_command.join(" "))
+        end
+
+        command = commands.join(" || ")
+
+        if Bundler.settings[:path]
+          env = {"BUNDLE_DISABLE_SHARED_GEMS" => "1"}
+          Command.new(command, :gemfile => gemfile_path, :env => env).run
+        else
+          Command.new(command, :gemfile => gemfile_path).run
+        end
+      end
+
+      def update(gems = [])
+        Command.new(update_command(gems), :gemfile => gemfile_path).run
+      end
+
+      private
+
+      def check_command
+        gemfile_option = "--gemfile='#{gemfile_path}'"
+        ["bundle", "check", gemfile_option]
+      end
+
+      def install_command(options = {})
+        gemfile_option = "--gemfile='#{gemfile_path}'"
+        ["bundle", "install", gemfile_option, bundle_options(options)].compact
+      end
+
+      def update_command(gems)
+        ["bundle", "update", *gems].compact
+      end
+
+      def bundle_options(options)
+        full_options = DEFAULT_INSTALL_OPTIONS.dup.merge(options)
+        options_strings = []
+
+        jobs = full_options.delete("jobs")
+        if jobs > 1
+          if Utils.support_parallel_installation?
+            options_strings << "--jobs=#{jobs}"
+          else
+            warn("Your current version of Bundler does not support parallel installation. Please " \
+              "upgrade Bundler to version >= 1.4.0, or invoke `appraisal` without `--jobs` option.")
+          end
+        end
+
+        path = full_options.delete("path")
+        if path
+          relative_path = project_root.join(options["path"])
+          options_strings << "--path #{relative_path}"
+        end
+
+        full_options.each do |flag, val|
+          options_strings << "--#{flag} #{val}"
+        end
+
+        options_strings.join(" ") if options_strings != []
+      end
+    end
+  end
+end

data/lib/appraisal/gem_manager/factory.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "bundler_adapter"
+require_relative "ore_adapter"
+
+module Appraisal
+  module GemManager
+    # Factory for creating gem manager adapters.
+    # Raises errors for unknown or unavailable gem managers.
+    class Factory
+      ADAPTERS = {
+        "bundler" => BundlerAdapter,
+        "ore" => OreAdapter,
+      }.freeze
+
+      DEFAULT_MANAGER = "bundler"
+
+      class << self
+        # Create a gem manager adapter
+        # @param gemfile_path [String] path to the gemfile
+        # @param project_root [Pathname] root directory of the project
+        # @param manager [String, nil] gem manager name (bundler or ore)
+        # @return [Base] gem manager adapter instance
+        # @raise [UnknownGemManagerError] if manager is not recognized
+        # @raise [OreNotAvailableError] if ore is requested but not installed
+        def create(gemfile_path, project_root, manager: nil)
+          manager_name = normalize_manager_name(manager)
+
+          adapter_class = ADAPTERS.fetch(manager_name) do
+            raise UnknownGemManagerError.new(manager_name, ADAPTERS.keys)
+          end
+
+          adapter = adapter_class.new(gemfile_path, project_root)
+          adapter.validate_availability!
+          adapter
+        end
+
+        # List of available gem manager names
+        # @return [Array<String>]
+        def available_managers
+          ADAPTERS.keys
+        end
+
+        private
+
+        def normalize_manager_name(manager)
+          return DEFAULT_MANAGER if manager.nil? || manager.to_s.strip.empty?
+
+          manager.to_s.strip.downcase
+        end
+      end
+    end
+  end
+end

data/lib/appraisal/gem_manager/ore_adapter.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Appraisal
+  module GemManager
+    # Ore-light adapter for gem management operations.
+    # Ore-light is a fast, Go-based alternative to Bundler for gem installation.
+    # See: https://github.com/contriboss/ore-light
+    class OreAdapter < Base
+      ORE_EXECUTABLE = "ore"
+
+      def name
+        "ore"
+      end
+
+      def available?
+        system("which #{ORE_EXECUTABLE} > /dev/null 2>&1")
+      end
+
+      def validate_availability!
+        raise OreNotAvailableError unless available?
+      end
+
+      def install(options = {})
+        validate_availability!
+
+        lockfile = "#{gemfile_path}.lock"
+
+        # Run ore lock first if lockfile doesn't exist
+        unless File.exist?(lockfile)
+          lock_command = [ORE_EXECUTABLE, "lock", "-gemfile", gemfile_path]
+          run_ore_command(lock_command)
+        end
+
+        command = install_command(options)
+        run_ore_command(command)
+      end
+
+      def update(gems = [])
+        validate_availability!
+
+        command = update_command(gems)
+        run_ore_command(command)
+      end
+
+      private
+
+      def install_command(options = {})
+        cmd = [ORE_EXECUTABLE, "install"]
+
+        # Map bundler options to ore options
+        # Ore uses -workers instead of --jobs
+        jobs = options["jobs"]
+        cmd << "-workers=#{jobs}" if jobs && jobs > 1
+
+        # Ore uses -without with comma-separated groups
+        without = options["without"]
+        if without && !without.empty?
+          # Convert space-separated to comma-separated
+          groups = without.split(/\s+/).join(",")
+          cmd << "-without=#{groups}"
+        end
+
+        # Ore uses -vendor instead of --path
+        path = options["path"]
+        if path
+          relative_path = project_root.join(path)
+          cmd << "-vendor=#{relative_path}"
+        end
+
+        # Ore uses -lockfile to specify the lockfile path
+        cmd << "-lockfile=#{gemfile_path}.lock"
+
+        # Note: Ore does not support --retry, so we ignore that option
+
+        cmd
+      end
+
+      def update_command(gems)
+        cmd = [ORE_EXECUTABLE, "update", "-gemfile", gemfile_path]
+        cmd.concat(gems) if gems.any?
+        cmd
+      end
+
+      def run_ore_command(command)
+        puts ">> BUNDLE_GEMFILE=#{gemfile_path} #{command.join(" ")}"
+
+        # Ore resolves path dependencies relative to the current working directory,
+        # not relative to the gemfile location. We need to cd to the gemfile's
+        # directory so that relative paths like "../appraisal2" resolve correctly.
+        gemfile_dir = File.dirname(gemfile_path)
+
+        Bundler.with_original_env do
+          ENV["BUNDLE_GEMFILE"] = gemfile_path
+          ENV["APPRAISAL_INITIALIZED"] = "1"
+          Dir.chdir(gemfile_dir) do
+            exit(1) unless Kernel.system(*command)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appraisal/gem_manager.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "gem_manager/factory"
+
+module Appraisal
+  # Gem manager abstraction layer.
+  # Supports multiple gem managers (bundler, ore-light) via adapter pattern.
+  module GemManager
+  end
+end

data/lib/appraisal/version.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
 module Appraisal
-  VERSION = "3.0.0"
+  module Version
+    VERSION = "3.0.1"
+  end
+  VERSION = Version::VERSION # Traditional constant location
 end