super_diff 0.12.1 → 0.14.0

data/spec/support/command_runner.rb

@@ -1,253 +0,0 @@
-require "childprocess"
-
-require "English"
-require "shellwords"
-require "timeout"
-
-class CommandRunner
-  class CommandFailedError < StandardError
-    def self.create(command:, exit_status:, output:, message: nil)
-      allocate.tap do |error|
-        error.command = command
-        error.exit_status = exit_status
-        error.output = output
-        error.__send__(:initialize, message)
-      end
-    end
-
-    attr_accessor :command, :exit_status, :output
-
-    def initialize(message = nil)
-      super(message || build_message)
-    end
-
-    private
-
-    def build_message
-      message = <<-MESSAGE
-Command #{command.inspect} failed, exiting with status #{exit_status}.
-      MESSAGE
-
-      message << <<-MESSAGE if output
-Output:
-#{
-        SuperDiff::Test::OutputHelpers.divider("START") + output +
-          SuperDiff::Test::OutputHelpers.divider("END")
-      }
-        MESSAGE
-
-      message
-    end
-  end
-
-  class CommandTimedOutError < StandardError
-    def self.create(command:, timeout:, output:, message: nil)
-      allocate.tap do |error|
-        error.command = command
-        error.timeout = timeout
-        error.output = output
-        error.__send__(:initialize, message)
-      end
-    end
-
-    attr_accessor :command, :timeout, :output
-
-    def initialize(message = nil)
-      super(message || build_message)
-    end
-
-    private
-
-    def build_message
-      message = <<-MESSAGE
-Command #{formatted_command.inspect} timed out after #{timeout} seconds.
-      MESSAGE
-
-      message << <<-MESSAGE if output
-Output:
-#{
-        SuperDiff::Test::OutputHelpers.divider("START") + output +
-          SuperDiff::Test::OutputHelpers.divider("END")
-      }
-        MESSAGE
-
-      message
-    end
-  end
-
-  def self.run(*args)
-    new(*args).tap do |runner|
-      yield runner if block_given?
-      runner.run
-    end
-  end
-
-  def self.run!(*args)
-    run(*args) do |runner|
-      runner.run_successfully = true
-      yield runner if block_given?
-    end
-  end
-
-  attr_reader :status, :options, :env
-  attr_accessor :run_quickly, :run_successfully, :retries, :timeout
-
-  def initialize(*args)
-    @reader, @writer = IO.pipe
-    options = (args.last.is_a?(Hash) ? args.pop : {})
-    @args = args
-    @options = options.merge(err: %i[child out], out: @writer)
-    @env = extract_env_from(@options)
-
-    @process = ChildProcess.build(*command)
-    @env.each { |key, value| @process.environment[key] = value }
-    @process.io.stdout = @process.io.stderr = @writer
-
-    @wrapper = ->(block) { block.call }
-    self.directory = Dir.pwd
-    @run_quickly = false
-    @run_successfully = false
-    @retries = 1
-    @num_times_run = 0
-    @timeout = 10
-  end
-
-  def around_command(&block)
-    @wrapper = block
-  end
-
-  def directory
-    @options[:chdir]
-  end
-
-  def directory=(directory)
-    @options[:chdir] = (directory || Dir.pwd).to_s
-  end
-
-  def formatted_command
-    [formatted_env, Shellwords.join(command)].reject(&:empty?).join(" ")
-  end
-
-  def run
-    possibly_running_quickly do
-      run_with_debugging
-
-      fail! if run_successfully && !success?
-    end
-
-    self
-  end
-
-  def stop
-    writer.close if !writer.closed?
-  end
-
-  def output
-    @_output ||=
-      begin
-        stop
-        reader.read
-      end
-  end
-
-  def elided_output
-    lines = output.split(/\n/)
-    new_lines = lines[0..4]
-
-    new_lines << "(...#{lines.size - 10} more lines...)" if lines.size > 10
-
-    new_lines << lines[-5..-1]
-    new_lines.join("\n")
-  end
-
-  def success?
-    status.success?
-  end
-
-  def exit_status
-    status.exitstatus
-  end
-
-  def fail!
-    raise CommandFailedError.create(
-            command: formatted_command,
-            exit_status: exit_status,
-            output: output
-          )
-  end
-
-  def has_output?(expected_output)
-    if expected_output.is_a?(Regexp)
-      output =~ expected_output
-    else
-      output.include?(expected_output)
-    end
-  end
-
-  protected
-
-  attr_reader :args, :reader, :writer, :wrapper, :process
-
-  private
-
-  def extract_env_from(options)
-    options
-      .delete(:env) { {} }
-      .reduce({}) { |hash, (key, value)| hash.merge(key.to_s => value) }
-  end
-
-  def command
-    args.flatten.flat_map { |word| Shellwords.split(word) }
-  end
-
-  def formatted_env
-    env.map { |key, value| "#{key}=#{value.inspect}" }.join(" ")
-  end
-
-  def run_freely
-    process.start
-    process.wait
-  end
-
-  def run_with_wrapper
-    wrapper.call(method(:run_freely))
-  end
-
-  def run_with_debugging
-    debug { "\n\e[33mChanging to directory:\e[0m #{directory}" }
-    debug { "\e[32mRunning command:\e[0m #{formatted_command}" }
-
-    run_with_wrapper
-
-    debug do
-      "\n" + SuperDiff::Test::OutputHelpers.divider("START") + output +
-        SuperDiff::Test::OutputHelpers.divider("END")
-    end
-  end
-
-  def possibly_running_quickly(&block)
-    if run_quickly
-      begin
-        Timeout.timeout(timeout, &block)
-      rescue Timeout::Error
-        stop
-
-        raise CommandTimedOutError.create(
-                command: formatted_command,
-                timeout: timeout,
-                output: output
-              )
-      end
-    else
-      yield
-    end
-  end
-
-  def debugging_enabled?
-    ENV["DEBUG_COMMANDS"] == "1"
-  end
-
-  def debug
-    puts yield if debugging_enabled?
-  end
-end

data/spec/support/helpers.rb

@@ -1,21 +0,0 @@
-module SuperDiff
-  module Test
-    module OutputHelpers
-      def self.bookended(text)
-        divider("START") + text + "\n" + divider("END")
-      end
-
-      def self.divider(title = "")
-        total_length = 72
-        start_length = 3
-
-        string = ""
-        string << ("-" * start_length)
-        string << title
-        string << "-" * (total_length - start_length - title.length)
-        string << "\n"
-        string
-      end
-    end
-  end
-end

data/spec/support/integration/helpers.rb

@@ -1,124 +0,0 @@
-module SuperDiff
-  module IntegrationTests
-    PROJECT_DIRECTORY = Pathname.new("../../..").expand_path(__dir__)
-
-    def as_both_colored_and_uncolored
-      [true, false].each { |color_enabled| yield color_enabled }
-    end
-
-    def make_plain_test_program(
-      test,
-      color_enabled:,
-      super_diff_configuration: {},
-      preserve_as_whole_file: false
-    )
-      TestPrograms::Plain.new(
-        test,
-        color_enabled: color_enabled,
-        super_diff_configuration: super_diff_configuration,
-        preserve_as_whole_file: preserve_as_whole_file
-      )
-    end
-
-    def make_rspec_active_record_program(test, color_enabled:)
-      TestPrograms::RSpecActiveRecord.new(test, color_enabled: color_enabled)
-    end
-
-    def make_rspec_active_support_program(test, color_enabled:)
-      TestPrograms::RSpecActiveSupport.new(test, color_enabled: color_enabled)
-    end
-
-    def make_rspec_rails_test_program(test, color_enabled:)
-      TestPrograms::RSpecRails.new(test, color_enabled: color_enabled)
-    end
-
-    def make_rspec_rails_engine_with_action_controller_program(
-      test,
-      color_enabled:
-    )
-      TestPrograms::RspecRailsEngineWithActionController.new(
-        test,
-        color_enabled: color_enabled
-      )
-    end
-
-    def build_expected_output(
-      color_enabled:,
-      snippet:,
-      expectation:,
-      test_name: "test passes",
-      key_enabled: true,
-      newline_before_expectation: false,
-      indentation: 7,
-      diff: nil,
-      extra_failure_lines: nil
-    )
-      colored(color_enabled: color_enabled) do
-        line "Failures:\n"
-
-        line "1) #{test_name}", indent_by: 2
-
-        line indent_by: 5 do
-          bold "Failure/Error: "
-          plain snippet
-        end
-
-        newline if diff || newline_before_expectation
-
-        indent by: indentation do
-          evaluate_block(&expectation)
-
-          if diff
-            newline
-
-            white_line "Diff:"
-
-            if key_enabled
-              newline
-
-              line { blue "┌ (Key) ──────────────────────────┐" }
-
-              line do
-                blue "│ "
-                magenta "‹-› in expected, not in actual"
-                blue "  │"
-              end
-
-              line do
-                blue "│ "
-                yellow "‹+› in actual, not in expected"
-                blue "  │"
-              end
-
-              line do
-                blue "│ "
-                text "‹ › in both expected and actual"
-                blue " │"
-              end
-
-              line { blue "└─────────────────────────────────┘" }
-            end
-
-            newline
-
-            evaluate_block(&diff)
-
-            newline
-          end
-        end
-
-        if extra_failure_lines
-          newline
-          evaluate_block(&extra_failure_lines)
-        end
-      end
-    end
-
-    def colored(color_enabled: true, &block)
-      SuperDiff::Core::Helpers
-        .style(color_enabled: color_enabled, &block)
-        .to_s
-        .chomp
-    end
-  end
-end

data/spec/support/integration/matchers/produce_output_when_run_matcher.rb

@@ -1,104 +0,0 @@
-module SuperDiff
-  module IntegrationTests
-    def produce_output_when_run(output)
-      ProduceOutputWhenRunMatcher.new(output)
-    end
-
-    class ProduceOutputWhenRunMatcher
-      def initialize(expected_output)
-        @expected_output = expected_output.to_s
-        @output_processor = nil
-        @expect_output_to_contain_color = nil
-      end
-
-      def removing_object_ids
-        first_replacing(/#<([\w_:]+):0x[a-f0-9]+/, '#<\1')
-        self
-      end
-
-      def in_color(color_enabled)
-        @expect_output_to_contain_color = color_enabled
-        self
-      end
-
-      def matches?(program)
-        @program = program
-
-        output_matches? && presence_of_color_matches?
-      end
-
-      def failure_message
-        if output_matches?
-          "Expected output of test " +
-            (expect_output_to_contain_color? ? "to " : "not to ") +
-            "contain color, but " +
-            (expect_output_to_contain_color? ? "it did not" : "it did") + "."
-        else
-          message =
-            "Expected test to produce #{expect_output_to_contain_color? ? "colored" : "uncolored"} output, but it did not.\n\n" +
-              "Expected output to contain:\n\n" +
-              SuperDiff::Test::OutputHelpers.bookended(expected_output) + "\n" +
-              "Actual output:\n\n" +
-              SuperDiff::Test::OutputHelpers.bookended(actual_output)
-
-          if %w[1 true].include?(ENV["SHOW_DIFF"])
-            ::RSpec::Matchers::ExpectedsForMultipleDiffs.from(
-              expected_output
-            ).message_with_diff(
-              message,
-              ::RSpec::Expectations.differ,
-              actual_output
-            )
-          else
-            message
-          end
-        end
-      end
-
-      def failure_message_when_negated
-        "Expected output of test not to produce output, but it did.\n\n" +
-          "Actual output:\n\n" +
-          SuperDiff::Test::OutputHelpers.bookended(actual_output)
-      end
-
-      private
-
-      attr_reader :expected_output, :program, :output_processor
-
-      def expect_output_to_contain_color?
-        @expect_output_to_contain_color
-      end
-
-      def first_replacing(pattern, replacement)
-        @output_processor = [pattern, replacement]
-        self
-      end
-
-      def output_matches?
-        actual_output.include?(expected_output)
-      end
-
-      def actual_output
-        @_actual_output ||=
-          begin
-            output = program.run.output.strip
-
-            if output_processor
-              output.gsub!(output_processor[0], output_processor[1])
-            end
-
-            output
-          end
-      end
-
-      def presence_of_color_matches?
-        @expect_output_to_contain_color.nil? ||
-          output_has_color? == expect_output_to_contain_color?
-      end
-
-      def output_has_color?
-        !!(actual_output =~ /\e\[\d+m/)
-      end
-    end
-  end
-end

data/spec/support/integration/matchers.rb

@@ -1,177 +0,0 @@
-module SuperDiff
-  module IntegrationTests
-    def fail_with_indented_multiline_failure_message
-      FailWithIndentedMultilineFailureMessageMatcher.new
-    end
-
-    def fail_with_paragraphed_failure_message
-      FailWithParagraphedFailureMessageMatcher.new
-    end
-
-    def fail_with_non_indented_multiline_failure_message
-      FailWithNonIndentedMultilineFailureMessageMatcher.new
-    end
-
-    def fail_with_singleline_failure_message
-      FailWithSinglelineFailureMessageMatcher.new
-    end
-
-    def pass_with_indented_multiline_failure_message
-      PassWithIndentedMultilineFailureMessageMatcher.new
-    end
-
-    def pass_with_paragraphed_failure_message
-      PassWithParagraphedFailureMessageMatcher.new
-    end
-
-    def pass_with_non_indented_multiline_failure_message
-      PassWithNonIndentedMultilineFailureMessageMatcher.new
-    end
-
-    def pass_with_singleline_failure_message
-      PassWithSinglelineFailureMessageMatcher.new
-    end
-
-    RSpec::Matchers.define :failing_custom_matcher_from_dsl do |value|
-      match { false }
-
-      description do
-        "custom matcher defined via the DSL with value #{value.inspect}"
-      end
-    end
-
-    def failing_custom_matcher_from_scratch(value)
-      FailingCustomMatcherFromScratch.new(value)
-    end
-
-    class FailingCustomMatcherFromScratch
-      def initialize(value)
-        @value = value
-      end
-
-      def matches?(_)
-        false
-      end
-
-      def description
-        "custom matcher defined from scratch with value #{value.inspect}"
-      end
-
-      def failure_message
-        "Expected custom matcher not to fail, but did"
-      end
-
-      private
-
-      attr_reader :value
-    end
-
-    class FailWithIndentedMultilineFailureMessageMatcher
-      def matches?(_)
-        false
-      end
-
-      def failure_message
-        <<-MESSAGE
-This is a message that spans multiple lines.
-Here is the next line.
-  This part is indented, for whatever reason. It just kinda keeps
-  going until we finish saying whatever it is we want to say.
-        MESSAGE
-      end
-    end
-
-    class FailWithParagraphedFailureMessageMatcher
-      def matches?(_)
-        false
-      end
-
-      def failure_message
-        <<-MESSAGE
-This is a message that spans multiple paragraphs.
-
-Here is the next paragraph.
-        MESSAGE
-      end
-    end
-
-    class FailWithNonIndentedMultilineFailureMessageMatcher
-      def matches?(_)
-        false
-      end
-
-      def failure_message
-        <<-MESSAGE
-This is a message that spans multiple lines.
-Here is the next line.
-        MESSAGE
-      end
-    end
-
-    class FailWithSinglelineFailureMessageMatcher
-      def matches?(_)
-        false
-      end
-
-      def failure_message
-        <<-MESSAGE
-This is a message that spans only one line.
-        MESSAGE
-      end
-    end
-
-    class PassWithIndentedMultilineFailureMessageMatcher
-      def does_not_match?(_)
-        false
-      end
-
-      def failure_message_when_negated
-        <<-MESSAGE
-This is a message that spans multiple lines.
-Here is the next line.
-  This part is indented, for whatever reason. It just kinda keeps
-  going until we finish saying whatever it is we want to say.
-        MESSAGE
-      end
-    end
-
-    class PassWithParagraphedFailureMessageMatcher
-      def does_not_match?(_)
-        false
-      end
-
-      def failure_message_when_negated
-        <<-MESSAGE
-This is a message that spans multiple paragraphs.
-
-Here is the next paragraph.
-        MESSAGE
-      end
-    end
-
-    class PassWithNonIndentedMultilineFailureMessageMatcher
-      def does_not_match?(_)
-        false
-      end
-
-      def failure_message_when_negated
-        <<-MESSAGE
-This is a message that spans multiple lines.
-Here is the next line.
-        MESSAGE
-      end
-    end
-
-    class PassWithSinglelineFailureMessageMatcher
-      def does_not_match?(_)
-        false
-      end
-
-      def failure_message_when_negated
-        <<-MESSAGE
-This is a message that spans only one line.
-        MESSAGE
-      end
-    end
-  end
-end