appraisal2 3.0.0

data/lib/appraisal/command.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Appraisal
+  # Executes commands with a clean environment
+  class Command
+    attr_reader :command, :env, :gemfile
+
+    def initialize(command, options = {})
+      @gemfile = options[:gemfile]
+      @env = options.fetch(:env, {})
+      @command = command_starting_with_bundle(command)
+    end
+
+    def run
+      run_env = test_environment.merge(env)
+
+      Bundler.with_original_env do
+        ensure_bundler_is_available
+        announce
+
+        ENV["BUNDLE_GEMFILE"] = gemfile
+        ENV["APPRAISAL_INITIALIZED"] = "1"
+        run_env.each_pair do |key, value|
+          ENV[key] = value
+        end
+
+        exit(1) unless Kernel.system(command_as_string)
+      end
+    end
+
+    private
+
+    def ensure_bundler_is_available
+      version = Utils.bundler_version
+      return if system(%(gem list --silent -i bundler -v #{version}))
+
+      puts ">> Reinstall Bundler into #{ENV["GEM_HOME"]}"
+
+      return if system("gem install bundler --version #{version}")
+
+      puts
+      puts <<-ERROR.rstrip
+Bundler installation failed.
+Please try running:
+  `GEM_HOME="#{ENV["GEM_HOME"]}" gem install bundler --version #{version}`
+manually.
+      ERROR
+      exit(1)
+    end
+
+    def announce
+      if gemfile
+        puts ">> BUNDLE_GEMFILE=#{gemfile} #{command_as_string}"
+      else
+        puts ">> #{command_as_string}"
+      end
+    end
+
+    def command_starts_with_bundle?(original_command)
+      if original_command.is_a?(Array)
+        original_command.first =~ /^bundle/
+      else
+        original_command =~ /^bundle/
+      end
+    end
+
+    def command_starting_with_bundle(original_command)
+      if command_starts_with_bundle?(original_command)
+        original_command
+      else
+        %w[bundle exec] + original_command
+      end
+    end
+
+    def command_as_string
+      if command.is_a?(Array)
+        Shellwords.join(command)
+      else
+        command
+      end
+    end
+
+    def test_environment
+      return {} unless ENV["APPRAISAL_UNDER_TEST"] == "1"
+
+      {
+        "GEM_HOME" => ENV["GEM_HOME"],
+        "GEM_PATH" => "",
+      }
+    end
+  end
+end

data/lib/appraisal/conditional.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+require "appraisal/utils"
+
+module Appraisal
+  class Conditional < BundlerDSL
+    def initialize(condition)
+      super()
+      @condition = condition
+    end
+
+    def to_s
+      <<-OUTPUT.rstrip
+install_if #{@condition} do
+#{indent(super)}
+end
+      OUTPUT
+    end
+
+    # :nodoc:
+    def for_dup
+      return unless @condition.is_a?(String)
+
+      <<-OUTPUT.rstrip
+install_if #{@condition} do
+#{indent(super)}
+end
+      OUTPUT
+    end
+  end
+end

data/lib/appraisal/customize.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Appraisal
+  class Customize
+    def initialize(options = {})
+      heading = options.fetch(:heading, nil)
+      single_quotes = options.fetch(:single_quotes, false)
+      @@heading = !heading.nil? && heading.chomp
+      @@single_quotes = single_quotes
+    end
+
+    def self.heading(gemfile = nil)
+      @@heading ||= nil
+      return @@heading unless gemfile
+
+      customize(@@heading, gemfile)
+    end
+
+    def self.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
+
+    private_class_method :customize
+  end
+end

data/lib/appraisal/dependency.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "appraisal/utils"
+
+module Appraisal
+  # Dependency on a gem and optional version requirements
+  class Dependency
+    attr_accessor :requirements
+    attr_reader :name
+
+    def initialize(name, requirements)
+      @name = name
+      @requirements = requirements
+    end
+
+    def to_s
+      formatted_output(Utils.format_arguments(path_prefixed_requirements))
+    end
+
+    # :nodoc:
+    def for_dup
+      formatted_output(Utils.format_arguments(requirements))
+    end
+
+    private
+
+    def path_prefixed_requirements
+      requirements.map do |requirement|
+        if requirement.is_a?(Hash)
+          requirement[:path] = Utils.prefix_path(requirement[:path]) if requirement[:path]
+
+          requirement[:git] = Utils.prefix_path(requirement[:git]) if requirement[:git]
+        end
+
+        requirement
+      end
+    end
+
+    def formatted_output(output_requirements)
+      [gem_name, output_requirements].compact.join(", ")
+    end
+
+    def gem_name
+      %(gem "#{name}")
+    end
+
+    def no_requirements?
+      requirements.nil? || requirements.empty?
+    end
+  end
+end

data/lib/appraisal/dependency_list.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Std libs
+require "set"
+
+# This gem
+require "appraisal/dependency"
+require "appraisal/ordered_hash"
+
+module Appraisal
+  class DependencyList
+    def initialize
+      @dependencies = OrderedHash.new
+      @removed_dependencies = Set.new
+    end
+
+    def add(name, requirements)
+      return if @removed_dependencies.include?(name)
+
+      @dependencies[name] = Dependency.new(name, requirements)
+    end
+
+    def remove(name)
+      return unless @removed_dependencies.add?(name)
+
+      @dependencies.delete(name)
+    end
+
+    def to_s
+      @dependencies.values.map(&:to_s).join("\n")
+    end
+
+    # :nodoc:
+    def for_dup
+      @dependencies.values.map(&:for_dup).join("\n")
+    end
+  end
+end

data/lib/appraisal/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Appraisal
+  # Raises when Appraisal is unable to locate Appraisals file in the current directory.
+  class AppraisalsNotFound < StandardError
+    def message
+      "Unable to locate 'Appraisals' file in the current directory."
+    end
+  end
+end

data/lib/appraisal/gemfile.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+
+module Appraisal
+  autoload :Gemspec, "appraisal/gemspec"
+  autoload :Git, "appraisal/git"
+  autoload :Group, "appraisal/group"
+  autoload :Path, "appraisal/path"
+  autoload :Platform, "appraisal/platform"
+  autoload :Source, "appraisal/source"
+  autoload :Conditional, "appraisal/conditional"
+
+  # Load bundler Gemfiles and merge dependencies
+  class Gemfile < BundlerDSL
+    def load(path)
+      run(File.read(path), path) if File.exist?(path)
+    end
+
+    def run(definitions, path, line = 1)
+      instance_eval(definitions, path, line) if definitions
+    end
+
+    def dup
+      Gemfile.new.tap do |gemfile|
+        gemfile.git_sources = @git_sources
+        gemfile.run(for_dup, __FILE__, __LINE__)
+      end
+    end
+  end
+end

data/lib/appraisal/gemspec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "appraisal/utils"
+
+module Appraisal
+  class Gemspec
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+      @options[:path] ||= "."
+    end
+
+    def to_s
+      "gemspec #{Utils.format_string(exported_options)}"
+    end
+
+    # :nodoc:
+    def for_dup
+      "gemspec #{Utils.format_string(@options)}"
+    end
+
+    private
+
+    def exported_options
+      @options.merge(
+        :path => Utils.prefix_path(@options[:path]),
+      )
+    end
+  end
+end

data/lib/appraisal/git.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+require "appraisal/utils"
+
+module Appraisal
+  class Git < BundlerDSL
+    def initialize(source, options = {})
+      super()
+      @source = source
+      @options = options
+    end
+
+    def to_s
+      if @options.empty?
+        <<-OUTPUT.rstrip
+git #{Utils.prefix_path(@source).inspect} do
+#{indent(super)}
+end
+        OUTPUT
+      else
+        <<-OUTPUT.rstrip
+git #{Utils.prefix_path(@source).inspect}, #{Utils.format_string(@options)} do
+#{indent(super)}
+end
+        OUTPUT
+      end
+    end
+
+    # :nodoc:
+    def for_dup
+      if @options.empty?
+        <<-OUTPUT.rstrip
+git #{@source.inspect} do
+#{indent(super)}
+end
+        OUTPUT
+      else
+        <<-OUTPUT.rstrip
+git #{@source.inspect}, #{Utils.format_string(@options)} do
+#{indent(super)}
+end
+        OUTPUT
+      end
+    end
+  end
+end

data/lib/appraisal/group.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+require "appraisal/utils"
+
+module Appraisal
+  class Group < BundlerDSL
+    def initialize(group_names)
+      super()
+      @group_names = group_names
+    end
+
+    def to_s
+      formatted_output(super)
+    end
+
+    # :nodoc:
+    def for_dup
+      formatted_output(super)
+    end
+
+    private
+
+    def formatted_output(output_dependencies)
+      <<-OUTPUT.rstrip
+group #{Utils.format_arguments(@group_names)} do
+#{indent(output_dependencies)}
+end
+      OUTPUT
+    end
+  end
+end

data/lib/appraisal/ordered_hash.rb

@@ -0,0 +1,22 @@
+module Appraisal
+  # An ordered hash implementation for Ruby 1.8.7 compatibility. This is not
+  # a complete implementation, but it covers Appraisal's specific needs.
+  class OrderedHash < ::Hash
+    # Hashes are ordered in Ruby 1.9.
+    if RUBY_VERSION < "1.9"
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def []=(key, value)
+        @keys << key unless has_key?(key)
+        super
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+    end
+  end
+end

data/lib/appraisal/path.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+require "appraisal/utils"
+
+module Appraisal
+  class Path < BundlerDSL
+    def initialize(source, options = {})
+      super()
+      @source = source
+      @options = options
+    end
+
+    def to_s
+      if @options.empty?
+        <<-OUTPUT.rstrip
+path #{Utils.prefix_path(@source).inspect} do
+#{indent(super)}
+end
+        OUTPUT
+      else
+        <<-OUTPUT.rstrip
+path #{Utils.prefix_path(@source).inspect}, #{Utils.format_string(@options)} do
+#{indent(super)}
+end"
+        OUTPUT
+      end
+    end
+
+    # :nodoc:
+    def for_dup
+      if @options.empty?
+        <<-OUTPUT.rstrip
+path #{@source.inspect} do
+#{indent(super)}
+end
+        OUTPUT
+      else
+        <<-OUTPUT.rstrip
+path #{@source.inspect}, #{Utils.format_string(@options)} do
+#{indent(super)}
+end
+        OUTPUT
+      end
+    end
+  end
+end

data/lib/appraisal/platform.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+require "appraisal/utils"
+
+module Appraisal
+  class Platform < BundlerDSL
+    def initialize(platform_names)
+      super()
+      @platform_names = platform_names
+    end
+
+    def to_s
+      formatted_output(super)
+    end
+
+    # :nodoc:
+    def for_dup
+      formatted_output(super)
+    end
+
+    private
+
+    def formatted_output(output_dependencies)
+      <<-OUTPUT.rstrip
+platforms #{Utils.format_arguments(@platform_names)} do
+#{indent(output_dependencies)}
+end
+      OUTPUT
+    end
+  end
+end

data/lib/appraisal/source.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "appraisal/bundler_dsl"
+require "appraisal/utils"
+
+module Appraisal
+  class Source < BundlerDSL
+    def initialize(source)
+      super()
+      @source = source
+    end
+
+    def to_s
+      formatted_output(super)
+    end
+
+    # :nodoc:
+    def for_dup
+      formatted_output(super)
+    end
+
+    private
+
+    def formatted_output(output_dependencies)
+      <<-OUTPUT.rstrip
+source #{@source.inspect} do
+#{indent(output_dependencies)}
+end
+      OUTPUT
+    end
+  end
+end

data/lib/appraisal/task.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "appraisal/appraisal_file"
+require "rake/tasklib"
+
+module Appraisal
+  # Defines tasks for installing appraisal dependencies and running other tasks
+  # for a given appraisal.
+  class Task < Rake::TaskLib
+    def initialize
+      namespace(:appraisal) do
+        desc("DEPRECATED: Generate a Gemfile for each appraisal")
+        task(:gemfiles) do
+          warn("`rake appraisal:gemfile` task is deprecated and will be removed soon. " \
+            "Please use `appraisal generate`.")
+          exec("bundle exec appraisal generate")
+        end
+
+        desc("DEPRECATED: Resolve and install dependencies for each appraisal")
+        task(:install) do
+          warn("`rake appraisal:install` task is deprecated and will be removed soon. " \
+            "Please use `appraisal install`.")
+          exec("bundle exec appraisal install")
+        end
+
+        desc("DEPRECATED: Remove all generated gemfiles from gemfiles/ folder")
+        task(:cleanup) do
+          warn("`rake appraisal:cleanup` task is deprecated and will be removed soon. " \
+            "Please use `appraisal clean`.")
+          exec("bundle exec appraisal clean")
+        end
+
+        begin
+          AppraisalFile.each do |appraisal|
+            desc("DEPRECATED: Run the given task for appraisal #{appraisal.name}")
+            task(appraisal.name) do
+              ARGV.shift
+              warn("`rake appraisal:#{appraisal.name}` task is deprecated and will be removed soon. " \
+                "Please use `appraisal #{appraisal.name} rake #{ARGV.join(" ")}`.")
+              exec("bundle exec appraisal #{appraisal.name} rake #{ARGV.join(" ")}")
+            end
+          end
+        rescue AppraisalsNotFound
+        end
+
+        task(:all) do
+          ARGV.shift
+          exec("bundle exec appraisal rake #{ARGV.join(" ")}")
+        end
+      end
+
+      desc("Run the given task for all appraisals")
+      task(:appraisal => "appraisal:all")
+    end
+  end
+end

data/lib/appraisal/utils.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Appraisal
+  # Contains methods for various operations
+  module Utils
+    class << self
+      def support_parallel_installation?
+        Gem::Version.create(Bundler::VERSION) >= Gem::Version.create("1.4.0.pre.1")
+      end
+
+      def support_git_local_installation?
+        Gem::Version.create(Bundler::VERSION) > Gem::Version.create("2.4.22")
+      end
+
+      # Appraisal needs to print Gemfiles in the oldest Ruby syntax that is supported by Appraisal.
+      # Otherwise, a project would not be able to use Appraisal to test compatibility
+      #   with older versions of Ruby, which is a core use case for Appraisal.
+      def format_string(object, enclosing_object = false)
+        case object
+        when Hash
+          items = object.map do |key, value|
+            format_hash_value(key, value)
+          end
+
+          if enclosing_object
+            "{ #{items.join(", ")} }"
+          else
+            items.join(", ")
+          end
+        else
+          object.inspect
+        end
+      end
+
+      # Appraisal needs to print Gemfiles in the oldest Ruby syntax that is supported by Appraisal.
+      # This means formatting Hashes as Rockets, until support for Ruby 1.8 is dropped.
+      # Regardless of what Ruby is used to generate appraisals,
+      #   generated appraisals may need to run on a different Ruby version.
+      # Generated appraisals should use a syntax compliant with the oldest supported Ruby version.
+      def format_hash_value(key, value)
+        key = format_string(key, true)
+        value = format_string(value, true)
+
+        "#{key} => #{value}"
+      end
+
+      def format_arguments(arguments)
+        return if arguments.empty?
+
+        arguments.map { |object| format_string(object, false) }.join(", ")
+      end
+
+      def join_parts(parts)
+        parts.reject(&:nil?).reject(&:empty?).join("\n\n").rstrip
+      end
+
+      def prefix_path(path)
+        if path !~ /^(?:\/|\S:)/ && path !~ /^\S+:\/\// && path !~ /^\S+@\S+:/
+          cleaned_path = path.gsub(/(^|\/)\.(?:\/|$)/, "\\1")
+          File.join("..", cleaned_path)
+        else
+          path
+        end
+      end
+
+      def bundler_version
+        Gem::Specification.detect { |spec| spec.name == "bundler" }.version.to_s
+      end
+    end
+  end
+end

data/lib/appraisal/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Appraisal
+  VERSION = "3.0.0"
+end

data/lib/appraisal.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# :nocov:
+require "appraisal2"
+# :nocov:

data/lib/appraisal2.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "appraisal/version"
+require "appraisal/task"
+
+Appraisal::Task.new