attributor 5.7 → 6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72e523c77927ca8972951fa08ca3d9171f7601053d2a6d2ead46da6a9a1e2c4b
-  data.tar.gz: d6e008f822dfd90cb035dfdf66fd52d9fbea8bba35f02073dd2363aa4714ec64
+  metadata.gz: 108abdb1d351f95b78cfae24b61bf8e5bf3943626d8badb691e28ce0df23c45d
+  data.tar.gz: 96f4e678e7bccb85526a7a3788aa2df538902200fcb50b49e0de3a36c5d3778d
 SHA512:
-  metadata.gz: 3404afef9afcc264b5394357c292155faa8ccf231e2f266b8e986d4234a16336a9d85b9e457d2bd16515bd01c95523460f1842dcdbde721d888dd3d80560c2b2
-  data.tar.gz: 65bc2b01956e42002e0b4a2e6fa54e93edd033dac3dae883225595f186b4f460823ffc82d32d5a6c9eba1a2ee7116325ca3d4af31e27f536462e6fd14fdc68fb
+  metadata.gz: 54217688f13fad04f249aa351062afd490dd3962278f7dbdcc5d31e05bd5df3151fc51a704208a1502d8d9cf67a2382ca10b85f331c577610223a39c7b96caa9
+  data.tar.gz: 8eb61d8a53f01d2529d1d2f15c77cd9b55a6a0f53f9a9f83db61ee87ae6091761c330ca026759146e05b73b43625fa5f51236e50a98cbee5aa55afe94b6f1c25

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Attributor Changelog
 
+## next
+
+## 6.0 (22/11/2021)
+- removed `required_if` support and all of the necessary code. 
+- changed the semantics of the `required:` option in attributes, to really mean if the "key" is required to be passed in or not (i.e., check if the key is null, not if its value is null)
+- Introduced a new option`null: true|false` to allow for the value of an attribute to be nullable or not when the attribute is passed in.
+  * The default behavior for an attribute nullability currently `null: false` (but it can be easily changed by overriding the `Attributor::Attribute.default_for_null` function to return `true`)
 ## 5.7 (1/7/2021)
 
 - added `custom_option` to Attributor::Attribute class, accepting a name and Attribute arguments that will be used to validate the option value(s) provided.

data/lib/attributor/attribute.rb

@@ -40,9 +40,7 @@ module Attributor
     # @block: code definition for struct attributes (nil for predefined types or leaf/simple types)
     def initialize(type, options = {}, &block)
       @type = Attributor.resolve_type(type, options, block)
-
-      @options = options
-      @options = @type.options.merge(@options) if @type.respond_to?(:options)
+      @options = @type.respond_to?(:options) ?  @type.options.merge(options) : options
 
       check_options!
     end
@@ -96,18 +94,16 @@ module Attributor
 
     def validate_type(value, context)
       # delegate check to type subclass if it exists
-      unless type.valid_type?(value)
-        msg = "Attribute #{Attributor.humanize_context(context)} received value: "
-        msg += "#{Attributor.errorize_value(value)} is of the wrong type "
-        msg += "(got: #{value.class.name}, expected: #{type.name})"
-        return [msg]
-      end
-      []
+      return [] if value.nil? || type.valid_type?(value)
+
+      msg = "Attribute #{Attributor.humanize_context(context)} received value: "
+      msg += "#{Attributor.errorize_value(value)} is of the wrong type "
+      msg += "(got: #{value.class.name}, expected: #{type.name})"
+      [msg]
     end
 
-    TOP_LEVEL_OPTIONS = [:description, :values, :default, :example, :required, :required_if, :custom_data].freeze
+    TOP_LEVEL_OPTIONS = [:description, :values, :default, :example, :required, :null, :custom_data].freeze
     INTERNAL_OPTIONS = [:dsl_compiler, :dsl_compiler_options].freeze # Options we don't want to expose when describing attributes
-    JSON_SCHEMA_UNSUPPORTED_OPTIONS = [ :required, :required_if ].freeze
     def describe(shallow=true, example: nil)
       description = { }
       # Clone the common options
@@ -228,78 +224,38 @@ module Attributor
       type.attributes if @type_has_attributes ||= type.respond_to?(:attributes)
     end
 
+    # Default value for a non-specified null: option 
+    def self.default_for_null
+      false
+    end
+
+    # It is only nullable if there is an explicit null: true (or if it's not passed/set, and the default is true)
+    def self.nullable_attribute?(options)
+      !options.key?(:null) ? default_for_null : options[:null]
+    end
+
     # Validates stuff and checks dependencies
     def validate(object, context = Attributor::DEFAULT_ROOT_CONTEXT)
       raise "INVALID CONTEXT!! #{context}" unless context
       # Validate any requirements, absolute or conditional, and return.
 
-      if object.nil? # == Attributor::UNSET
-        # With no value, we can only validate whether that is acceptable or not and return.
-        # Beyond that, no further validation should be done.
-        return validate_missing_value(context)
-      end
-
-      # TODO: support validation for other types of conditional dependencies based on values of other attributes
-
-      errors = validate_type(object, context)
-
-      # End validation if we don't even have the proper type to begin with
-      return errors if errors.any?
-
-      if options[:values] && !options[:values].include?(object)
-        errors << "Attribute #{Attributor.humanize_context(context)}: #{Attributor.errorize_value(object)} is not within the allowed values=#{options[:values].inspect} "
-      end
-
-      errors + type.validate(object, context, self)
-    end
-
-    def validate_missing_value(context)
-      raise "INVALID CONTEXT!!! (got: #{context.inspect})" unless context.is_a? Enumerable
-
-      # Missing attribute was required if :required option was set
-      return ["Attribute #{Attributor.humanize_context(context)} is required"] if options[:required]
-
-      # Missing attribute was not required if :required_if (and :required)
-      # option was NOT set
-      requirement = options[:required_if]
-      return [] unless requirement
-
-      case requirement
-      when ::String
-        key_path = requirement
-        predicate = nil
-      when ::Hash
-        # TODO: support multiple dependencies?
-        key_path = requirement.keys.first
-        predicate = requirement.values.first
+      errors = []
+      if object.nil? && !self.class.nullable_attribute?(options)
+        errors << "Attribute #{Attributor.humanize_context(context)} is not nullable"
       else
-        # should never get here if the option validation worked...
-        raise AttributorException, "unknown type of dependency: #{requirement.inspect} for #{Attributor.humanize_context(context)}"
-      end
-
-      # chop off the last part
-      requirement_context = context[0..-2]
-      requirement_context_string = requirement_context.join(Attributor::SEPARATOR)
+        errors.push *validate_type(object, context)
 
-      # FIXME: we're having to reconstruct a string context just to use the resolver...smell.
-      if AttributeResolver.current.check(requirement_context_string, key_path, predicate)
-        message = "Attribute #{Attributor.humanize_context(context)} is required when #{key_path} "
-
-        # give a hint about what the full path for a relative key_path would be
-        unless key_path[0..0] == Attributor::AttributeResolver::ROOT_PREFIX
-          message << "(for #{Attributor.humanize_context(requirement_context)}) "
+        # If the value is null we skip value validation:
+        # a) If null wasn't allowed, it would have failed above.
+        # b) If null was allowed, we always allow that as a valid value
+        if !object.nil? && options[:values] && !options[:values].include?(object)
+          errors << "Attribute #{Attributor.humanize_context(context)}: #{Attributor.errorize_value(object)} is not within the allowed values=#{options[:values].inspect} "
         end
-
-        message << if predicate
-                     "matches #{predicate.inspect}."
-                   else
-                     'is present.'
-                   end
-
-        [message]
-      else
-        []
       end
+
+      return errors if errors.any?
+      
+      object.nil? ? errors : errors + type.validate(object, context, self)
     end
 
     def check_options!
@@ -328,9 +284,8 @@ module Attributor
       when :required
         raise AttributorException, 'Required must be a boolean' unless definition == true || definition == false
         raise AttributorException, 'Required cannot be enabled in combination with :default' if definition == true && options.key?(:default)
-      when :required_if
-        raise AttributorException, 'Required_if must be a String, a Hash definition or a Proc' unless definition.is_a?(::String) || definition.is_a?(::Hash) || definition.is_a?(::Proc)
-        raise AttributorException, 'Required_if cannot be specified together with :required' if options[:required]
+      when :null
+        raise AttributorException, 'Null must be a boolean' unless definition == true || definition == false        
       when :example
         unless definition.is_a?(::Regexp) || definition.is_a?(::String) || definition.is_a?(::Array) || definition.is_a?(::Proc) || definition.nil? || type.valid_type?(definition)
           raise AttributorException, "Invalid example type (got: #{definition.class.name}). It must always match the type of the attribute (except if passing Regex that is allowed for some types)"

data/lib/attributor/hash_dsl_compiler.rb

@@ -35,30 +35,31 @@ module Attributor
           rest = attr_names - keys
           unless rest.empty?
             rest.each do |attr|
-              result.push "Key #{attr} is required for #{Attributor.humanize_context(context)}."
+              sub_context = Attributor::Hash.generate_subcontext(context, attr)
+              result.push "Attribute #{Attributor.humanize_context(sub_context)} is required."
             end
           end
         when :exactly
           included = attr_names & keys
           unless included.size ==  number
-            result.push "Exactly #{number} of the following keys #{attr_names} are required for #{Attributor.humanize_context(context)}. Found #{included.size} instead: #{included.inspect}"
+            result.push "Exactly #{number} of the following attributes #{attr_names} are required for #{Attributor.humanize_context(context)}. Found #{included.size} instead: #{included.inspect}"
           end
         when :at_most
           rest = attr_names & keys
           if rest.size > number
             found = rest.empty? ? 'none' : rest.inspect
-            result.push "At most #{number} keys out of #{attr_names} can be passed in for #{Attributor.humanize_context(context)}. Found #{found}"
+            result.push "At most #{number} attributes out of #{attr_names} can be passed in for #{Attributor.humanize_context(context)}. Found #{found}"
           end
         when :at_least
           rest = attr_names & keys
           if rest.size < number
             found = rest.empty? ? 'none' : rest.inspect
-            result.push "At least #{number} keys out of #{attr_names} are required to be passed in for #{Attributor.humanize_context(context)}. Found #{found}"
+            result.push "At least #{number} attributes out of #{attr_names} are required to be passed in for #{Attributor.humanize_context(context)}. Found #{found}"
           end
         when :exclusive
           intersection = attr_names & keys
           if intersection.size > 1
-            result.push "keys #{intersection.inspect} are mutually exclusive for #{Attributor.humanize_context(context)}."
+            result.push "Attributes #{intersection.inspect} are mutually exclusive for #{Attributor.humanize_context(context)}."
           end
         end
         result

data/lib/attributor/types/hash.rb

@@ -426,7 +426,6 @@ module Attributor
       unless object.is_a?(self)
         raise ArgumentError, "#{name} can not validate object of type #{object.class.name} for #{Attributor.humanize_context(context)}."
       end
-
       object.validate(context)
     end
 
@@ -514,7 +513,6 @@ module Attributor
         end
       end
       # TODO: minProperties and maxProperties and patternProperties
-      # TODO: map our required_if (and possible our above requirements 'at_least...' to json schema dependencies)
       hash
     end
 
@@ -613,6 +611,12 @@ module Attributor
       context = [context] if context.is_a? ::String
 
       if self.class.keys.any?
+        extra_keys = @contents.keys - self.class.keys.keys
+        if extra_keys.any? && !self.class.options[:allow_extra]
+          return extra_keys.collect do |k|
+            "#{Attributor.humanize_context(context)} can not have key: #{k.inspect}"
+          end
+        end
         self.validate_keys(context)
       else
         self.validate_generic(context)
@@ -622,30 +626,34 @@ module Attributor
     end
 
     def validate_keys(context)
-      extra_keys = @contents.keys - self.class.keys.keys
-      if extra_keys.any? && !self.class.options[:allow_extra]
-        return extra_keys.collect do |k|
-          "#{Attributor.humanize_context(context)} can not have key: #{k.inspect}"
-        end
-      end
-
       errors = []
-      keys_with_values = []
+      keys_provided = []
 
       self.class.keys.each do |key, attribute|
         sub_context = self.class.generate_subcontext(context, key)
 
-        value = @contents[key]
-        keys_with_values << key unless value.nil?
+        value = _get_attr(key)
+        keys_provided << key if @contents.key?(key)
 
         if value.respond_to?(:validating) # really, it's a thing with sub-attributes
           next if value.validating
         end
-
-        errors.concat attribute.validate(value, sub_context)
+        # Isn't this handled by the requirements validation? NO! we might want to combine
+        if attribute.options[:required] && !@contents.key?(key)
+          errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."]
+        end
+        if @contents[key].nil?
+          if !Attribute.nullable_attribute?(attribute.options) && @contents.key?(key)
+            errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is not nullable."]
+          end
+          # No need to validate the attribute further if the key wasn't passed...(or we would get nullable errors etc..cause the attribute has no
+          # context if its containing key was even passed (and there might not be a containing key for a top level attribute anyways))
+        else
+          errors.concat attribute.validate(value, sub_context)
+        end
       end
       self.class.requirements.each do |requirement|
-        validation_errors = requirement.validate(keys_with_values, context)
+        validation_errors = requirement.validate(keys_provided, context)
         errors.concat(validation_errors) unless validation_errors.empty?
       end
       errors
@@ -661,7 +669,7 @@ module Attributor
 
         unless value_type == Attributor::Object
           sub_context = context + ["value(#{value.inspect})"]
-          errors.concat value_attribute.validate(value, sub_context)
+        errors.concat value_attribute.validate(value, sub_context)
         end
       end
     end

data/lib/attributor/types/model.rb

@@ -129,27 +129,9 @@ module Attributor
       @validating = true
 
       context = [context] if context.is_a? ::String
-      keys_with_values = []
-      errors = []
-
-      self.class.attributes.each do |sub_attribute_name, sub_attribute|
-        sub_context = self.class.generate_subcontext(context, sub_attribute_name)
-
-        value = __send__(sub_attribute_name)
-        keys_with_values << sub_attribute_name unless value.nil?
-
-        if value.respond_to?(:validating) # really, it's a thing with sub-attributes
-          next if value.validating
-        end
-
-        errors.concat sub_attribute.validate(value, sub_context)
-      end
-      self.class.requirements.each do |req|
-        validation_errors = req.validate(keys_with_values, context)
-        errors.concat(validation_errors) unless validation_errors.empty?
-      end
-
-      errors
+      # Use the common, underlying attribute validation of the hash (which will use our _get_attr)
+      # to know how to retrieve a value from a model (instead of a hash)
+      validate_keys(context)
     ensure
       @validating = false
     end
@@ -198,4 +180,10 @@ module Attributor
       @dumping = false
     end
   end
+
+  # Override the generic way to get a value from an instance (models need to call the method)
+  def _get_attr(k)
+    __send__(k)
+  end    
+
 end

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = '5.7'.freeze
+  VERSION = '6.0'.freeze
 end

data/lib/attributor.rb

@@ -13,7 +13,6 @@ module Attributor
   require_relative 'attributor/type'
   require_relative 'attributor/dsl_compiler'
   require_relative 'attributor/hash_dsl_compiler'
-  require_relative 'attributor/attribute_resolver'
   require_relative 'attributor/smart_attribute_selector'
 
   require_relative 'attributor/example_mixin'
@@ -22,7 +21,8 @@ module Attributor
 
   # hierarchical separator string for composing human readable attributes
   SEPARATOR = '.'.freeze
-  DEFAULT_ROOT_CONTEXT = ['$'].freeze
+  ROOT_PREFIX = '$'.freeze
+  DEFAULT_ROOT_CONTEXT = [ROOT_PREFIX].freeze
 
   # @param type [Class] The class of the type to resolve
   #
@@ -56,10 +56,6 @@ module Attributor
 
     context = Array(context) if context.is_a? ::String
 
-    unless context.is_a? Enumerable
-      raise "INVALID CONTEXT!!! (got: #{context.inspect})"
-    end
-
     begin
       return context.join('.')
     rescue e

data/spec/attribute_spec.rb

@@ -11,7 +11,7 @@ describe Attributor::Attribute do
 
   context 'initialize' do
     its(:type) { should be type }
-    its(:options) { should be attribute_options }
+    its(:options) { should eq attribute_options }
 
     it 'calls check_options!' do
       expect_any_instance_of(Attributor::Attribute).to receive(:check_options!)
@@ -72,8 +72,8 @@ describe Attributor::Attribute do
     let(:expected) do
       h = {type: {name: 'String', id: type.id, family: type.family}}
       common = attribute_options.select{|k,v| Attributor::Attribute::TOP_LEVEL_OPTIONS.include? k }
-      h.merge!( common )
-      h[:options] = {:min => 0 }
+      h.merge!(common)
+      h[:options] = {min: 0}
       h
     end
 
@@ -458,10 +458,49 @@ describe Attributor::Attribute do
         context 'applying attribute options' do
           context ':required' do
             let(:attribute_options) { { required: true } }
+            context 'has no effect on a bare attribute' do
+              let(:value) { 'val' }
+              it 'it does not error, as we do not know if the parent attribute key was passed in (done at the Hash level)' do
+                expect(attribute.validate(value, context)).to be_empty
+              end
+            end
+          end
+          context ':null false (non-nullable)' do
+            let(:attribute_options) { { null: false } }
             context 'with a nil value' do
               let(:value) { nil }
               it 'returns an error' do
-                expect(attribute.validate(value, context).first).to eq 'Attribute context is required'
+                expect(attribute.validate(value, context).first).to eq 'Attribute context is not nullable'
+              end
+            end
+          end
+          context ':null true (nullable)' do
+            let(:attribute_options) { { null: true } }
+            context 'with a nil value' do
+              let(:value) { nil }
+              it 'does not error' do
+                expect(attribute.validate(value, context)).to be_empty
+              end
+            end
+          end
+          context 'defaults to non-nullable if null not defined' do
+            let(:attribute_options) { { } }
+            context 'with a nil value' do
+              let(:value) { nil }
+              it 'returns an error' do
+                expect(Attributor::Attribute.default_for_null).to be(false)
+                expect(attribute.validate(value, context).first).to eq 'Attribute context is not nullable'
+              end
+            end
+          end
+
+          context 'default can be overrideable with true' do
+            let(:attribute_options) { { } }
+            context 'with a nil value' do
+              let(:value) { nil }
+              it 'suceeds' do
+                expect(Attributor::Attribute).to receive(:default_for_null).and_return(true)
+                expect(attribute.validate(value, context)).to be_empty
               end
             end
           end
@@ -507,6 +546,13 @@ describe Attributor::Attribute do
           end
         end
 
+        context 'with a nil value' do
+          let(:value) { nil }
+          it 'returns no errors' do
+            expect(errors).to be_empty
+          end
+        end
+
         context 'with a value of a value different than the native_type' do
           let(:value) { 1 }
 
@@ -516,58 +562,6 @@ describe Attributor::Attribute do
           end
         end
       end
-
-      context '#validate_missing_value' do
-        let(:key) { '$.instance.ssh_key.name' }
-        let(:value) { /\w+/.gen }
-
-        let(:attribute_options) { { required_if: key } }
-
-        let(:ssh_key) { double('ssh_key', name: value) }
-        let(:instance) { double('instance', ssh_key: ssh_key) }
-
-        before { Attributor::AttributeResolver.current.register('instance', instance) }
-
-        let(:attribute_context) { ['$', 'params', 'key_material'] }
-        subject(:errors) { attribute.validate_missing_value(attribute_context) }
-
-        context 'for a simple dependency without a predicate' do
-          context 'that is satisfied' do
-            it { should_not be_empty }
-          end
-
-          context 'that is missing' do
-            let(:value) { nil }
-            it { should be_empty }
-          end
-        end
-
-        context 'with a dependency that has a predicate' do
-          let(:value) { 'default_ssh_key_name' }
-          # subject(:errors) { attribute.validate_missing_value('') }
-
-          context 'where the target attribute exists, and matches the predicate' do
-            let(:attribute_options) { { required_if: { key => /default/ } } }
-
-            it { should_not be_empty }
-
-            its(:first) { should match(/Attribute #{Regexp.quote(Attributor.humanize_context(attribute_context))} is required when #{Regexp.quote(key)} matches/) }
-          end
-
-          context 'where the target attribute exists, but does not match the predicate' do
-            let(:attribute_options) { { required_if: { key => /other/ } } }
-
-            it { should be_empty }
-          end
-
-          context 'where the target attribute does not exist' do
-            let(:attribute_options) { { required_if: { key => /default/ } } }
-            let(:ssh_key) { double('ssh_key', name: nil) }
-
-            it { should be_empty }
-          end
-        end
-      end
     end
 
     context 'for an attribute for a subclass of Model' do
@@ -636,71 +630,6 @@ describe Attributor::Attribute do
           end
         end
       end
-
-      context '#validate_missing_value' do
-        let(:type) { Duck }
-        let(:attribute_name) { nil }
-        let(:attribute) { Duck.attributes[attribute_name] }
-
-        let(:attribute_context) { ['$', 'duck', attribute_name.to_s] }
-        subject(:errors) { attribute.validate_missing_value(attribute_context) }
-
-        before do
-          Attributor::AttributeResolver.current.register('duck', duck)
-        end
-
-        context 'for a dependency with no predicate' do
-          let(:attribute_name) { :email }
-
-          let(:duck) do
-            d = Duck.new
-            d.age = 1
-            d.name = 'Donald'
-            d
-          end
-
-          context 'where the target attribute exists, and matches the predicate' do
-            it { should_not be_empty }
-            its(:first) { should eq 'Attribute $.duck.email is required when name (for $.duck) is present.' }
-          end
-          context 'where the target attribute does not exist' do
-            before do
-              duck.name = nil
-            end
-            it { should be_empty }
-          end
-        end
-
-        context 'for a dependency with a predicate' do
-          let(:attribute_name) { :age }
-
-          let(:duck) do
-            d = Duck.new
-            d.name = 'Daffy'
-            d.email = 'daffy@darkwing.uoregon.edu' # he's a duck,get it?
-            d
-          end
-
-          context 'where the target attribute exists, and matches the predicate' do
-            it { should_not be_empty }
-            its(:first) { should match(/Attribute #{Regexp.quote('$.duck.age')} is required when name #{Regexp.quote('(for $.duck)')} matches/) }
-          end
-
-          context 'where the target attribute exists, and does not match the predicate' do
-            before do
-              duck.name = 'Donald'
-            end
-            it { should be_empty }
-          end
-
-          context 'where the target attribute does not exist' do
-            before do
-              duck.name = nil
-            end
-            it { should be_empty }
-          end
-        end
-      end
     end
   end
 
@@ -757,4 +686,24 @@ describe Attributor::Attribute do
       end
     end
   end
+
+  context '.nullable_attribute?' do
+    subject { described_class.nullable_attribute?(options) }
+    context 'with null: true option' do
+      let(:options) { { null: true } }  
+      it { should be_truthy }
+    end
+    context 'with null: false option' do
+      let(:options) { { null: false } }  
+      it { should be_falsey }
+    end
+    context 'defaults to false without any null option' do
+      let(:options) { { } }  
+      it { should be_falsey }
+    end
+    context 'defaults to false if null: nil' do
+      let(:options) { { null: nil } }  
+      it { should be_falsey }
+    end
+  end
 end

data/spec/hash_dsl_compiler_spec.rb

@@ -109,31 +109,31 @@ describe Attributor::HashDSLCompiler do
       context 'for :all' do
         let(:arguments) { { all: [:one, :two, :three] } }
         let(:value) { [:one] }
-        let(:validation_error) { ['Key two is required for $.', 'Key three is required for $.'] }
+        let(:validation_error) { ["Attribute $.key(:two) is required.", "Attribute $.key(:three) is required."] }
         it { expect(subject).to include(*validation_error) }
       end
       context 'for :exactly' do
         let(:requirement) { req_class.new(exactly: 1).of(:one, :two) }
         let(:value) { [:one, :two] }
-        let(:validation_error) { 'Exactly 1 of the following keys [:one, :two] are required for $. Found 2 instead: [:one, :two]' }
+        let(:validation_error) { 'Exactly 1 of the following attributes [:one, :two] are required for $. Found 2 instead: [:one, :two]' }
         it { expect(subject).to include(validation_error) }
       end
       context 'for :at_least' do
         let(:requirement) { req_class.new(at_least: 2).of(:one, :two, :three) }
         let(:value) { [:one] }
-        let(:validation_error) { 'At least 2 keys out of [:one, :two, :three] are required to be passed in for $. Found [:one]' }
+        let(:validation_error) { 'At least 2 attributes out of [:one, :two, :three] are required to be passed in for $. Found [:one]' }
         it { expect(subject).to include(validation_error) }
       end
       context 'for :at_most' do
         let(:requirement) { req_class.new(at_most: 1).of(:one, :two, :three) }
         let(:value) { [:one, :two] }
-        let(:validation_error) { 'At most 1 keys out of [:one, :two, :three] can be passed in for $. Found [:one, :two]' }
+        let(:validation_error) { 'At most 1 attributes out of [:one, :two, :three] can be passed in for $. Found [:one, :two]' }
         it { expect(subject).to include(validation_error) }
       end
       context 'for :exclusive' do
         let(:arguments) { { exclusive: [:one, :two] } }
         let(:value) { [:one, :two] }
-        let(:validation_error) { 'keys [:one, :two] are mutually exclusive for $.' }
+        let(:validation_error) { 'Attributes [:one, :two] are mutually exclusive for $.' }
         it { expect(subject).to include(validation_error) }
       end
     end

data/spec/spec_helper.rb

@@ -23,9 +23,7 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
   config.around(:each) do |example|
-    Attributor::AttributeResolver.current = Attributor::AttributeResolver.new
     example.run
-    Attributor::AttributeResolver.current = nil
   end
 end
 

data/spec/support/models.rb

@@ -11,9 +11,9 @@ end
 
 class Duck < Attributor::Model
   attributes do
-    attribute :age, Attributor::Integer, required_if: { 'name' => 'Daffy' }
+    attribute :age, Attributor::Integer
     attribute :name, Attributor::String
-    attribute :email, Attributor::String, required_if: 'name'
+    attribute :email, Attributor::String
     attribute :angry, Attributor::Boolean, default: true, example: /true|false/, description: 'Angry bird?'
     attribute :weight, Attributor::Float, example: /\d{1,2}\.\d/, description: 'The weight of the duck'
     attribute :type, Attributor::Symbol, values: [:duck]
@@ -50,15 +50,15 @@ class Cormorant < Attributor::Model
     end
 
     # This will be a collection of arbitrary Ruby Objects
-    attribute :fish, Attributor::Collection, description: 'All kinds of fish for feeding the babies'
+    attribute :all_the_fish, Attributor::Collection, description: 'All kinds of fish for feeding the babies'
 
     # This will be a collection of Cormorants (note, this relationship is circular)
-    attribute :neighbors, Attributor::Collection.of(Cormorant), description: 'Neighbor cormorants'
+    attribute :neighbors, Attributor::Collection.of(Cormorant), member_options: {null: false}, description: 'Neighbor cormorants', null: false
 
     # This will be a collection of instances of an anonymous Struct class, each having two well-defined attributes
 
     attribute :babies, Attributor::Collection.of(Attributor::Struct), description: 'All the babies', member_options: { identity: :name } do
-      attribute :name, Attributor::String, example: /[:name]/, description: 'The name of the baby cormorant'
+      attribute :name, Attributor::String, example: /[:name]/, description: 'The name of the baby cormorant', required: true
       attribute :months, Attributor::Integer, default: 0, min: 0, description: 'The age in months of the baby cormorant'
       attribute :weight, Attributor::Float, example: /\d{1,2}\.\d{3}/, description: 'The weight in kg of the baby cormorant'
     end
@@ -76,8 +76,8 @@ end
 
 class Address < Attributor::Model
   attributes do
-    attribute :name, String, example: /\w+/
-    attribute :state, String, values: %w(OR CA)
+    attribute :name, String, example: /\w+/, null: true
+    attribute :state, String, values: %w(OR CA), null: false
     attribute :person, Person, example: proc { |address, context| Person.example(context, address: address) }
     requires :name
   end

data/spec/types/hash_spec.rb

@@ -514,6 +514,7 @@ describe Attributor::Hash do
       end
     end
   end
+
   context '#validate' do
     context 'for a key and value typed hash' do
       let(:key_type) { Integer }
@@ -534,45 +535,85 @@ describe Attributor::Hash do
     context 'for a hash with defined keys' do
       let(:block) do
         proc do
-          key 'integer', Integer
+          key 'integer', Integer, null: false # non-nullable, but not required
           key 'datetime', DateTime
-          key 'not-optional', String, required: true
+          key 'not-optional', String, required: true, null: false # required AND non-nullable
+          key 'required-but-nullable', String, required: true, null: true
         end
       end
 
       let(:type) { Attributor::Hash.construct(block) }
-
-      let(:values) { { 'integer' => 'one', 'datetime' => 'now' } }
       subject(:hash) { type.new(values) }
 
-      it 'validates the keys' do
-        errors = hash.validate
-        expect(errors).to have(3).items
-        expect(errors).to include('Attribute $.key("not-optional") is required')
+      context 'validates it all' do
+        let(:values) { { 'integer' => 'one', 'datetime' => 'now', 'required-but-nullable' => nil} }
+        it 'validates the keys' do
+          errors = hash.validate
+          expect(errors).to have(3).items
+          [
+            'Attribute $.key("integer") received value: "one" is of the wrong type (got: String, expected: Attributor::Integer)',
+            'Attribute $.key("datetime") received value: "now" is of the wrong type (got: String, expected: Attributor::DateTime)',
+            'Attribute $.key("not-optional") is required'
+          ].each do |msg|
+            regexp = Regexp.new(Regexp.escape(msg))
+            expect(errors.any?{|err| err =~ regexp}).to be_truthy
+          end
+        end
+      end
+      
+      context 'still validates requiredness even if values are nullable' do
+        let(:values) { {} }
+        it 'complains if not provided' do
+          errors = hash.validate
+          expect(errors).to have(2).items
+          [
+            'Attribute $.key("not-optional") is required',
+            'Attribute $.key("required-but-nullable") is required'
+          ].each do |msg|
+            regexp = Regexp.new(Regexp.escape(msg))
+            expect(errors.any?{|err| err =~ regexp}).to be_truthy
+          end
+        end
       end
+
+      context 'validates nullability regardless of requiredness' do
+        let(:values) { {'integer'  => nil, 'not-optional' => nil, 'required-but-nullable' => nil} }
+        it 'complains if null' do
+          errors = hash.validate
+          expect(errors).to have(2).items
+          [
+            'Attribute $.key("integer") is not nullable',
+            'Attribute $.key("not-optional") is not nullable',
+          ].each do |msg|
+            regexp = Regexp.new(Regexp.escape(msg))
+            expect(errors.any?{|err| err =~ regexp}).to be_truthy
+          end
+        end
+      end
+      
     end
 
     context 'with requirements defined' do
       let(:type) { Attributor::Hash.construct(block) }
 
-      context 'using requires' do
+      context 'using the requires DSL' do
         let(:block) do
           proc do
             key 'name', String
+            key 'nevernull', String, null: false
             key 'consistency', Attributor::Boolean
-            key 'availability', Attributor::Boolean
-            key 'partitioning', Attributor::Boolean
+            key 'availability', Attributor::Boolean, null: true
+            key 'partitioning', Attributor::Boolean, null: true
             requires 'consistency', 'availability'
-            requires.all 'name' # Just to show that it is equivalent to 'requires'
+            requires.all 'name'
           end
         end
 
         it 'complains not all the listed elements are set (false or true)' do
-          errors = type.new('name' => 'CAP').validate
+          errors = type.new('name' => 'CAP', 'consistency' => true, 'nevernull' => nil).validate
           expect(errors).to have(2).items
-          %w(consistency availability).each do |name|
-            expect(errors).to include("Key #{name} is required for $.")
-          end
+          expect(errors).to include('Attribute $.key("nevernull") is not nullable.')
+          expect(errors).to include('Attribute $.key("availability") is required.')
         end
       end
 
@@ -591,7 +632,7 @@ describe Attributor::Hash do
           errors = type.new('name' => 'CAP', 'consistency' => false).validate
           expect(errors).to have(1).items
           expect(errors).to include(
-            'At least 2 keys out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found ["consistency"]'
+            'At least 2 attributes out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found ["consistency"]'
           )
         end
       end
@@ -610,7 +651,7 @@ describe Attributor::Hash do
         it 'complains if more than 2 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true, 'partitioning' => false).validate
           expect(errors).to have(1).items
-          expect(errors).to include('At most 2 keys out of ["consistency", "availability", "partitioning"] can be passed in for $. Found ["consistency", "availability", "partitioning"]')
+          expect(errors).to include('At most 2 attributes out of ["consistency", "availability", "partitioning"] can be passed in for $. Found ["consistency", "availability", "partitioning"]')
         end
       end
 
@@ -628,12 +669,12 @@ describe Attributor::Hash do
         it 'complains if less than 1 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP').validate
           expect(errors).to have(1).items
-          expect(errors).to include('Exactly 1 of the following keys ["consistency", "availability", "partitioning"] are required for $. Found 0 instead: []')
+          expect(errors).to include('Exactly 1 of the following attributes ["consistency", "availability", "partitioning"] are required for $. Found 0 instead: []')
         end
         it 'complains if more than 1 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true).validate
           expect(errors).to have(1).items
-          expect(errors).to include('Exactly 1 of the following keys ["consistency", "availability", "partitioning"] are required for $. Found 2 instead: ["consistency", "availability"]')
+          expect(errors).to include('Exactly 1 of the following attributes ["consistency", "availability", "partitioning"] are required for $. Found 2 instead: ["consistency", "availability"]')
         end
       end
 
@@ -651,7 +692,7 @@ describe Attributor::Hash do
         it 'complains if two or more in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true).validate
           expect(errors).to have(1).items
-          expect(errors).to include('keys ["consistency", "availability"] are mutually exclusive for $.')
+          expect(errors).to include('Attributes ["consistency", "availability"] are mutually exclusive for $.')
         end
       end
 
@@ -676,7 +717,7 @@ describe Attributor::Hash do
           errors = type.new('name' => 'CAP').validate
           expect(errors).to have(1).items
           expect(errors).to include(
-            'At least 1 keys out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found none'
+            'At least 1 attributes out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found none'
           )
         end
       end

data/spec/types/model_spec.rb

@@ -371,7 +371,12 @@ describe Attributor::Model do
     context 'for models using the "requires" DSL' do
       subject(:address) { Address.load({state: 'CA'}) }
       its(:validate) { should_not be_empty }
-      its(:validate) { should include 'Key name is required for $.' }
+      its(:validate) { should include 'Attribute $.key(:name) is required.' }
+    end
+    context 'for models with non-nullable attributes' do
+      subject(:address) { Address.load({name: nil, state: nil}) }
+      its(:validate) { should_not be_empty }
+      its(:validate) { should include 'Attribute $.state is not nullable.' } # name is nullable
     end
     context 'for models with circular sub-attributes' do
       context 'that are valid' do
@@ -478,6 +483,7 @@ describe Attributor::Model do
 
       it 'supports defining sub-attributes using the proper reference' do
         expect(struct.attributes[:neighbors].options[:required]).to be true
+        expect(struct.attributes[:neighbors].options[:null]).to be false
         expect(struct.attributes[:neighbors].type.member_attribute.type.attributes.keys).to match_array [:name, :age]
 
         name_options = struct.attributes[:neighbors].type.member_attribute.type.attributes[:name].options

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attributor
 version: !ruby/object:Gem::Version
-  version: '5.7'
+  version: '6.0'
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -312,7 +312,6 @@ files:
 - attributor.gemspec
 - lib/attributor.rb
 - lib/attributor/attribute.rb
-- lib/attributor/attribute_resolver.rb
 - lib/attributor/dsl_compiler.rb
 - lib/attributor/dumpable.rb
 - lib/attributor/example_mixin.rb
@@ -350,7 +349,6 @@ files:
 - lib/attributor/types/time.rb
 - lib/attributor/types/uri.rb
 - lib/attributor/version.rb
-- spec/attribute_resolver_spec.rb
 - spec/attribute_spec.rb
 - spec/attributor_spec.rb
 - spec/dsl_compiler_spec.rb
@@ -407,12 +405,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A powerful attribute and type management library for Ruby
 test_files:
-- spec/attribute_resolver_spec.rb
 - spec/attribute_spec.rb
 - spec/attributor_spec.rb
 - spec/dsl_compiler_spec.rb

data/lib/attributor/attribute_resolver.rb

@@ -1,111 +0,0 @@
-require 'ostruct'
-
-module Attributor
-  class AttributeResolver
-    ROOT_PREFIX = '$'.freeze
-    COLLECTION_INDEX_KEY = /^at\((\d+)\)$/
-
-    class Data < ::Hash
-      include Hashie::Extensions::MethodReader
-    end
-
-    attr_reader :data
-
-    def initialize
-      @data = Data.new
-    end
-
-    def query!(key_path, path_prefix = ROOT_PREFIX)
-      # If the incoming key_path is not an absolute path, append the given prefix
-      # NOTE: Need to index key_path by range here because Ruby 1.8 returns a
-      # FixNum for the ASCII code, not the actual character, when indexing by a number.
-      unless key_path[0..0] == ROOT_PREFIX
-        # TODO: prepend path_prefix to path_prefix if it did not include it? hm.
-        key_path = path_prefix + SEPARATOR + key_path
-      end
-
-      # Discard the initial element, which should always be ROOT_PREFIX at this point
-      _root, *path = key_path.split(SEPARATOR)
-
-      # Follow the hierarchy path to the requested node and return it:
-      # Example path => ["instance", "ssh_key", "name"]
-      # Example @data => {"instance" => { "ssh_key" => { "name" => "foobar" } }}
-      #
-      # at(n) is a collection index:
-      # Example path => ["filters", "at(0)", "type"]
-      # Example data => {"filters" => [{ "type" => "instance:tag" }]}
-      #
-      result = path.inject(@data) do |hash, key|
-        return nil if hash.nil?
-        if (match = key.match(COLLECTION_INDEX_KEY))
-          hash[match[1].to_i]
-        else
-          hash.send key
-        end
-      end
-      result
-    end
-
-    # Query for a certain key in the attribute hierarchy
-    #
-    # @param [String] key_path The name of the key to query and its path
-    # @param [String] path_prefix
-    #
-    # @return [String] The value of the specified attribute/key
-    #
-    def query(key_path, path_prefix = ROOT_PREFIX)
-      query!(key_path, path_prefix)
-    rescue NoMethodError
-      nil
-    end
-
-    def register(key_path, value)
-      if key_path.split(SEPARATOR).size > 1
-        raise AttributorException, "can only register top-level attributes. got: #{key_path}"
-      end
-
-      @data[key_path] = value
-    end
-
-    # Checks that the the condition is met. This means the attribute identified
-    # by path_prefix and key_path satisfies the optional predicate, which when
-    # nil simply checks for existence.
-    #
-    # @param path_prefix [String]
-    # @param key_path [String]
-    # @param predicate [String|Regexp|Proc|NilClass]
-    #
-    # @returns [Boolean] True if :required_if condition is met, false otherwise
-    #
-    # @raise [AttributorException] When an unsupported predicate is passed
-    #
-    def check(path_prefix, key_path, predicate = nil)
-      value = query(key_path, path_prefix)
-
-      # we have a value, any value, which is good enough given no predicate
-      return true if !value.nil? && predicate.nil?
-
-      case predicate
-      when ::String, ::Regexp, ::Integer, ::Float, ::DateTime, true, false
-        return predicate === value
-      when ::Proc
-        # Cannot use === here as above due to different behavior in Ruby 1.8
-        return predicate.call(value)
-      when nil
-        return !value.nil?
-      else
-        raise AttributorException, "predicate not supported: #{predicate.inspect}"
-      end
-    end
-
-    # TODO: kill this when we also kill Taylor's IdentityMap.current
-    def self.current=(resolver)
-      Thread.current[:_attributor_attribute_resolver] = resolver
-    end
-
-    def self.current
-      raise AttributorException, 'No AttributeResolver set.' unless Thread.current[:_attributor_attribute_resolver]
-      Thread.current[:_attributor_attribute_resolver]
-    end
-  end
-end

data/spec/attribute_resolver_spec.rb

@@ -1,237 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper.rb')
-
-describe Attributor::AttributeResolver do
-  let(:value) { /\w+/.gen }
-
-  context 'registering and querying simple values' do
-    let(:name) { 'string_value' }
-    before { subject.register(name, value) }
-
-    it 'works' do
-      expect(subject.query(name)).to be value
-    end
-  end
-
-  context 'querying and registering nested values' do
-    let(:one) { double(two: value) }
-    let(:key) { 'one.two' }
-    before { subject.register('one', one) }
-
-    it 'works' do
-      expect(subject.query(key)).to be value
-    end
-  end
-
-  context 'querying nested values from models' do
-    let(:instance) { double('instance', ssh_key: ssh_key) }
-    let(:ssh_key) { double('ssh_key', name: value) }
-    let(:key) { 'instance.ssh_key.name' }
-
-    before { subject.register('instance', instance) }
-
-    it 'works' do
-      expect(subject.query('instance')).to be instance
-      expect(subject.query('instance.ssh_key')).to be ssh_key
-      expect(subject.query(key)).to be value
-    end
-
-    context 'with a prefix' do
-      let(:key) { 'name' }
-      let(:prefix) { '$.instance.ssh_key' }
-      let(:value) { 'some_name' }
-      it 'works' do
-        expect(subject.query(key, prefix)).to be(value)
-      end
-    end
-  end
-
-  context 'querying values that do not exist' do
-    context 'for a straight key' do
-      let(:key) { 'missing' }
-      it 'returns nil' do
-        expect(subject.query(key)).to be_nil
-      end
-    end
-    context 'for a nested key' do
-      let(:key) { 'nested.missing' }
-      it 'returns nil' do
-        expect(subject.query(key)).to be_nil
-      end
-    end
-  end
-
-  context 'querying collection indices from models' do
-    let(:instances) { [instance1, instance2] }
-    let(:instance1) { double('instance1', ssh_key: ssh_key1) }
-    let(:instance2) { double('instance2', ssh_key: ssh_key2) }
-    let(:ssh_key1) { double('ssh_key', name: value) }
-    let(:ssh_key2) { double('ssh_key', name: 'second') }
-    let(:args) { [path, prefix].compact }
-
-    before { subject.register('instances', instances) }
-
-    it 'resolves the index to the correct member of the collection' do
-      expect(subject.query('instances')).to be instances
-      expect(subject.query('instances.at(1).ssh_key')).to be ssh_key2
-      expect(subject.query('instances.at(0).ssh_key.name')).to be value
-    end
-
-    it 'returns nil for index out of range' do
-      expect(subject.query('instances.at(2)')).to be(nil)
-      expect(subject.query('instances.at(-1)')).to be(nil)
-    end
-
-    context 'with a prefix' do
-      let(:key) { 'name' }
-      let(:prefix) { '$.instances.at(0).ssh_key' }
-      let(:value) { 'some_name' }
-
-      it 'resolves the index to the correct member of the collection' do
-        expect(subject.query(key, prefix)).to be(value)
-      end
-    end
-  end
-
-  context 'checking attribute conditions' do
-    let(:key) { 'instance.ssh_key.name' }
-    let(:ssh_key) { double('ssh_key', name: value) }
-    let(:instance_id) { 123 }
-    let(:instance) { double('instance', ssh_key: ssh_key, id: instance_id) }
-
-    let(:context) { '$' }
-
-    before { subject.register('instance', instance) }
-
-    let(:present_key) { key }
-    let(:missing_key) { 'instance.ssh_key.something_else' }
-
-    context 'with no condition' do
-      let(:condition) { nil }
-      before { expect(ssh_key).to receive(:something_else).and_return(nil) }
-      it 'works' do
-        expect(subject.check(context, present_key, condition)).to be true
-        expect(subject.check(context, missing_key, condition)).to be false
-      end
-    end
-
-    context 'with a string condition' do
-      let(:passing_condition) { value }
-      let(:failing_condition) { /\w+/.gen }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to be true
-        expect(subject.check(context, key, failing_condition)).to be false
-      end
-    end
-
-    context 'with a regex condition' do
-      let(:passing_condition) { /\w+/ }
-      let(:failing_condition) { /\d+/ }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to be true
-        expect(subject.check(context, key, failing_condition)).to be false
-      end
-    end
-
-    context 'with an integer condition' do
-      let(:key) { 'instance.id' }
-      let(:passing_condition) { instance_id }
-      let(:failing_condition) { /\w+/.gen }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to be true
-        expect(subject.check(context, key, failing_condition)).to be false
-      end
-    end
-
-    skip 'with a hash condition' do
-    end
-
-    context 'with a proc condition' do
-      let(:passing_condition) { proc { |test_value| test_value == value } }
-      let(:failing_condition) { proc { |test_value| test_value != value } }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to eq(true)
-        expect(subject.check(context, key, failing_condition)).to eq(false)
-      end
-    end
-
-    context 'with an unsupported condition type' do
-      let(:condition) { double('weird condition type') }
-      it 'raises an error' do
-        expect { subject.check(context, present_key, condition) }.to raise_error(Attributor::AttributorException)
-      end
-    end
-
-    context 'with a condition that asserts something IS nil' do
-      let(:ssh_key) { double('ssh_key', name: nil) }
-      it 'can be done using the almighty Proc' do
-        cond = proc { |value| !value.nil? }
-        expect(subject.check(context, key, cond)).to be false
-      end
-    end
-
-    context 'with a relative path' do
-      let(:context) { '$.instance.ssh_key' }
-      let(:key) { 'name' }
-
-      it 'works' do
-        expect(subject.check(context, key, value)).to be true
-      end
-    end
-  end
-
-  # context 'with context stuff...' do
-
-  #   let(:ssh_key) { double("ssh_key", name:value) }
-  #   let(:instance) { double("instance", ssh_key:ssh_key) }
-
-  #   let(:key) { "ssh_key.name" }
-  #   let(:key) { "$.payload" }
-  #   let(:key) { "ssh_key.name" } # no $ == current object
-  #   let(:key) { "@.ssh_key" }    # @ is current object
-
-  #   before { subject.register('instance', instance) }
-
-  #   it 'works?' do
-  #     # check dependency for 'instance'
-  #     resolver.with 'instance' do |res|
-  #       res.check(key)
-  #       '$.payload'
-  #     end
-
-  #   end
-
-  # end
-
-  # context 'integration with attributes that have sub-attributes' do
-  # when you start to parse... do you set the root in the resolver?
-  # end
-  #
-  #  context 'actually using the thing' do
-
-  #   # we'll always want to add... right? never really remove?
-  #   # at least not remove for the duration of a given resolver...
-  #   # which will last for one request.
-  #   #
-  #   # could the resolver be an identity-map of sorts for the request?
-  #   # how much overlap is there in there?
-  #   #
-  #   #
-
-  #   it 'is really actually quite useful' do
-  #     #attribute = Attributor::Attribute.new ::String, required_if: { "instance.ssh_key.name" : Proc.new { |value| value.nil? } }
-
-  #     resolver = Attributor::AttributeResolver.new
-
-  #     resolver.register '$.parsed_params', parsed_params
-  #     resolver.register '$.payload', payload
-
-  #     resolver.query '$.parsed_params.account_id'
-
-  #   end
-
-  # end
-end