shape_of 1.2.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee7f353196efa5fe84c5b077228696920b0cfecc74c0f7da62ef18eaa15e4cd5
-  data.tar.gz: 4ae20130b4b1f2307755015f0bffcc6a82138ab6a75e81e8c71012e5c7926383
+  metadata.gz: 302fcc2359111f2a5ea57aa97fa6b686499fe2e93048ca204655989711157ee1
+  data.tar.gz: 8481cc4a6c1c709b680c6babbe2b5aa3335f3a689ec45c8bf24551b80c776f3e
 SHA512:
-  metadata.gz: a51dd81d6468c8cee82ad6a633eea7510950a475f8bd7d3bed251f88a4e029d7c5f6a557dc26e084706b17b4904a50485814814748c20aff4c1eb5de4fb3be66
-  data.tar.gz: ebdd687b4046fbd6bce79024f927aee2ef0e625776c4bfde98a4b12d12513b66d5a64c7df4a7871c75e249358ae1142f4c787c10d1ee4e23584951fd45b1e372
+  metadata.gz: 5319dce493532fccf310d7b2c52c53fad2699dab8c23d4a914a7a9754f8db22c336874005eca5a317ab60f185af6ac7057334388e7498760d70e93382a791ad8
+  data.tar.gz: dfaaedf3abcf1dd77c0830215a787a9e2a29d0f06b2db35fc592a28add9aa495344ed7e4c22f46370d840da490fc57b240225a72092d28fccf758df87467ef09

data/lib/shape_of.rb

@@ -84,37 +84,125 @@
 # hash_shape.shape_of?({ value: [{}] }) # => false
 # ```
 #
+require 'pp'
+
 module ShapeOf
+  # Used in Assertions, and can also be used separately. It is used to keep track of places where the shape of
+  # data does not match, so that you can have greater insight than just a simple true/false.
+  class Validator
+    attr_reader :shape, :object
+
+    def initialize(shape:, object:)
+      @current_error_key_nesting = [:base] # stack of the current error key.
+      @errors = {}
+      @object = object
+      @shape = shape
+
+      validate
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def errors
+      @errors[:base]
+    end
+
+    def error_message
+      errors.pretty_inspect
+    end
+
+    def add_error(message)
+      create_nested_error_structure
+
+      @errors.dig(*@current_error_key_nesting)[:errors] << message.dup
+    end
+
+    def push_key(key)
+      @current_error_key_nesting.push(key.dup)
+    end
+
+    def pop_key
+      @current_error_key_nesting.pop
+    end
+
+    private
+
+    def create_nested_error_structure
+      errors = @errors
+      @current_error_key_nesting.each do |key|
+        errors[key] ||= {}
+        errors = errors[key]
+      end
+      @errors.dig(*@current_error_key_nesting)[:errors] ||= []
+    end
+
+    def validate
+      shape.shape_of?(object, validator: self)
+    end
+  end
+
   # To be included in a MiniTest test class
   module Assertions
-    def assert_shape_of(object, shape)
+    # For backward compatibility, this is "off" by default, and the order in the assertions are reverse.
+    @proper_expected_actual_order = false
+    def self.use_proper_expected_actual_order!
+      @proper_expected_actual_order = true
+    end
+
+    def assert_shape_of(arg1, arg2)
+      shape = object = nil
+      if @proper_expected_actual_order
+        shape = arg1
+        object = arg2
+      else
+        shape = arg2
+        object = arg1
+      end
+
+      validator = nil
       if shape.respond_to? :shape_of?
-        assert_operator shape, :shape_of?, object
+        validator = Validator.new(shape: shape, object: object)
       elsif shape.instance_of? ::Array
-        assert_operator Array[shape.first], :shape_of?, object
+        validator = Validator.new(shape: Array[shape.first], object: object)
       elsif shape.instance_of? ::Hash
-        assert_operator Hash[shape], :shape_of?, object
+        validator = Validator.new(shape: Hash[shape], object: object)
       else
         raise TypeError, "Expected #{Shape.inspect}, an #{::Array.inspect}, or a #{::Hash.inspect} as the shape"
       end
+
+      assert validator.valid?, validator.error_message
     end
 
-    def refute_shape_of(object, shape)
+    def refute_shape_of(arg1, arg2)
+      shape = object = nil
+      if @proper_expected_actual_order
+        shape = arg1
+        object = arg2
+      else
+        shape = arg2
+        object = arg1
+      end
+
+      validator = nil
       if shape.respond_to? :shape_of?
-        refute_operator shape, :shape_of?, object
+        validator = Validator.new(shape: shape, object: object)
       elsif shape.instance_of? ::Array
-        refute_operator Array[shape.first], :shape_of?, object
+        validator = Validator.new(shape: Array[shape.first], object: object)
       elsif shape.instance_of? ::Hash
-        refute_operator Hash[shape], :shape_of?, object
+        validator = Validator.new(shape: Hash[shape], object: object)
       else
         raise TypeError, "Expected #{Shape.inspect}, an #{::Array.inspect}, or a #{::Hash.inspect} as the shape"
       end
+
+      refute validator.valid?, "#{shape} is shape_of? #{object}"
     end
   end
 
   # Generic shape which all shapes subclass from
   class Shape
-    def self.shape_of?(*)
+    def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
       raise NotImplementedError
     end
 
@@ -134,8 +222,11 @@ module ShapeOf
   class Array < Shape
     @internal_class = ::Array
 
-    def self.shape_of?(object)
-      object.instance_of? @internal_class
+    def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
+      is_instance_of = object.instance_of?(@internal_class)
+      validator.add_error(object.inspect + " is not instance of " + @internal_class.inspect) unless is_instance_of
+
+      is_instance_of
     end
 
     def self.[](shape)
@@ -156,20 +247,37 @@ module ShapeOf
           @class_name
         end
 
-        def self.shape_of?(array)
-          super && array.all? do |elem|
-            if @shape.respond_to? :shape_of?
-              @shape.shape_of? elem
+        def self.shape_of?(array, validator: Validator.new(shape: self, object: array))
+          return false unless super
+
+          idx = 0
+          each_is_shape_of = true
+          array.each do |elem|
+            validator.push_key("idx_#{idx}".to_sym)
+
+            is_shape_of = if @shape.respond_to? :shape_of?
+              @shape.shape_of?(elem, validator: validator)
             elsif @shape.is_a? ::Array
-              Array[@shape.first].shape_of? elem
+              Array[@shape.first].shape_of?(elem, validator: validator)
             elsif @shape.is_a? ::Hash
-              Hash[@shape].shape_of? elem
+              Hash[@shape].shape_of?(elem, validator: validator)
             elsif @shape.is_a? Class
-              elem.instance_of? @shape
+              is_instance_of = elem.instance_of?(@shape)
+              validator.add_error(elem.inspect + " is not instance of " + @shape.inspect) unless is_instance_of
+
+              is_instance_of
             else
-              elem == @shape
+              is_equal_to = elem == @shape
+              validator.add_error(elem.inspect " is not equal to (==) " + @shape.inspect) unless is_equal_to
+
+              is_equal_to
             end
+
+            validator.pop_key
+            idx += 1
+            each_is_shape_of &&= is_shape_of
           end
+          each_is_shape_of
         end
       end
     end
@@ -182,8 +290,11 @@ module ShapeOf
   class Hash < Shape
     @internal_class = ::Hash
 
-    def self.shape_of?(object)
-      object.instance_of? @internal_class
+    def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
+      is_instance_of = object.instance_of?(@internal_class)
+      validator.add_error(object.inspect + " is not instance of " + @internal_class.inspect) unless is_instance_of
+
+      is_instance_of
     end
 
     def self.[](shape = {})
@@ -206,32 +317,57 @@ module ShapeOf
           @class_name
         end
 
-        def self.shape_of?(hash)
+        def self.shape_of?(hash, validator: Validator.new(shape: self, object: hash))
           return false unless super
 
+          each_is_shape_of = true
           rb_hash = stringify_rb_hash_keys(hash)
 
           rb_hash.keys.each do |key|
-            return false unless @shape.key?(key)
+            has_key = @shape.key?(key)
+            unless has_key
+              validator.push_key(key)
+              validator.add_error("unexpected key")
+              validator.pop_key
+              each_is_shape_of = false
+            end
           end
 
           @shape.each do |key, shape|
-            return false unless rb_hash.key?(key) || shape.respond_to?(:required?) && !shape.required?
+            unless rb_hash.key?(key) || shape.respond_to?(:required?) && !shape.required?
+              validator.push_key(key)
+              validator.add_error("required key not present")
+              validator.pop_key
+              each_is_shape_of = false
+            end
           end
 
-          rb_hash.all? do |key, elem|
-            if @shape[key].respond_to? :shape_of?
-              @shape[key].shape_of? elem
-            elsif @shape[key].is_a? ::Array
-              Array[@shape[key].first].shape_of? elem
-            elsif @shape[key].is_a? ::Hash
-              Hash[@shape[key]].shape_of? elem
-            elsif @shape[key].is_a? Class
-              elem.instance_of? @shape[key]
+          rb_hash.each do |key, elem|
+            shape_elem = @shape[key]
+            validator.push_key(key)
+
+            is_shape_of = if shape_elem.respond_to? :shape_of?
+              shape_elem.shape_of?(elem, validator: validator)
+            elsif shape_elem.is_a? ::Array
+              Array[shape_elem.first].shape_of?(elem, validator: validator)
+            elsif shape_elem.is_a? ::Hash
+              Hash[shape_elem].shape_of?(elem, validator: validator)
+            elsif shape_elem.is_a? Class
+              is_instance_of = elem.instance_of?(shape_elem)
+              validator.add_error(elem.inspect + " is not instance of " + shape_elem.inspect) unless is_instance_of
+
+              is_instance_of
             else
-              elem == @shape[key]
+              is_equal_to = elem == shape_elem
+              validator.add_error(elem.inspect + " is not equal to (==) " + shape_elem.inspect) unless is_equal_to
+
+              is_equal_to
             end
+
+            validator.pop_key
+            each_is_shape_of &&= is_shape_of
           end
+          each_is_shape_of
         end
       end
     end
@@ -239,7 +375,7 @@ module ShapeOf
     private
 
     def self.stringify_rb_hash_keys(rb_hash)
-      rb_hash.to_a.map { |k, v| [k.to_s, v] }.to_h
+      rb_hash.transform_keys(&:to_s)
     end
   end
 
@@ -262,20 +398,36 @@ module ShapeOf
           @class_name
         end
 
-        def self.shape_of?(object)
-          @shapes.any? do |shape|
+        def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
+          is_any_shape_of_shape_or_hash_or_array = false
+          is_any_shape_of = @shapes.any? do |shape|
             if shape.respond_to? :shape_of?
-              shape.shape_of? object
+              is_any_shape_of_shape_or_hash_or_array ||= shape.shape_of?(object)
             elsif shape.is_a? ::Hash
-              Hash[shape].shape_of? object
+              is_any_shape_of_shape_or_hash_or_array ||= Hash[shape].shape_of?(object)
             elsif shape.is_a? ::Array
-              Array[shape].shape_of? object
+              is_any_shape_of_shape_or_hash_or_array ||= Array[shape].shape_of?(object)
             elsif shape.is_a? Class
-              object.instance_of? shape
+              object.instance_of?(shape)
             else
               object == shape
             end
           end
+
+          if !is_any_shape_of && !is_any_shape_of_shape_or_hash_or_array
+            shape_shapes = @shapes.select { |shape| shape.respond_to?(:shape_of?) }
+            class_shapes = @shapes.select do |shape|
+              !shape.respond_to?(:shape_of?) && !shape.is_a?(::Hash) && !shape.is_a?(::Array) && shape.is_a?(Class)
+            end
+            object_shapes = @shapes.select do |shape|
+              !shape.respond_to?(:shape_of?) && !shape.is_a?(::Hash) && !shape.is_a?(::Array) && !shape.is_a?(Class)
+            end
+            validator.add_error(object.inspect + " is not shape of any of (" + shape_shapes.map(&:inspect).join(", ") +
+                                ") or is not instance of any of (" + class_shapes.map(&:inspect).join(", ") +
+                                ") or is not equal to (==) any of (" + object_shapes.map(&:inspect).join(", ") + ")")
+          end
+
+          is_any_shape_of
         end
       end
     end
@@ -303,14 +455,15 @@ module ShapeOf
 
   # Anything matches unless key does not exist in the Hash.
   class Any < Shape
-    def self.shape_of?(object)
+    def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
       true
     end
   end
 
   # Only passes when the key does not exist in the Hash.
   class Nothing < Shape
-    def self.shape_of?(object)
+    def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
+      validator.add_error("key present when not allowed")
       false
     end
 
@@ -342,10 +495,15 @@ module ShapeOf
           @class_name
         end
 
-        def self.shape_of?(object)
-          raise TypeError, "expected #{String.inspect}, was instead #{object.inspect}" unless object.instance_of?(String)
+        def self.shape_of?(object, validator: Validator.new(shape: self, object: object))
+          unless object.instance_of?(String)
+            validator.add_error(object.inspect + " is not instance of " + String.inspect)
+            return false
+          end
 
-          @shape.match?(object)
+          does_regexp_match = @shape.match?(object)
+          validator.add_error(object.inspect + " does not match " + @shape.inspect) unless does_regexp_match
+          does_regexp_match
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shape_of
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 3.0.0
 platform: ruby
 authors:
 - John Isom
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-28 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -38,7 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
-description:
+description: 
 email: john@johnisom.dev
 executables: []
 extensions: []
@@ -49,7 +49,7 @@ homepage: https://github.com/johnisom/shape_of
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -64,8 +64,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.17
-signing_key:
+rubygems_version: 3.2.22
+signing_key: 
 specification_version: 4
 summary: A shape/type checker for Ruby objects.
 test_files: []