rspec-json_matchers 0.1.0.alpha.1 → 0.1.0.alpha.2

data/lib/rspec/json_matchers/matchers.rb

@@ -1,6 +1,6 @@
-require_relative  "matchers/be_json_matcher"
-require_relative  "matchers/be_json_with_content_matcher"
-require_relative  "matchers/be_json_with_sizes_matcher"
+require_relative "matchers/be_json_matcher"
+require_relative "matchers/be_json_with_content_matcher"
+require_relative "matchers/be_json_with_sizes_matcher"
 
 module RSpec
   module JsonMatchers

data/lib/rspec/json_matchers/matchers/be_json_matcher.rb

@@ -2,6 +2,8 @@ require "json"
 
 module RSpec
   module JsonMatchers
+    # Mixin Module to be included into RSpec
+    # Other files will define the same module and add methods to this module
     module Matchers
       # @api
       #
@@ -13,6 +15,8 @@ module RSpec
       end
 
       # @api private
+      #
+      # The implementation for {Matchers#be_json}
       class BeJsonMatcher
         attr_reader :actual
 
@@ -61,32 +65,38 @@ module RSpec
           "be a valid JSON string"
         end
 
-        # Failure message displayed when a positive example failed (e.g. using `should`)
+        # Failure message displayed when a positive example failed
+        # (e.g. using `should`)
         #
         # @return [String]
         def failure_message_for_positive
           "expected value to be parsed as JSON, but failed"
         end
-        alias :failure_message :failure_message_for_positive
+        alias_method :failure_message,
+          :failure_message_for_positive
 
-        # Failure message displayed when a negative example failed (e.g. using `should_not`)
+        # Failure message displayed when a negative example failed
+        # (e.g. using `should_not`)
         #
         # @return [String]
         def failure_message_for_negative
           "expected value not to be parsed as JSON, but succeeded"
         end
-        alias :failure_message_when_negated :failure_message_for_negative
+        alias_method :failure_message_when_negated,
+          :failure_message_for_negative
 
         private
 
         def has_parser_error?
-          !!@has_parser_error
+          @has_parser_error
         end
       end
     end
   end
 end
 
-# These files are required since the classes are only required on runtime, not load time
+# These files are required here
+# since the classes are only required
+# on runtime but not load time
 require_relative "be_json_with_content_matcher"
 require_relative "be_json_with_sizes_matcher"

data/lib/rspec/json_matchers/matchers/be_json_with_sizes_matcher.rb

@@ -13,7 +13,10 @@ module RSpec
         private
 
         def value_matching_proc
-          -> (expected, actual) { Expectations::Private::ArrayWithSize[expected].expect?(actual) }
+          lambda do |expected, actual|
+            Expectations::Private::ArrayWithSize[expected].
+              expect?(actual)
+          end
         end
       end
     end

data/lib/rspec/json_matchers/matchers/be_json_with_something_matcher.rb

@@ -12,15 +12,12 @@ module RSpec
       # @abstract
       #
       # Parent of matcher classes that requires {#at_path} & {#with_exact_keys}
-      # This is not merged with {BeJsonMatcher} since it should be able to be used alone
+      # This is not merged with {BeJsonMatcher}
+      # since it should be able to be used alone
       class BeJsonWithSomethingMatcher < BeJsonMatcher
         extend AbstractClass
 
-        attr_reader *[
-          :expected,
-          :path,
-          :with_exact_keys,
-        ]
+        attr_reader(*[:expected, :path, :with_exact_keys])
         alias_method :with_exact_keys?, :with_exact_keys
 
         def initialize(expected)
@@ -37,25 +34,28 @@ module RSpec
           !matches?(*args) && has_valid_path?
         end
 
-        def description
-          super
-        end
-
         # Override {BeJsonMatcher#actual}
         # It return actual object extracted by {#path}
-        # And also detect & set state for path error (either it's invalid or fails to extract)
+        # And also detect & set state for path error
+        # (either it's invalid or fails to extract)
         #
-        # @return [Object] extracted object but could be object in the middle when extraction failed
+        # @return [Object]
+        #   extracted object but could be object in the middle
+        #   when extraction failed
         def actual
           result = path.extract(super)
           has_path_error! if result.failed?
           result.object
         end
 
-        # Sets the path to be used for object, to avoid passing a deep nested {Hash} or {Array} as expectation
+        # Sets the path to be used for object,
+        # to avoid passing a deep nested
+        # {Hash} or {Array} as expectation
         # Defaults to "" (if this is not called)
+        #
         # The path uses period (".") as separator for parts
-        # (also period cannot be used as path name as a side-effect, but who does?)
+        # Also period cannot be used as path name as a side-effect
+        #
         # This does NOT raise error if the path is invalid
         # (like having 2 periods, 1 period at the start/end of string)
         # But it will fail the example with both `should` & `should_not`
@@ -78,39 +78,43 @@ module RSpec
         # makes the matcher to pass the example
         # when actual has more elements than expected and expectation passes
         #
-        # @param exactly [Boolean] whether the matcher should match keys in actual & expected exactly
+        # @param exactly [Boolean]
+        #   whether the matcher should match keys in actual & expected exactly
         #
         # @return (see #at_path)
         def with_exact_keys(exactly = true)
-          @with_exact_keys = !!exactly
+          @with_exact_keys = exactly
           self
         end
 
+        # Overrides {BeJsonMatcher#failure_message_for_positive}
         def failure_message_for_positive
           return super if has_parser_error?
-          return invalid_path_message unless has_valid_path?
-          return path_error_message if has_path_error?
-
-          inspection_messages(true)
+          failure_message_for(true)
         end
-        alias :failure_message :failure_message_for_positive
 
+        # Overrides {BeJsonMatcher#failure_message_for_negative}
         def failure_message_for_negative
           return super if has_parser_error?
+          failure_message_for(false)
+        end
+
+        private
+
+        def failure_message_for(should_match)
           return invalid_path_message unless has_valid_path?
           return path_error_message if has_path_error?
 
-          inspection_messages(false)
+          inspection_messages(should_match)
         end
-        alias :failure_message_when_negated :failure_message_for_negative
-
-        private
 
         # @return [Bool] Whether `expected` & `parsed` are "equal"
         def expected_and_actual_matched?
           extracted_actual = actual
           return false if has_path_error?
-          result = comparer_klass.new(extracted_actual, expected, reasons, value_matching_proc).compare
+          result = comparer_klass.
+            new(extracted_actual, expected, reasons, value_matching_proc).
+            compare
 
           result.matched?.tap do |matched|
             @reasons = result.reasons unless matched
@@ -122,18 +126,24 @@ module RSpec
         end
 
         def inspection_messages(should_match)
-          prefix = !!should_match ? nil : "not"
-
-          messages = [
-            ["expected", prefix, "to match:"].compact.map(&:strip).join(" "),
+          [
+            ["expected", inspection_messages_prefix(should_match), "to match:"].
+              compact.map(&:strip).join(" "),
             expected.awesome_inspect(indent: -2),
             "",
             "actual:",
             actual.awesome_inspect(indent: -2),
             "",
-          ]
-          messages.push "reason/path: #{reasons.reverse.join(".")}" unless reasons.empty?
-          messages.join("\n")
+            inspection_message_for_reason,
+          ].join("\n")
+        end
+
+        def inspection_messages_prefix(should_match)
+          should_match ? nil : "not"
+        end
+
+        def inspection_message_for_reason
+          reasons.any? ? "reason/path: #{reasons.reverse.join('.')}" : nil
         end
 
         def original_actual
@@ -141,7 +151,7 @@ module RSpec
         end
 
         def has_path_error?
-          !!@has_path_error
+          @has_path_error
         end
 
         def has_path_error!
@@ -150,8 +160,8 @@ module RSpec
 
         # For both positive and negative
         def path_error_message
-          %Q|path "#{path}" does not exists in actual: |
           [
+            %(path "#{path}" does not exists in actual: ),
             original_actual.awesome_inspect(indent: -2),
           ].join("\n")
         end
@@ -162,11 +172,15 @@ module RSpec
 
         # For both positive and negative
         def invalid_path_message
-          %Q|path "#{path}" is invalid|
+          %(path "#{path}" is invalid)
         end
 
         def comparer_klass
-          with_exact_keys? ? Comparers::ExactKeysComparer : Comparers::IncludeKeysComparer
+          if with_exact_keys?
+            Comparers::ExactKeysComparer
+          else
+            Comparers::IncludeKeysComparer
+          end
         end
       end
     end

data/lib/rspec/json_matchers/utils/collection_keys_extractor.rb

@@ -25,9 +25,10 @@ module RSpec
         end
 
         def extract
-          COLLECTION_TYPE_TO_VALUE_EXTRACTION_PROC_MAP.fetch(collection.class) do
-            raise TypeError
-          end.call(collection)
+          COLLECTION_TYPE_TO_VALUE_EXTRACTION_PROC_MAP.
+            fetch(collection.class) do
+              fail TypeError
+            end.call(collection)
         end
       end
     end

data/lib/rspec/json_matchers/utils/key_path/extraction.rb

@@ -0,0 +1,149 @@
+require_relative "path"
+
+module RSpec
+  module JsonMatchers
+    module Utils
+      # @api private
+      module KeyPath
+        # Represents an extractor that performs the extraction
+        # with a {#path} & {#object}
+        class Extraction
+          # Create a new extractor with the "source object"
+          # and the path to be used for extracting our target object
+          #
+          # @param object [Object]
+          #   The source object to extract our target object from
+          # @param path [String, Path]
+          #   the path of target object
+          #   Will convert into {Path}
+          #
+          # @see JsonMatchers::Matchers::BeJsonWithSomethingMatcher#at_path
+          def initialize(object, path)
+            @object = object
+            @path = KeyPath::Path.new(path)
+
+            @failed = false
+          end
+
+          # Actually perform the extraction and return the result
+          # Since the object could be falsy,
+          # an object of custom class is returned instead of the object only
+          #
+          # Assume the path to be valid
+          #
+          # @return (see Path#extract)
+          def extract
+            path.each_path_part do |path_part|
+              result = extract_object_with_path_part(path_part)
+              return Result.new(object, false) if result.failed?
+
+              self.object = result.object
+            end
+
+            Result.new(object, true)
+          end
+
+          private
+
+          attr_accessor(*[
+            :object,
+          ])
+          attr_reader(*[
+            :path,
+            :failed,
+          ])
+          alias_method :failed?, :failed
+
+          # @param path_part [String]
+          #   One part of {#path}
+          def extract_object_with_path_part(path_part)
+            ExtractionWithOnePathPart.new(object, path_part).extract
+          end
+
+          def fail!
+            @failed = true
+            self
+          end
+
+          # @api private
+          #
+          # Internal implementation for an extraction operation with
+          # only one part of the path
+          class ExtractionWithOnePathPart
+            # Create a new extractor with the "source object"
+            # and the path to be used for extracting our target object
+            #
+            # @param object [Object]
+            #   The source object to extract our target object from
+            # @param path_part [String]
+            #   a part of {KeyPath::Path} of target object
+            def initialize(object, path_part)
+              @object = object
+              @path_part = path_part
+            end
+
+            # Actually perform the extraction and return the result
+            # Since the object could be falsy,
+            # an object of custom class is returned instead of the object only
+            #
+            # @return (see Extraction#extract)
+            def extract
+              case object
+              when Hash
+                extract_object_from_hash
+              when Array
+                extract_object_from_array
+              else
+                # Disallow non JSON collection type
+                Result.new(object, false)
+              end
+            end
+
+            private
+
+            def extract_object_from_hash
+              # Allow nil as object, but disallow key to be absent
+              return Result.new(object, false) unless object.key?(path_part)
+
+              Result.new(object.fetch(path_part), true)
+            end
+
+            def extract_object_from_array
+              index = path_part.to_i
+              # Disallow index to be out of range
+              # Disallow negative number as index
+              unless (path_part =~ /\A\d+\z/) && index < object.size
+                return Result.new(object, false)
+              end
+
+              Result.new(object.slice(index), true)
+            end
+
+            attr_accessor(*[
+              :object,
+            ])
+            attr_reader(*[
+              :path_part,
+            ])
+          end
+
+          # @api private
+          #
+          # Only as a value object for internal communication
+          class Result
+            attr_reader :object, :successful
+
+            def initialize(object, successful)
+              @object = object
+              @successful = successful
+            end
+
+            def failed?
+              !successful
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/json_matchers/utils/key_path/path.rb

@@ -1,31 +1,37 @@
-require_relative "extraction_result"
-require_relative "extractor"
+require_relative "extraction"
 
 module RSpec
   module JsonMatchers
     module Utils
       # @api private
       module KeyPath
+        # Represents a path pointing to an element
+        # of a {Hash} or {Array}
         class Path
           # The "path part" separator
           # Period is used since it's the least used char as part of a key name
           # (it can never by used for index anyway)
-          # As a side effect this char CANNOT be used, escaping is not planned to be added
+          # As a side effect this char CANNOT be used,
+          # escaping is not planned to be added
           PATH_PART_SPLITTER = ".".freeze
           # The regular expression for checking "invalid" path
           # The separator should NOT at the start/end of the string,
           # or repeating itself without other chars in between
-          INVALID_PATH_REGEX = %r_(
+          INVALID_PATH_REGEX = /
+          (
           ^#{Regexp.escape(PATH_PART_SPLITTER)}
           |
           #{Regexp.escape(PATH_PART_SPLITTER)}{2,}
           |
           #{Regexp.escape(PATH_PART_SPLITTER)}$
-          )_x.freeze
+          )
+          /x.freeze
 
           # Creates a {Path}
-          # with a {String} (mainly from external) (will store it internally)
-          # or a {Path} (mainly from internal) (will get and assign the string path it internally)
+          # with a {String} (mainly from external)
+          # (will store it internally)
+          # or a {Path} (mainly from internal)
+          # (will get and assign the string path it internally)
           #
           # @note
           #   It does not copy the string object since there is not need
@@ -43,7 +49,7 @@ module RSpec
             when String
               @string_path = path
             else
-              raise TypeError, "Only String and Path is expected"
+              fail TypeError, "Only String and Path is expected"
             end
           end
 
@@ -69,11 +75,11 @@ module RSpec
           # @param object [Object]
           #   The "source object" to extract our "target object" from
           #
-          # @return [ExtractionResult] The result of object extraction
+          # @return [Extraction::Result] The result of object extraction
           def extract(object)
-            return ExtractionResult.new(object, true) if empty?
-            return ExtractionResult.new(object, false) if invalid?
-            Extractor.new(object, self).extract
+            return Extraction::Result.new(object, true) if empty?
+            return Extraction::Result.new(object, false) if invalid?
+            Extraction.new(object, self).extract
           end
 
           protected