super_diff 0.10.0 → 0.11.0

data/spec/support/shared_examples/hash_with_indifferent_access.rb

@@ -6,18 +6,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = {
-                  line_1: "123 Main St.",
-                  city: "Hill Valley",
-                  state: "CA",
-                  zip: "90382",
-                }
                 actual = HashWithIndifferentAccess.new({
                   line_1: "456 Ponderosa Ct.",
                   city: "Oakland",
                   state: "CA",
                   zip: "91234",
                 })
+                expected = {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382",
+                }
                 expect(actual).to eq(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -63,18 +63,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = {
-                  "line_1" => "123 Main St.",
-                  "city" => "Hill Valley",
-                  "state" => "CA",
-                  "zip" => "90382",
-                }
                 actual = HashWithIndifferentAccess.new({
                   line_1: "456 Ponderosa Ct.",
                   city: "Oakland",
                   state: "CA",
                   zip: "91234",
                 })
+                expected = {
+                  "line_1" => "123 Main St.",
+                  "city" => "Hill Valley",
+                  "state" => "CA",
+                  "zip" => "90382",
+                }
                 expect(actual).to eq(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -124,18 +124,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  line_1: "456 Ponderosa Ct.",
-                  city: "Oakland",
-                  state: "CA",
-                  zip: "91234",
-                })
                 actual = {
                   line_1: "123 Main St.",
                   city: "Hill Valley",
                   state: "CA",
                   zip: "90382",
                 }
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
                 expect(actual).to eq(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -181,18 +181,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  line_1: "456 Ponderosa Ct.",
-                  city: "Oakland",
-                  state: "CA",
-                  zip: "91234",
-                })
                 actual = {
                   "line_1" => "123 Main St.",
                   "city" => "Hill Valley",
                   "state" => "CA",
                   "zip" => "90382",
                 }
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
                 expect(actual).to eq(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -240,16 +240,6 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  shipments: [
-                    HashWithIndifferentAccess.new({
-                      estimated_delivery: HashWithIndifferentAccess.new({
-                        from: '2019-05-06',
-                        to: '2019-05-06'
-                      })
-                    })
-                  ]
-                })
                 actual = {
                   shipments: [
                     {
@@ -260,6 +250,16 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
                     }
                   ]
                 }
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
                 expect(actual).to eq(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -307,16 +307,6 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  shipments: [
-                    HashWithIndifferentAccess.new({
-                      estimated_delivery: HashWithIndifferentAccess.new({
-                        from: '2019-05-06',
-                        to: '2019-05-06'
-                      })
-                    })
-                  ]
-                })
                 actual = {
                   'shipments' => [
                     {
@@ -327,6 +317,16 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
                     }
                   ]
                 }
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
                 expect(actual).to eq(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -380,18 +380,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = {
-                  line_1: "123 Main St.",
-                  city: "Hill Valley",
-                  state: "CA",
-                  zip: "90382",
-                }
                 actual = HashWithIndifferentAccess.new({
                   line_1: "456 Ponderosa Ct.",
                   city: "Oakland",
                   state: "CA",
                   zip: "91234",
                 })
+                expected = {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382",
+                }
                 expect(actual).to match(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -437,18 +437,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = {
-                  "line_1" => "123 Main St.",
-                  "city" => "Hill Valley",
-                  "state" => "CA",
-                  "zip" => "90382",
-                }
                 actual = HashWithIndifferentAccess.new({
                   line_1: "456 Ponderosa Ct.",
                   city: "Oakland",
                   state: "CA",
                   zip: "91234",
                 })
+                expected = {
+                  "line_1" => "123 Main St.",
+                  "city" => "Hill Valley",
+                  "state" => "CA",
+                  "zip" => "90382",
+                }
                 expect(actual).to match(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -498,18 +498,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  line_1: "456 Ponderosa Ct.",
-                  city: "Oakland",
-                  state: "CA",
-                  zip: "91234",
-                })
                 actual = {
                   line_1: "123 Main St.",
                   city: "Hill Valley",
                   state: "CA",
                   zip: "90382",
                 }
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
                 expect(actual).to match(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -555,18 +555,18 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  line_1: "456 Ponderosa Ct.",
-                  city: "Oakland",
-                  state: "CA",
-                  zip: "91234",
-                })
                 actual = {
                   "line_1" => "123 Main St.",
                   "city" => "Hill Valley",
                   "state" => "CA",
                   "zip" => "90382",
                 }
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
                 expect(actual).to match(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -614,16 +614,6 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  shipments: [
-                    HashWithIndifferentAccess.new({
-                      estimated_delivery: HashWithIndifferentAccess.new({
-                        from: '2019-05-06',
-                        to: '2019-05-06'
-                      })
-                    })
-                  ]
-                })
                 actual = {
                   shipments: [
                     {
@@ -634,6 +624,16 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
                     }
                   ]
                 }
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
                 expect(actual).to match(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)
@@ -681,16 +681,6 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
           it "produces the correct output" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
-                expected = HashWithIndifferentAccess.new({
-                  shipments: [
-                    HashWithIndifferentAccess.new({
-                      estimated_delivery: HashWithIndifferentAccess.new({
-                        from: '2019-05-06',
-                        to: '2019-05-06'
-                      })
-                    })
-                  ]
-                })
                 actual = {
                   'shipments' => [
                     {
@@ -701,6 +691,16 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
                     }
                   ]
                 }
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
                 expect(actual).to match(expected)
               TEST
               program = make_program(snippet, color_enabled: color_enabled)

data/spec/support/shared_examples/key.rb

@@ -3,15 +3,15 @@ shared_examples_for "a matcher that supports a toggleable key" do
     it "produces the key" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
-          expected = [
+          actual = [
             "Afghanistan",
             "Aland Islands",
-            "Albania"
+            "Australia"
           ]
-          actual = [
+          expected = [
             "Afghanistan",
             "Aland Islands",
-            "Australia"
+            "Albania"
           ]
           expect(actual).to #{matcher}(expected)
         TEST
@@ -19,7 +19,7 @@ shared_examples_for "a matcher that supports a toggleable key" do
           make_plain_test_program(
             snippet,
             color_enabled: color_enabled,
-            configuration: {
+            super_diff_configuration: {
               key_enabled: true
             }
           )
@@ -64,15 +64,15 @@ shared_examples_for "a matcher that supports a toggleable key" do
     it "does not produce the key" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
-          expected = [
+          actual = [
             "Afghanistan",
             "Aland Islands",
-            "Albania"
+            "Australia"
           ]
-          actual = [
+          expected = [
             "Afghanistan",
             "Aland Islands",
-            "Australia"
+            "Albania"
           ]
           expect(actual).to #{matcher}(expected)
         TEST
@@ -80,7 +80,7 @@ shared_examples_for "a matcher that supports a toggleable key" do
           make_plain_test_program(
             snippet,
             color_enabled: color_enabled,
-            configuration: {
+            super_diff_configuration: {
               key_enabled: false
             }
           )

data/spec/unit/active_support/object_inspection_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+
+RSpec.describe SuperDiff, type: :unit do
+  describe ".inspect_object",
+           "for ActiveSupport objects",
+           active_support: true do
+    context "given an ActiveSupport::OrderedOptions object" do
+      context "given as_lines: false" do
+        it "returns an inspected version of the object" do
+          string =
+            described_class.inspect_object(
+              ::ActiveSupport::OrderedOptions[name: "Bob", age: 42],
+              as_lines: false
+            )
+          expect(string).to eq(%(#<OrderedOptions { name: "Bob", age: 42 }>))
+        end
+      end
+
+      context "given as_lines: true" do
+        it "returns an inspected version of the object as multiple Lines" do
+          tiered_lines =
+            described_class.inspect_object(
+              ::ActiveSupport::OrderedOptions[name: "Bob", age: 42],
+              as_lines: true,
+              type: :delete,
+              indentation_level: 1
+            )
+          expect(tiered_lines).to match(
+            [
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 1,
+                value: "#<OrderedOptions {",
+                collection_bookend: :open
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                prefix: "name: ",
+                value: "\"Bob\"",
+                add_comma: true
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                prefix: "age: ",
+                value: "42",
+                add_comma: false
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 1,
+                value: "}>",
+                collection_bookend: :close
+              )
+            ]
+          )
+        end
+      end
+    end
+
+    context "given a DateTime object" do
+      context "given as_lines: false" do
+        it "returns a representation of the datetime on a single line" do
+          inspection =
+            described_class.inspect_object(
+              DateTime.new(2021, 5, 5, 10, 23, 28.123456789123, "-05:00"),
+              as_lines: false
+            )
+          expect(inspection).to eq(
+            "#<DateTime 2021-05-05 10:23:28+(123456789/1000000000) -05:00 (-05:00)>"
+          )
+        end
+      end
+
+      context "given as_lines: true" do
+        it "returns a representation of the datetime across multiple lines" do
+          inspection =
+            described_class.inspect_object(
+              DateTime.new(2021, 5, 5, 10, 23, 28.1234567891, "-05:00"),
+              as_lines: true,
+              type: :delete,
+              indentation_level: 1
+            )
+          expect(inspection).to match(
+            [
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 1,
+                value: "#<DateTime {",
+                add_comma: false,
+                collection_bookend: :open
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "year: 2021",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "month: 5",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "day: 5",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "hour: 10",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "min: 23",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "sec: 28",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "subsec: (123456789/1000000000)",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "zone: \"-05:00\"",
+                add_comma: true,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 2,
+                value: "utc_offset: -18000",
+                add_comma: false,
+                collection_bookend: nil
+              ),
+              an_object_having_attributes(
+                type: :delete,
+                indentation_level: 1,
+                value: "}>",
+                add_comma: false,
+                collection_bookend: :close
+              )
+            ]
+          )
+        end
+      end
+    end
+  end
+end

data/spec/unit/rspec/matchers/raise_error_spec.rb

@@ -5,39 +5,71 @@ RSpec.describe "RSpec's `raise_error` matcher" do
     context "given only an exception class" do
       it "returns the correct output" do
         expect(raise_error(RuntimeError).description).to eq(
-          "raise error #<RuntimeError>"
+          "raise a kind of RuntimeError"
         )
       end
     end
 
-    context "with only a message (and assuming a RuntimeError)" do
+    context "given only a string message" do
       it "returns the correct output" do
         expect(raise_error("hell").description).to eq(
-          %|raise error #<Exception "hell">|
+          %|raise a kind of Exception with message "hell"|
         )
       end
     end
 
-    context "with regular expression as message (and assuming a RuntimeError)" do
+    context "given only a regexp message" do
       it "returns the correct output" do
-        expect(raise_error(/hell/).description).to eq(
-          "raise error #<Exception /hell/>"
+        expect(raise_error(/hell/i).description).to eq(
+          "raise a kind of Exception with message matching /hell/i"
         )
       end
     end
 
-    context "with both an exception and a message" do
+    context "given both an exception and string message" do
       it "returns the correct output" do
         expect(raise_error(RuntimeError, "hell").description).to eq(
-          %|raise error #<RuntimeError "hell">|
+          %|raise a kind of RuntimeError with message "hell"|
         )
       end
     end
 
-    context "with an exception and a regular expression as message" do
+    context "given both an exception and regexp message" do
       it "returns the correct output" do
-        expect(raise_error(RuntimeError, /hell/).description).to eq(
-          "raise error #<RuntimeError /hell/>"
+        expect(raise_error(RuntimeError, /hell/i).description).to eq(
+          "raise a kind of RuntimeError with message matching /hell/i"
+        )
+      end
+    end
+
+    context "given a simple RSpec matcher" do
+      it "returns the correct output" do
+        expect(raise_error(a_kind_of(RuntimeError)).description).to eq(
+          "raise #<a kind of RuntimeError>"
+        )
+      end
+    end
+
+    context "given a simple RSpec matcher and string message" do
+      it "returns the correct output" do
+        expect(raise_error(a_kind_of(RuntimeError), "boo").description).to eq(
+          'raise #<a kind of RuntimeError> with message "boo"'
+        )
+      end
+    end
+
+    context "given a simple RSpec matcher and regexp message" do
+      it "returns the correct output" do
+        expect(raise_error(a_kind_of(RuntimeError), /boo/i).description).to eq(
+          "raise #<a kind of RuntimeError> with message matching /boo/i"
+        )
+      end
+    end
+
+    context "given a compound RSpec matcher" do
+      it "returns the correct output" do
+        expect(raise_error(a_kind_of(Array).or eq(true)).description).to eq(
+          "raise #<a kind of Array or eq true>"
         )
       end
     end