super_diff 0.1.0 → 0.2.0

data/lib/super_diff/csi/color_helper.rb

@@ -1,52 +0,0 @@
-module SuperDiff
-  module Csi
-    module ColorHelper
-      BLACK = Csi::FourBitColor.new(:white)
-      # LIGHT_RED = Csi::TwentyFourBitColor.new(r: 63, g: 32, b: 32)
-      LIGHT_RED = Csi::TwentyFourBitColor.new(r: 73, g: 62, b: 71)
-      # RED = Csi::TwentyFourBitColor.new(r: 110, g: 56, b: 56)
-      # RED = Csi::TwentyFourBitColor.new(r: 116, g: 78, b: 84)
-      RED = Csi::FourBitColor.new(:red)
-      # LIGHT_GREEN = Csi::TwentyFourBitColor.new(r: 40, g: 48, b: 39)
-      LIGHT_GREEN = Csi::TwentyFourBitColor.new(r: 51, g: 81, b: 81)
-      # GREEN = Csi::TwentyFourBitColor.new(r: 73, g: 87, b: 71)
-      # GREEN = Csi::TwentyFourBitColor.new(r: 81, g: 115, b: 105)
-      GREEN = Csi::FourBitColor.new(:green)
-      DARK_GREY = Csi::TwentyFourBitColor.new(r: 134, g: 147, b: 149)
-
-      def self.plain(text)
-        text
-      end
-
-      def self.line(given_text = "")
-        if block_given?
-          text = ""
-          yield text
-          text + "\n"
-        else
-          given_text + "\n"
-        end
-      end
-
-      def self.light_red_bg(text)
-        Csi.colorize(text, fg: BLACK, bg: LIGHT_RED)
-      end
-
-      def self.red(text)
-        Csi.colorize(text, fg: RED)
-      end
-
-      def self.light_green_bg(text)
-        Csi.colorize(text, fg: BLACK, bg: LIGHT_GREEN)
-      end
-
-      def self.green(text)
-        Csi.colorize(text, fg: GREEN)
-      end
-
-      def self.dark_grey(text)
-        Csi.colorize(text, fg: BLACK, bg: DARK_GREY)
-      end
-    end
-  end
-end

data/lib/super_diff/csi/eight_bit_sequence.rb

@@ -1,27 +0,0 @@
-module SuperDiff
-  module Csi
-    class EightBitSequence
-      LEADING_CODES = { fg: 38, bg: 48 }.freeze
-      SERIAL_CODE = 5
-
-      def initialize(fg: nil, bg: nil)
-        @fg = fg
-        @bg = bg
-      end
-
-      def to_s
-        [sequence_for(:fg, fg), sequence_for(:bg, bg)].compact.join
-      end
-
-      private
-
-      attr_reader :fg, :bg
-
-      def sequence_for(type, color)
-        if color
-          "\e[#{LEADING_CODES.fetch(type)};#{SERIAL_CODE};#{color.code}m"
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/csi/four_bit_sequence.rb

@@ -1,24 +0,0 @@
-module SuperDiff
-  module Csi
-    class FourBitSequence
-      def initialize(fg: nil, bg: nil)
-        @fg = fg
-        @bg = bg
-      end
-
-      def to_s
-        [sequence_for(fg), sequence_for(bg)].compact.join
-      end
-
-      private
-
-      attr_reader :fg, :bg
-
-      def sequence_for(color)
-        if color
-          "\e[#{color.code}m"
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/csi/sequence.rb

@@ -1,22 +0,0 @@
-module SuperDiff
-  module Csi
-    module Sequence
-      def self.for(color)
-        case color
-        when :reset
-          Csi::ResetSequence.new
-        when FourBitColor
-          Csi::FourBitSequence.new(color)
-        when EightBitColor
-          Csi::EightBitSequence.new(color)
-        when TwentyFourBitColor
-          Csi::TwentyFourBitSequence.new(color)
-        else
-          raise ArgumentError.new(
-            "Don't know how to interpret color: #{color.inspect}",
-          )
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/csi/twenty_four_bit_sequence.rb

@@ -1,27 +0,0 @@
-module SuperDiff
-  module Csi
-    class TwentyFourBitSequence
-      LEADING_CODES = { fg: 38, bg: 48 }.freeze
-      SERIAL_CODE = 2
-
-      def initialize(fg: nil, bg: nil)
-        @fg = fg
-        @bg = bg
-      end
-
-      def to_s
-        [sequence_for(:fg, fg), sequence_for(:bg, bg)].compact.join
-      end
-
-      private
-
-      attr_reader :fg, :bg
-
-      def sequence_for(type, color)
-        if color
-          "\e[#{LEADING_CODES.fetch(type)};#{SERIAL_CODE};#{color.code}m"
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/diff_formatters/multi_line_string.rb

@@ -1,31 +0,0 @@
-module SuperDiff
-  module DiffFormatters
-    class MultiLineString < Base
-      def self.applies_to?(operations)
-        operations.is_a?(OperationSequences::MultiLineString)
-      end
-
-      def call
-        lines.join("\n")
-      end
-
-      private
-
-      def lines
-        operations.reduce([]) do |array, operation|
-          case operation.name
-          when :change
-            array << Helpers.style(:deleted, "- #{operation.left_value}")
-            array << Helpers.style(:inserted, "+ #{operation.right_value}")
-          when :delete
-            array << Helpers.style(:deleted, "- #{operation.value}")
-          when :insert
-            array << Helpers.style(:inserted, "+ #{operation.value}")
-          else
-            array << Helpers.style(:normal, "  #{operation.value}")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/differs/object.rb

@@ -1,68 +0,0 @@
-module SuperDiff
-  module Differs
-    class Object < Base
-      def self.applies_to?(value)
-        value.is_a?(::Object)
-      end
-
-      def self.call(
-        expected,
-        actual,
-        indent_level:,
-        index_in_collection:,
-        **rest
-      )
-        super(
-          expected,
-          actual,
-          indent_level: indent_level,
-          index_in_collection: index_in_collection,
-          **rest
-        )
-      end
-
-      def self.inspection_lines_for(value)
-        inspected_value = value.inspect
-        match = inspected_value.match(/\A#<([^ ]+)(.*)>\Z/)
-
-        if match
-          [
-            "#<#{match.captures[0]} {",
-            *match.captures[1].split(" ").map { |line| "  " + line },
-            "}>",
-          ]
-        else
-          [inspected_value]
-        end
-      end
-
-      def call
-        lines.join("\n")
-      end
-
-      private
-
-      attr_reader :expected, :actual, :indent_level, :index_in_collection
-
-      def lines
-        [
-          styled_lines_for("-", :deleted, expected),
-          styled_lines_for("+", :inserted, actual),
-        ]
-      end
-
-      def styled_lines_for(icon, style_name, value)
-        unstyled_lines_for(icon, value).map do |line|
-          Helpers.style(style_name, line)
-        end
-      end
-
-      def unstyled_lines_for(icon, value)
-        lines = self.class.inspection_lines_for(value).
-          map { |inspection_line| "#{icon} #{indentation}#{inspection_line}" }
-
-        lines
-      end
-    end
-  end
-end

data/lib/super_diff/equality_matchers/object.rb

@@ -1,18 +0,0 @@
-module SuperDiff
-  module EqualityMatchers
-    class Object < Base
-      def self.applies_to?(value)
-        value.class == ::Object
-      end
-
-      def fail
-        <<~OUTPUT.strip
-          Differing #{Helpers.plural_type_for(actual)}.
-
-          #{Helpers.style :deleted,  "Expected: #{expected.inspect}"}
-          #{Helpers.style :inserted, "  Actual: #{actual.inspect}"}
-        OUTPUT
-      end
-    end
-  end
-end

data/lib/super_diff/value_inspection.rb

@@ -1,11 +0,0 @@
-module SuperDiff
-  class ValueInspection
-    attr_reader :beginning, :middle, :end
-
-    def initialize(args)
-      @beginning = args.fetch(:beginning)
-      @middle = args.fetch(:middle)
-      @end = args.fetch(:end)
-    end
-  end
-end

data/spec/integration/rspec_spec.rb

@@ -1,261 +0,0 @@
-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