appraisal2 3.0.0

data/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+| Version  | Supported |
+|----------|-----------|
+| 1.latest | ✅         |
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## Additional Support
+
+If you are interested in support for versions older than the latest release,
+please consider sponsoring the project / maintainer @ https://liberapay.com/pboling/donate,
+or find other sponsorship links in the [README].
+
+[README]: README.md

data/exe/appraisal

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+require "appraisal2"
+require "appraisal/cli"
+
+begin
+  Appraisal::CLI.start
+rescue Appraisal::AppraisalsNotFound => e
+  puts e.message
+  exit(127)
+end

data/lib/appraisal/appraisal.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+# Std Lib
+require "fileutils"
+require "pathname"
+
+# This gem
+require "appraisal/gemfile"
+require "appraisal/command"
+require "appraisal/customize"
+require "appraisal/utils"
+
+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)
+      @name = name
+      @gemfile = source_gemfile.dup
+    end
+
+    def eval_gemfile(*args)
+      gemfile.eval_gemfile(*args)
+    end
+
+    def gem(*args)
+      gemfile.gem(*args)
+    end
+
+    def remove_gem(*args)
+      gemfile.remove_gem(*args)
+    end
+
+    def source(*args, &block)
+      gemfile.source(*args, &block)
+    end
+
+    def ruby(*args)
+      gemfile.ruby(*args)
+    end
+
+    def git(*args, &block)
+      gemfile.git(*args, &block)
+    end
+
+    def path(*args, &block)
+      gemfile.path(*args, &block)
+    end
+
+    def group(*args, &block)
+      gemfile.group(*args, &block)
+    end
+
+    def install_if(*args, &block)
+      gemfile.install_if(*args, &block)
+    end
+
+    def platforms(*args, &block)
+      gemfile.platforms(*args, &block)
+    end
+
+    def gemspec(options = {})
+      gemfile.gemspec(options)
+    end
+
+    def git_source(*args, &block)
+      gemfile.git_source(*args, &block)
+    end
+
+    def write_gemfile
+      File.open(gemfile_path, "w") do |file|
+        signature =
+          Customize.heading(self) || "This file was generated by Appraisal2"
+        file.puts([comment_lines(signature), quoted_gemfile].join("\n\n"))
+      end
+    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
+    end
+
+    def update(gems = [])
+      Command.new(update_command(gems), :gemfile => gemfile_path).run
+    end
+
+    def gemfile_path
+      gemfile_root.mkdir unless gemfile_root.exist?
+
+      gemfile_root.join(gemfile_name).to_s
+    end
+
+    def relative_gemfile_path
+      File.join("gemfiles", gemfile_name)
+    end
+
+    def relativize
+      current_directory = Pathname.new(Dir.pwd)
+      relative_path = current_directory.relative_path_from(gemfile_root).cleanpath
+      lockfile_content = File.read(lockfile_path)
+
+      File.open(lockfile_path, "w") do |file|
+        file.write(lockfile_content.gsub(
+          / #{current_directory}/,
+          " #{relative_path}",
+        ))
+      end
+    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 gemfile_root
+      project_root + "gemfiles"
+    end
+
+    def project_root
+      Pathname.new(Dir.pwd)
+    end
+
+    def gemfile_name
+      "#{clean_name}.gemfile"
+    end
+
+    def lockfile_path
+      "#{gemfile_path}.lock"
+    end
+
+    def clean_name
+      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?
+          line
+        else
+          "# #{line}"
+        end
+      end.join
+    end
+
+    def quoted_gemfile
+      return gemfile.to_s unless Customize.single_quotes
+
+      gemfile.to_s.tr('"', "'")
+    end
+  end
+end

data/lib/appraisal/appraisal_file.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "appraisal/appraisal"
+require "appraisal/customize"
+require "appraisal/errors"
+require "appraisal/gemfile"
+
+module Appraisal
+  # Loads and parses Appraisals file
+  class AppraisalFile
+    attr_reader :appraisals, :gemfile
+
+    def self.each(&block)
+      new.each(&block)
+    end
+
+    def initialize
+      @appraisals = []
+      @gemfile = Gemfile.new
+      @gemfile.load(ENV["BUNDLE_GEMFILE"] || "Gemfile")
+
+      raise AppraisalsNotFound unless File.exist?(path)
+
+      run(File.read(path))
+    end
+
+    def each(&block)
+      appraisals.each(&block)
+    end
+
+    def appraise(name, &block)
+      appraisal = Appraisal.new(name, gemfile)
+      appraisal.instance_eval(&block)
+      @appraisals << appraisal
+    end
+
+    def customize_gemfiles(&_block)
+      args = yield
+      Customize.new(args)
+    end
+
+    private
+
+    def run(definitions)
+      instance_eval(definitions, __FILE__, __LINE__)
+    end
+
+    def path
+      "Appraisals"
+    end
+  end
+end

data/lib/appraisal/bundler_dsl.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "appraisal/dependency_list"
+require "appraisal/ordered_hash"
+
+module Appraisal
+  class BundlerDSL
+    attr_reader :dependencies
+
+    PARTS = %w[
+      source
+      ruby_version
+      gits
+      paths
+      dependencies
+      groups
+      platforms
+      source_blocks
+      install_if
+      gemspec
+      eval_gemfile
+    ]
+
+    def initialize
+      @sources = []
+      @ruby_version = nil
+      @dependencies = DependencyList.new
+      @gemspecs = []
+      @groups = OrderedHash.new
+      @platforms = OrderedHash.new
+      @gits = OrderedHash.new
+      @paths = OrderedHash.new
+      @source_blocks = OrderedHash.new
+      @git_sources = {}
+      @install_if = {}
+      @eval_gemfile = []
+    end
+
+    def run(&block)
+      instance_exec(&block)
+    end
+
+    def eval_gemfile(path, contents = nil)
+      @eval_gemfile << [path, contents]
+    end
+
+    def gem(name, *requirements)
+      @dependencies.add(name, substitute_git_source(requirements))
+    end
+
+    def remove_gem(name)
+      @dependencies.remove(name)
+    end
+
+    def group(*names, &block)
+      @groups[names] ||=
+        Group.new(names).tap { |g| g.git_sources = @git_sources.dup }
+      @groups[names].run(&block)
+    end
+
+    def install_if(condition, &block)
+      @install_if[condition] ||=
+        Conditional.new(condition).tap { |g| g.git_sources = @git_sources.dup }
+      @install_if[condition].run(&block)
+    end
+
+    def platforms(*names, &block)
+      @platforms[names] ||=
+        Platform.new(names).tap { |g| g.git_sources = @git_sources.dup }
+      @platforms[names].run(&block)
+    end
+
+    alias_method :platform, :platforms
+
+    def source(source, &block)
+      if block_given?
+        @source_blocks[source] ||=
+          Source.new(source).tap { |g| g.git_sources = @git_sources.dup }
+        @source_blocks[source].run(&block)
+      else
+        @sources << source
+      end
+    end
+
+    def ruby(ruby_version)
+      @ruby_version = ruby_version
+    end
+
+    def git(source, options = {}, &block)
+      @gits[source] ||=
+        Git.new(source, options).tap { |g| g.git_sources = @git_sources.dup }
+      @gits[source].run(&block)
+    end
+
+    def path(source, options = {}, &block)
+      @paths[source] ||=
+        Path.new(source, options).tap { |g| g.git_sources = @git_sources.dup }
+      @paths[source].run(&block)
+    end
+
+    def to_s
+      Utils.join_parts(PARTS.map { |part| send(:"#{part}_entry") })
+    end
+
+    def for_dup
+      Utils.join_parts(PARTS.map { |part| send(:"#{part}_entry_for_dup") })
+    end
+
+    def gemspec(options = {})
+      @gemspecs << Gemspec.new(options)
+    end
+
+    def git_source(source, &block)
+      @git_sources[source] = block
+    end
+
+    protected
+
+    attr_writer :git_sources
+
+    private
+
+    def eval_gemfile_entry
+      @eval_gemfile.map { |(p, c)| "eval_gemfile(#{p.inspect}#{", #{c.inspect}" if c})" } * "\n\n"
+    end
+
+    alias_method :eval_gemfile_entry_for_dup, :eval_gemfile_entry
+
+    def source_entry
+      @sources.uniq.map { |source| "source #{source.inspect}" }.join("\n")
+    end
+
+    alias_method :source_entry_for_dup, :source_entry
+
+    def ruby_version_entry
+      return unless @ruby_version
+
+      case @ruby_version
+      when String then "ruby #{@ruby_version.inspect}"
+      else "ruby(#{Utils.format_string(@ruby_version)})"
+      end
+    end
+
+    alias_method :ruby_version_entry_for_dup, :ruby_version_entry
+
+    def gemspec_entry
+      @gemspecs.map(&:to_s).join("\n")
+    end
+
+    def gemspec_entry_for_dup
+      @gemspecs.map(&:for_dup).join("\n")
+    end
+
+    def dependencies_entry
+      @dependencies.to_s
+    end
+
+    def dependencies_entry_for_dup
+      @dependencies.for_dup
+    end
+
+    [:gits, :paths, :platforms, :groups, :source_blocks, :install_if].each do |method_name|
+      class_eval <<-METHODS, __FILE__, __LINE__ + 1
+        private
+
+        def #{method_name}_entry
+          @#{method_name}.values.map(&:to_s).join("\n\n")
+        end
+
+        def #{method_name}_entry_for_dup
+          @#{method_name}.values.map(&:for_dup).join("\n\n")
+        end
+      METHODS
+    end
+
+    def indent(string)
+      indent_by = ENV.fetch("APPRAISAL_INDENTER", "lookaround")
+      if indent_by == "lookaround"
+        # Default indenter for Appraisal v3
+        # Uses a "look-around" of the "look-behind" variety to indent lines that are more than just empty space.
+        # In other words, retain existing indentation, and indent the line again, but not on empty lines.
+        string.
+          # NOTES:
+          #   (?![\r\n]) - Negative Look Behind which requires that the following pattern,
+          #                which is (\s*) in this case, *not* be followed by a new line character
+          #   (\s*) - Captures whitespace at beginning of the line
+          #   Learn more here: https://learnbyexample.github.io/Ruby_Regexp/lookarounds.html
+          gsub(/^(?![\r\n])(\s*)/, '  \0').
+          rstrip
+      elsif indent_by == "capture"
+        # Original indentation regex for Appraisal < v3
+        string.gsub(/^(.+)$/, '  \1').rstrip
+      else
+        string
+      end
+    end
+
+    def substitute_git_source(requirements)
+      requirements.each do |requirement|
+        next unless requirement.is_a?(Hash)
+
+        (requirement.keys & @git_sources.keys).each do |matching_source|
+          value = requirement.delete(matching_source)
+          requirement[:git] = @git_sources[matching_source].call(value)
+        end
+      end
+    end
+  end
+end

data/lib/appraisal/cli.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+
+module Appraisal
+  class CLI < Thor
+    default_task :install
+    map ["-v", "--version"] => "version"
+
+    class << self
+      # Override help command to print out usage
+      def help(shell, subcommand = false)
+        shell.say(strip_heredoc(<<-HELP))
+          Appraisal: Find out what your Ruby gems are worth.
+
+          Usage:
+            appraisal [APPRAISAL_NAME] EXTERNAL_COMMAND
+
+            If APPRAISAL_NAME is given, only run that EXTERNAL_COMMAND against the given
+            appraisal, otherwise it runs the EXTERNAL_COMMAND against all appraisals.
+        HELP
+
+        if File.exist?("Appraisals")
+          shell.say
+          shell.say("Available Appraisal(s):")
+
+          AppraisalFile.each do |appraisal|
+            shell.say("  - #{appraisal.name}")
+          end
+        end
+
+        shell.say
+
+        super
+      end
+
+      def exit_on_failure?
+        true
+      end
+
+      private
+
+      def strip_heredoc(string)
+        indent = string.scan(/^[ \t]*(?=\S)/).min.size || 0
+        string.gsub(/^[ \t]{#{indent}}/, "")
+      end
+    end
+
+    desc "install", "Resolve and install dependencies for each appraisal"
+    method_option "jobs",
+      :aliases => "j",
+      :type => :numeric,
+      :default => 1,
+      :banner => "SIZE",
+      :desc => "Install gems in parallel using the given number of workers."
+    method_option "retry",
+      :type => :numeric,
+      :default => 1,
+      :desc => "Retry network and git requests that have failed"
+    method_option "without",
+      :banner => "GROUP_NAMES",
+      :desc => "A space-separated list of groups referencing gems to skip " \
+        "during installation. Bundler will remember this option."
+    method_option "full-index",
+      :type => :boolean,
+      :desc => "Run bundle install with the " \
+        "full-index argument."
+    method_option "path",
+      :type => :string,
+      :desc => "Install gems in the specified directory. " \
+        "Bundler will remember this option."
+
+    def install
+      invoke(:generate, [], {})
+
+      AppraisalFile.each do |appraisal|
+        appraisal.install(options)
+        appraisal.relativize
+      end
+    end
+
+    desc "generate", "Generate a gemfile for each appraisal"
+    def generate
+      AppraisalFile.each do |appraisal|
+        appraisal.write_gemfile
+      end
+    end
+
+    desc "clean", "Remove all generated gemfiles and lockfiles from gemfiles folder"
+    def clean
+      FileUtils.rm_f(Dir["gemfiles/*.{gemfile,gemfile.lock}"])
+    end
+
+    desc "update [LIST_OF_GEMS]", "Remove all generated gemfiles and lockfiles, resolve, and install dependencies again"
+    def update(*gems)
+      invoke(:generate, [])
+
+      AppraisalFile.each do |appraisal|
+        appraisal.update(gems)
+      end
+    end
+
+    desc "list", "List the names of the defined appraisals"
+    def list
+      AppraisalFile.new.appraisals.each { |appraisal| puts appraisal.name }
+    end
+
+    desc "version", "Display the version and exit"
+    def version
+      puts "Appraisal2 #{VERSION}"
+    end
+
+    private
+
+    def method_missing(name, *args)
+      matching_appraisal = AppraisalFile.new.appraisals.detect do |appraisal|
+        appraisal.name == name.to_s
+      end
+
+      if matching_appraisal
+        Command.new(args, :gemfile => matching_appraisal.gemfile_path).run
+      else
+        AppraisalFile.each do |appraisal|
+          Command.new(ARGV, :gemfile => appraisal.gemfile_path).run
+        end
+      end
+    end
+  end
+end