super_diff 0.1.0

data/spec/integration/rspec_spec.rb

@@ -0,0 +1,261 @@
+require "spec_helper"
+
+RSpec.describe "Integration with RSpec", type: :integration do
+  context "comparing two different integers" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expect(1).to eq(42)
+      TEST
+
+      expected_output = <<~OUTPUT
+        expected: 42
+             got: 1
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  context "comparing two different symbols" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expect(:bar).to eq(:foo)
+      TEST
+
+      expected_output = <<~OUTPUT
+        expected: :foo
+             got: :bar
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  context "comparing two different single-line strings" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expect("Jennifer").to eq("Marty")
+      TEST
+
+      expected_output = <<~OUTPUT
+        expected: "Marty"
+             got: "Jennifer"
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  context "comparing two closely different multi-line strings" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expected = "This is a line\nAnd that's a line\nAnd there's a line too"
+        actual = "This is a line\nSomething completely different\nAnd there's a line too"
+        expect(actual).to eq(expected)
+      TEST
+
+      expected_output = <<~OUTPUT
+        Diff:
+
+        #{
+          colored do
+            plain_line %(  This is a line⏎)
+            red_line   %(- And that's a line⏎)
+            green_line %(+ Something completely different⏎)
+            plain_line %(  And there's a line too)
+          end
+        }
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  context "comparing two completely different multi-line strings" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expected = "This is a line\nAnd that's a line\n"
+        actual = "Something completely different\nAnd something else too\n"
+        expect(actual).to eq(expected)
+      TEST
+
+      expected_output = <<~OUTPUT
+        Diff:
+
+        #{
+          colored do
+            red_line   %(- This is a line⏎)
+            red_line   %(- And that's a line⏎)
+            green_line %(+ Something completely different⏎)
+            green_line %(+ And something else too⏎)
+          end
+        }
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  context "comparing two arrays with other data structures inside" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expected = [
+          [
+            :h1,
+            [:span, [:text, "Hello world"]],
+            {
+              class: "header",
+              data: {
+                "sticky" => true,
+                person: SuperDiff::Test::Person.new(name: "Marty")
+              }
+            }
+          ]
+        ]
+        actual = [
+          [
+            :h2,
+            [:span, [:text, "Goodbye world"]],
+            {
+              id: "hero",
+              class: "header",
+              data: {
+                "sticky" => false,
+                role: "deprecated",
+                person: SuperDiff::Test::Person.new(name: "Doc")
+              }
+            }
+          ],
+          :br
+        ]
+        expect(actual).to eq(expected)
+      TEST
+
+      expected_output = <<~OUTPUT
+        Diff:
+
+        #{
+          colored do
+            plain_line %(  [)
+            plain_line %(    [)
+            red_line   %(-     :h1,)
+            green_line %(+     :h2,)
+            plain_line %(      [)
+            plain_line %(        :span,)
+            plain_line %(        [)
+            plain_line %(          :text,)
+            red_line   %(-         "Hello world")
+            green_line %(+         "Goodbye world")
+            plain_line %(        ])
+            plain_line %(      ],)
+            plain_line %(      {)
+            plain_line %(        class: "header",)
+            plain_line %(        data: {)
+            red_line   %(-         "sticky" => true,)
+            green_line %(+         "sticky" => false,)
+            plain_line %(          person: #<SuperDiff::Test::Person {)
+            red_line   %(-           name: "Marty")
+            green_line %(+           name: "Doc")
+            plain_line %(          }>,)
+            green_line %(+         role: "deprecated")
+            plain_line %(        },)
+            green_line %(+       id: "hero")
+            plain_line %(      })
+            plain_line %(    ],)
+            green_line %(+   :br)
+            plain_line %(  ])
+          end
+        }
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  context "comparing two hashes with other data structures inside" do
+    it "produces the correct output" do
+      test = <<~TEST
+        expected = {
+          customer: {
+            person: SuperDiff::Test::Person.new(name: "Marty McFly"),
+            shipping_address: {
+              line_1: "123 Main St.",
+              city: "Hill Valley",
+              state: "CA",
+              zip: "90382"
+            }
+          },
+          items: [
+            {
+              name: "Fender Stratocaster",
+              cost: 100_000,
+              options: ["red", "blue", "green"]
+            },
+            { name: "Chevy 4x4" }
+          ]
+        }
+        actual = {
+          customer: {
+            person: SuperDiff::Test::Person.new(name: "Marty McFly, Jr."),
+            shipping_address: {
+              line_1: "456 Ponderosa Ct.",
+              city: "Hill Valley",
+              state: "CA",
+              zip: "90382"
+            }
+          },
+          items: [
+            {
+              name: "Fender Stratocaster",
+              cost: 100_000,
+              options: ["red", "blue", "green"]
+            },
+            { name: "Mattel Hoverboard" }
+          ]
+        }
+        expect(actual).to eq(expected)
+      TEST
+
+      expected_output = <<~OUTPUT
+        Diff:
+
+        #{
+          colored do
+            plain_line %(  {)
+            plain_line %(    customer: {)
+            plain_line %(      person: #<SuperDiff::Test::Person {)
+            red_line   %(-       name: "Marty McFly")
+            green_line %(+       name: "Marty McFly, Jr.")
+            plain_line %(      }>,)
+            plain_line %(      shipping_address: {)
+            red_line   %(-       line_1: "123 Main St.",)
+            green_line %(+       line_1: "456 Ponderosa Ct.",)
+            plain_line %(        city: "Hill Valley",)
+            plain_line %(        state: "CA",)
+            plain_line %(        zip: "90382")
+            plain_line %(      })
+            plain_line %(    },)
+            plain_line %(    items: [)
+            plain_line %(      {)
+            plain_line %(        name: "Fender Stratocaster",)
+            plain_line %(        cost: 100000,)
+            plain_line %(        options: ["red", "blue", "green"])
+            plain_line %(      },)
+            plain_line %(      {)
+            red_line   %(-       name: "Chevy 4x4")
+            green_line %(+       name: "Mattel Hoverboard")
+            plain_line %(      })
+            plain_line %(    ])
+            plain_line %(  })
+          end
+        }
+      OUTPUT
+
+      expect(test).to produce_output_when_run(expected_output)
+    end
+  end
+
+  def colored(&block)
+    SuperDiff::Tests::Colorizer.call(&block).chomp
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require_relative "../lib/super_diff"
+require_relative "../lib/super_diff/rspec"
+
+begin
+  require "pry-byebug"
+rescue LoadError
+end
+
+begin
+  require "pry-nav"
+rescue LoadError
+end
+
+Dir.glob(File.expand_path("support/**/*.rb", __dir__)).each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.include(SuperDiff::IntegrationTests, type: :integration)
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.max_formatted_output_length = nil
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = "documentation"
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+end
+
+require "pp"

data/spec/support/color_helper.rb

@@ -0,0 +1,49 @@
+module SuperDiff
+  module Tests
+    class Colorizer < BasicObject
+      def self.call(&block)
+        new.instance_eval(&block).to_s
+      end
+
+      def initialize
+        @string = ""
+      end
+
+      def method_missing(name, *args, &block)
+        match = name.to_s.match(/\A(.+)_line\Z/)
+
+        if match
+          real_name = match.captures[0]
+
+          if Csi::ColorHelper.respond_to?(real_name)
+            addition = Csi::ColorHelper.public_send(real_name, *args)
+
+            if match
+              addition << "\n"
+            end
+
+            @string << addition
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        match = name.to_s.match(/\A(.+)_line\Z/)
+
+        if match
+          Csi::ColorHelper.respond_to?(match.captures[0]) || super
+        else
+          super
+        end
+      end
+
+      def to_s
+        @string.strip
+      end
+    end
+  end
+end

data/spec/support/command_runner.rb

@@ -0,0 +1,279 @@
+require "childprocess"
+
+require "English"
+require "shellwords"
+require "timeout"
+
+class CommandRunner
+  module OutputHelpers
+    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
+
+  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
+
+      if output
+        message << <<-MESSAGE
+Output:
+#{OutputHelpers.divider("START") + output + OutputHelpers.divider("END")}
+        MESSAGE
+      end
+
+      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
+
+      if output
+        message << <<-MESSAGE
+Output:
+#{OutputHelpers.divider("START") + output + OutputHelpers.divider("END")}
+        MESSAGE
+      end
+
+      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: [:child, :out],
+      out: @writer,
+    )
+    @env = extract_env_from(@options)
+
+    @process = ChildProcess.build(*command)
+    @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
+
+      if run_successfully && !success?
+        fail!
+      end
+    end
+
+    self
+  end
+
+  def stop
+    if !writer.closed?
+      writer.close
+    end
+  end
+
+  def output
+    @_output ||= begin
+      stop
+      reader.read
+    end
+  end
+
+  def elided_output
+    lines = output.split(/\n/)
+    new_lines = lines[0..4]
+
+    if lines.size > 10
+      new_lines << "(...#{lines.size - 10} more lines...)"
+    end
+
+    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({}) do |hash, (key, value)|
+      hash.merge(key.to_s => value)
+    end
+  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" +
+        OutputHelpers.divider("START") +
+        output +
+        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
+    if debugging_enabled?
+      puts yield
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module SuperDiff
+  module IntegrationTests
+    def produce_output_when_run(output)
+      ProduceOutputWhenRunMatcher.new(output)
+    end
+
+    class ProduceOutputWhenRunMatcher
+      PROJECT_DIRECTORY = Pathname.new("../../../../../").expand_path(__FILE__)
+      TEMP_DIRECTORY = PROJECT_DIRECTORY.join("tmp")
+
+      def initialize(expected_output)
+        @expected_output =
+          expected_output.
+            strip.
+            split(/(\n+)/).
+            map { |line| line =~ /\n+/ ? line : (" " * 7) + line }.
+            join
+      end
+
+      def matches?(test)
+        @test = test.strip
+        TEMP_DIRECTORY.mkpath
+        actual_output.include?(expected_output)
+      end
+
+      def failure_message
+        "Expected test to produce output, but it did not.\n\n" +
+          "Expected output:\n\n" +
+          CommandRunner::OutputHelpers.divider("START") +
+          expected_output + "\n" +
+          CommandRunner::OutputHelpers.divider("END") +
+          "\n" +
+          "Actual output:\n\n" +
+          CommandRunner::OutputHelpers.divider("START") +
+          actual_output + "\n" +
+          CommandRunner::OutputHelpers.divider("END")
+      end
+
+      private
+
+      attr_reader :expected_output, :test
+
+      def actual_output
+        @_actual_output ||=
+          CommandRunner.run("rspec", tempfile.to_s).output.strip
+      end
+
+      def tempfile
+        @_tempfile =
+          TEMP_DIRECTORY.join("acceptance_spec.rb").
+            tap { |tempfile| tempfile.write(program) }
+      end
+
+      def program
+        <<~PROGRAM
+          require "#{PROJECT_DIRECTORY.join("lib/super_diff/rspec.rb")}"
+          require "#{PROJECT_DIRECTORY.join("spec/support/person.rb")}"
+          require "#{PROJECT_DIRECTORY.join("spec/support/person_diff_formatter.rb")}"
+          require "#{PROJECT_DIRECTORY.join("spec/support/person_operation_sequence.rb")}"
+          require "#{PROJECT_DIRECTORY.join("spec/support/person_operational_sequencer.rb")}"
+
+          SuperDiff::RSpec.configure do |config|
+            config.extra_operational_sequencer_classes << SuperDiff::Test::PersonOperationalSequencer
+            config.extra_diff_formatter_classes << SuperDiff::Test::PersonDiffFormatter
+          end
+
+          RSpec.describe "test" do
+            it "passes" do
+              #{test}
+            end
+          end
+        PROGRAM
+      end
+    end
+  end
+end