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

data/lib/rspec/json_matchers/comparers/comparison_result.rb

@@ -14,7 +14,7 @@ module RSpec
         end
 
         def matched?
-          !!@matched
+          @matched
         end
       end
     end

data/lib/rspec/json_matchers/comparers/exact_keys_comparer.rb

@@ -12,15 +12,15 @@ module RSpec
 
         # @note with side effect on `#reasons`
         def has_matched_keys?
-          actual_keys = Utils::CollectionKeysExtractor.extract(actual)
-          expected_keys = Utils::CollectionKeysExtractor.extract(expected)
           (actual_keys == expected_keys).tap do |success|
-            unless success
-              diff_keys = (actual_keys - expected_keys) + (expected_keys - actual_keys)
-              reasons.push(diff_keys.awesome_inspect)
-            end
+            reasons.push(diff_keys.awesome_inspect) unless success
           end
         end
+
+        def diff_keys
+          (actual_keys - expected_keys) +
+            (expected_keys - actual_keys)
+        end
       end
     end
   end

data/lib/rspec/json_matchers/comparers/include_keys_comparer.rb

@@ -12,15 +12,14 @@ module RSpec
 
         # @note with side effect on `#reasons`
         def has_matched_keys?
-          actual_keys = Utils::CollectionKeysExtractor.extract(actual)
-          expected_keys = Utils::CollectionKeysExtractor.extract(expected)
           (expected_keys.subset?(actual_keys)).tap do |success|
-            unless success
-              diff_keys = (expected_keys - actual_keys)
-              reasons.push(diff_keys.awesome_inspect)
-            end
+            reasons.push(diff_keys.awesome_inspect) unless success
           end
         end
+
+        def diff_keys
+          expected_keys - actual_keys
+        end
       end
     end
   end

data/lib/rspec/json_matchers/expectation.rb

@@ -3,7 +3,8 @@ require "abstract_class"
 module RSpec
   module JsonMatchers
     # Represents an expectation of an object (usually called `expected`)
-    # Built to avoid {Object#===} usage like other matcher gems, like `rspec-json_matcher`
+    # Built to avoid {Object#===} usage like other matcher gems,
+    # like `rspec-json_matcher`
     # Actually `rspec-mocks` `3.x` also uses it, but only internally
     #
     # @api
@@ -11,18 +12,24 @@ module RSpec
     #   But only used for this gem
     # @abstract
     #   This class MUST be used after being inherited
-    #   Subclasses MUST override {#expect?} to allow this gem to determine the test result
+    #   Subclasses MUST override {#expect?}
+    #   to allow this gem to determine the test result
     class Expectation
       extend AbstractClass
 
+      # Determine the value passed in
+      # is "expected" by self or not
+      # And return the result
+      #
       # @abstract
-      #   This method MUST be overridden to allow this gem to determine the test result
+      #   This method MUST be overridden
+      #   to allow this gem to determine the test result
       #
-      # @param value [Object] actual value to be evaluated
+      # @param _value [Object] actual value to be evaluated
       #
       # @return [Bool] Whether the `value` is expected
-      def expect?(value)
-        raise NotImplementedError
+      def expect?(_value)
+        fail NotImplementedError
       end
 
       class << self
@@ -35,30 +42,7 @@ module RSpec
         #
         # @return [Expectation]
         def build(value)
-          return value if value.is_a?(self)
-
-          if value.is_a?(Regexp)
-            return Expectations::Private::MatchingRegexp[value]
-          end
-
-          if value.is_a?(Range)
-            return Expectations::Private::InRange[value]
-          end
-
-          if value.respond_to?(:call)
-            return Expectations::Private::SatisfyingCallable[value]
-          end
-
-          if value.is_a?(Class)
-            # Subclass
-            # See http://ruby-doc.org/core-2.2.2/Module.html#method-i-3C
-            if value < Expectations::Core::SingletonExpectation
-              return value::INSTANCE
-            end
-            return Expectations::Private::KindOf[value]
-          end
-
-          Expectations::Private::Eq[value]
+          Builder.new(value).build
         end
         # @api private
         #
@@ -67,7 +51,73 @@ module RSpec
         # @return [Array<Expectation>]
         # @see .build
         def build_many(values)
-          values.flat_map{|v| build(v) }
+          values.flat_map { |v| build(v) }
+        end
+      end
+
+      # @api private
+      #
+      # Represents a builder that
+      # returns a {Expectation} object from an input object
+      class Builder
+        # Creates a bullder with an object that
+        # might or might not be a {Expectation} object
+        #
+        # @param object [Object]
+        #   any object that should be "built"
+        #   into a {Expectation} object
+        def initialize(object)
+          @object = object
+        end
+
+        # Create and return a {Expectation} object
+        # according to one of the following
+        #   - the class of object
+        #   - does the object respond to `#call`
+        #   - the ancestors of the object (when it's a class)
+        #
+        # @return [Expectation] a {Expectation} object
+        def build
+          return object if object.is_a?(Expectation)
+          return expectation_by_class unless expectation_by_class.nil?
+          return expectation_for_call if object.respond_to?(:call)
+          return expectation_by_ancestors if object.is_a?(Class)
+
+          Expectations::Private::Eq[object]
+        end
+
+        private
+
+        OBJECT_CLASS_TO_EXPECTATION_HASH = {
+          Regexp => -> (obj) { Expectations::Private::MatchingRegexp[obj] },
+          Range => -> (obj) { Expectations::Private::InRange[obj] },
+        }.freeze
+        private_constant :OBJECT_CLASS_TO_EXPECTATION_HASH
+
+        attr_reader(*[:object])
+
+        def expectation_by_class
+          if instance_variable_defined?(:@expectation_by_object_class)
+            return @expectation_by_object_class
+          end
+
+          proc = OBJECT_CLASS_TO_EXPECTATION_HASH[object.class]
+          return nil if proc.nil?
+
+          proc.call(object)
+        end
+
+        def expectation_by_ancestors
+          # Subclass
+          # See http://ruby-doc.org/core-2.2.2/Module.html#method-i-3C
+          if object < Expectations::Core::SingletonExpectation
+            return object::INSTANCE
+          end
+          Expectations::Private::KindOf[object]
+        end
+
+        def expectation_for_call
+          Expectations::Private::SatisfyingCallable[object]
         end
       end
     end

data/lib/rspec/json_matchers/expectations/abstract.rb

@@ -6,12 +6,14 @@ module RSpec
   module JsonMatchers
     module Expectations
       # @api private
-      #   All classes within module should NOT be able to be used directly / extended
+      #   All classes within module
+      #   should NOT be able to be used directly / extended
       #
       # Classes in this namespace are depending on {Core}
       # and depended by some classes in {Expectations::Mixins::BuiltIn}
       # They are all abstract too, thus the naming, but might change
-      # This namespace is created is to avoid require order problem when putting classes here in {Private}
+      # This namespace is created is to avoid require order problem
+      # when putting classes here in {Private}
       module Abstract
         # @abstract
         #   Only for reducing code duplication
@@ -29,7 +31,6 @@ module RSpec
             value.is_a?(Numeric)
           end
         end
-
       end
     end
   end

data/lib/rspec/json_matchers/expectations/core.rb

@@ -14,9 +14,11 @@ module RSpec
       module Core
         # @abstract
         #   This class MUST be used after being inherited
-        #   Subclasses will have a constant `INSTANCE` storing the only instance of that class
+        #   Subclasses will have a constant `INSTANCE`
+        #   storing the only instance of that class
         # @note
-        #   This class assumed descendants to NOT override {.inherited} or call `super` if overridden
+        #   This class assumed descendants to NOT
+        #   override {.inherited} or call `super` if overridden
         #   Otherwise the constant `INSTANCE` won't work
         # @note
         #   The constant `INSTANCE` will be referred with namespace,
@@ -69,22 +71,22 @@ module RSpec
           # But only 1 argument is accepted
           def self.[](*values)
             unless values.size == EXPECTED_VALUE_SIZE
-              raise ArgumentError, "Exactly #{EXPECTED_VALUE_SIZE} argument is required"
+              fail(
+                ArgumentError,
+                "Exactly #{EXPECTED_VALUE_SIZE} argument is required",
+              )
             end
             super
           end
         end
 
-        # Takes any number of objects and converts into expectation objects (if not already)
+        # Takes any number of objects and
+        # converts into expectation objects (if not already)
         #
         # @abstract
         class CompositeExpectation < CallableExpectation
           extend AbstractClass
 
-          private
-          attr_reader :expectations
-          public
-
           # (see CallableExpectation.[])
           # Also all values will be converted into expectations
           def self.[](*values)
@@ -93,6 +95,8 @@ module RSpec
 
           private
 
+          attr_reader :expectations
+
           def initialize(expectations)
             @expectations = expectations
           end

data/lib/rspec/json_matchers/expectations/mixins/built_in.rb

@@ -9,7 +9,8 @@ module RSpec
       # @api
       #   The modules under this module can be included (in RSpec)
       #
-      # If this gem or extensions gems decide to add different groups of expectations classes
+      # If this gem or extensions gems decide to
+      # add different groups of expectations classes
       # Which aim to be included in example groups
       # They should add the namespace modules here
       module Mixins
@@ -22,7 +23,8 @@ module RSpec
         module BuiltIn
           # Whatever the value is, it just passes
           # A more verbose solution than passing {Object} in
-          # (That also works since everything parsed by {JSON} inherits from {Object})
+          # (That also works since everything parsed
+          # by {JSON} inherits from {Object})
           #
           # @example
           #   { key_with_unstable_content => Anything }
@@ -61,22 +63,20 @@ module RSpec
             end
           end
 
-          # Takes exactly one object and converts to an expectation object (if not already)
+          # Takes exactly one object and converts to
+          # an expectation object (if not already)
           # Validates `value` to be {Array}
           # And uses stored expectation for checking all elements of `value`
           class ArrayOf < Expectations::Core::SingleValueCallableExpectation
-            private
-            attr_reader :children_elements_expectation
-            public
-
             def expect?(value)
               value.is_a?(Array) &&
                 (empty_allowed? || !value.empty?) &&
-                value.all? {|v| children_elements_expectation.expect?(v) }
+                value.all? { |v| children_elements_expectation.expect?(v) }
             end
 
             # {Enumerable#all?} returns `true` when collection is empty
-            # So this method can be called to signal the expectation to do or do not expect an empty collection
+            # So this method can be called to signal the expectation to
+            # do or do not expect an empty collection
             #
             # @param allow [Boolean]
             #   optional
@@ -84,7 +84,7 @@ module RSpec
             #
             # @return [ArrayOf] the matcher itself
             def allow_empty(allow = true)
-              @empty_allowed = !!allow
+              @empty_allowed = allow
               self
             end
 
@@ -97,13 +97,15 @@ module RSpec
 
             private
 
+            attr_reader :children_elements_expectation
+
             def initialize(value)
               @children_elements_expectation = Expectation.build(value)
               @empty_allowed = true
             end
 
             def empty_allowed?
-              !!@empty_allowed
+              @empty_allowed
             end
           end
 
@@ -127,6 +129,15 @@ module RSpec
             end
           end
 
+          # (see AnyOf)
+          # It will pass regardless of {#expectations}
+          # if the value is `nil`
+          class NullableOf < AnyOf
+            def expect?(value)
+              value.nil? || super
+            end
+          end
+
           # Takes any number of {Integer} or {Range} (if not already)
           # Validates `value` to be {Array}
           # And the size matches any value passed in
@@ -134,7 +145,8 @@ module RSpec
           # @note
           #   For behaviour of "and" (which should be a rare case)
           #   Combine {AllOf} & {ArrayWithSize}
-          #   Or raise an issue to add support for switching to "and" with another method call
+          #   Or raise an issue to add support for
+          #   switching to "and" with another method call
           class ArrayWithSize < AnyOf
             # `Fixnum` & `Bignum` will be returned instead of `Integer`
             # in `#class` for numbers
@@ -149,7 +161,7 @@ module RSpec
               # Overrides {Expectation.build}
               def build(value)
                 expectation_classes_mappings.fetch(value.class) do
-                  -> (_) { raise ArgumentError, <<-ERR }
+                  -> (_) { fail ArgumentError, <<-ERR }
                     Expected expection(s) to be kind of
                     #{expectation_classes_mappings.keys.inspect}
                     but found #{value.inspect}

data/lib/rspec/json_matchers/expectations/private.rb

@@ -7,10 +7,13 @@ module RSpec
   module JsonMatchers
     module Expectations
       # @api private
-      #   All classes within module should NOT be able to be used directly / extended
+      #   All classes within module should NOT be able
+      #   to be used directly / extended
       #
-      # All classes in this module are internal expectations used when non-expectation object/class is passed in
-      # Extension gems should have their own namespace and should NOT add new classes to this namespace
+      # All classes in this module are internal expectations used
+      # when non-expectation object/class is passed in
+      # Extension gems should have their own namespace and
+      # should NOT add new classes to this namespace
       # Classes here have dependency on {Core} & {Mixins::BuiltIn}
       #
       # TODO: Remove dependency on {Mixins::BuiltIn}
@@ -21,16 +24,14 @@ module RSpec
         # Takes exactly one object
         # Use stored value & `==` for checking `value`
         class Eq < Core::SingleValueCallableExpectation
-          private
-          attr_reader :expected_value
-          public
-
           def expect?(value)
             value == expected_value
           end
 
           private
 
+          attr_reader :expected_value
+
           def initialize(value)
             @expected_value = value
           end
@@ -50,18 +51,18 @@ module RSpec
           EXPECTED_CLASS = Class
           private_constant :EXPECTED_CLASS
 
-          private
-          attr_reader :expected_class
-          public
-
           def expect?(value)
             value.is_a?(expected_class)
           end
 
           private
 
+          attr_reader :expected_class
+
           def initialize(value)
-            raise ArgumentError, "a #{EXPECTED_CLASS} is required" unless value.is_a?(EXPECTED_CLASS)
+            unless value.is_a?(EXPECTED_CLASS)
+              fail ArgumentError, "a #{EXPECTED_CLASS} is required"
+            end
             @expected_class = value
           end
         end
@@ -75,18 +76,18 @@ module RSpec
           EXPECTED_CLASS = Range
           private_constant :EXPECTED_CLASS
 
-          private
-          attr_reader :range
-          public
-
           def expect?(value)
             range.cover?(value)
           end
 
           private
 
+          attr_reader :range
+
           def initialize(value)
-            raise ArgumentError, "a #{EXPECTED_CLASS} is required" unless value.is_a?(EXPECTED_CLASS)
+            unless value.is_a?(EXPECTED_CLASS)
+              fail ArgumentError, "a #{EXPECTED_CLASS} is required"
+            end
             @range = value
           end
         end
@@ -100,20 +101,20 @@ module RSpec
           EXPECTED_CLASS = Regexp
           private_constant :EXPECTED_CLASS
 
-          private
-          attr_reader :regexp
-          public
-
           def expect?(value)
             # regex =~ string seems to be fastest
             # @see https://stackoverflow.com/questions/11887145/fastest-way-to-check-if-a-string-matches-or-not-a-regexp-in-ruby
-            value.is_a?(String) && !!(regexp =~ value)
+            value.is_a?(String) && regexp =~ value
           end
 
           private
 
+          attr_reader :regexp
+
           def initialize(value)
-            raise ArgumentError, "a #{EXPECTED_CLASS} is required" unless value.is_a?(EXPECTED_CLASS)
+            unless value.is_a?(EXPECTED_CLASS)
+              fail ArgumentError, "a #{EXPECTED_CLASS} is required"
+            end
             @regexp = value
           end
         end
@@ -124,18 +125,19 @@ module RSpec
         # Takes exactly one object
         # Use stored proc for checking `value`
         class SatisfyingCallable < Core::SingleValueCallableExpectation
-          private
-          attr_reader :callable
-          public
-
           def expect?(value)
             callable.call(value)
           end
 
           private
 
+          attr_reader :callable
+
           def initialize(value)
-            raise ArgumentError, "an object which respond to `:call` is required" unless value.respond_to?(:call)
+            unless value.respond_to?(:call)
+              fail ArgumentError,
+                "an object which respond to `:call` is required"
+            end
             @callable = value
           end
         end
@@ -154,24 +156,29 @@ module RSpec
         #   Used internally by a matcher method
         #
         # Comparing to {Expectations::Mixins::BuiltIn::ArrayWithSize}
-        # This also accepts `Hash` and `Array`, and return false for collection matching
+        # This also accepts `Hash` and `Array`
+        # and return false for collection matching
         class ArrayWithSize < Expectations::Mixins::BuiltIn::ArrayWithSize
           # `Fixnum` & `Bignum` will be returned instead of `Integer`
           # in `#class` for numbers
-          ADDITIONAL_EXPECTED_VALUE_CLASS_TO_EXPECTATION_CLASS_MAPPING = {
+          ADDITIONAL_EXPECTATION_CLASS_MAPPINGS = {
             Array   => -> (_) { Expectations::Private::Nothing::INSTANCE },
             Hash    => -> (_) { Expectations::Private::Nothing::INSTANCE },
           }.freeze
-          private_constant :ADDITIONAL_EXPECTED_VALUE_CLASS_TO_EXPECTATION_CLASS_MAPPING
+          private_constant :ADDITIONAL_EXPECTATION_CLASS_MAPPINGS
 
           class << self
             private
 
-            # Overrides {Expectations::Mixins::BuiltIn::ArrayWithSize.expectation_classes_mappings}
+            # Overrides
+            # {Expectations::Mixins::BuiltIn::ArrayWithSize.
+            # expectation_classes_mappings}
             #
             # @return [Hash]
             def expectation_classes_mappings
-              super.merge(ADDITIONAL_EXPECTED_VALUE_CLASS_TO_EXPECTATION_CLASS_MAPPING)
+              super.merge(
+                ADDITIONAL_EXPECTATION_CLASS_MAPPINGS,
+              )
             end
           end
         end