attributor 5.4 → 6.0

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
 
@@ -437,11 +436,11 @@ module Attributor
 
       if keys.any?
         # Spit keys if it's the root or if it's an anonymous structures
-        if !shallow || name.nil?
-          required_names = []
+        if ( !shallow || self.name == nil)
+          required_names_from_attr = []
           # FIXME: change to :keys when the praxis doc browser supports displaying those
-          hash[:attributes] = keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
-            required_names << sub_name if sub_attribute.options[:required] == true
+          hash[:attributes] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+            required_names_from_attr << sub_name if sub_attribute.options[:required] == true
             sub_example = example.get(sub_name) if example
             sub_attributes[sub_name] = sub_attribute.describe(true, example: sub_example)
           end
@@ -449,14 +448,14 @@ module Attributor
             described_req = req.describe(shallow)
             if described_req[:type] == :all
               # Add the names of the attributes that have the required flag too
-              described_req[:attributes] |= required_names
-              required_names = []
+              described_req[:attributes] |= required_names_from_attr
+              required_names_from_attr = []
             end
             list << described_req
           end
           # Make sure we create an :all requirement, if there wasn't one so we can add the required: true attributes
-          unless required_names.empty?
-            hash[:requirements] << { type: :all, attributes: required_names }
+          unless required_names_from_attr.empty?
+            hash[:requirements] << {type: :all, attributes: required_names_from_attr }
           end
         end
       else
@@ -467,6 +466,60 @@ module Attributor
       hash
     end
 
+    def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+      hash = super
+      opts = self.options.merge( attribute_options )
+
+      if key_type
+        hash[:'x-key_type'] = key_type.as_json_schema
+      end
+
+      if self.keys.any?
+        # Spit keys if it's the root or if it's an anonymous structures
+        if ( !shallow || self.name == nil)
+          required_names_from_attr = []
+          # FIXME: change to :keys when the praxis doc browser supports displaying those
+          hash[:properties] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+            required_names_from_attr << sub_name if sub_attribute.options[:required] == true
+            sub_example = example.get(sub_name) if example
+            sub_attributes[sub_name] = sub_attribute.as_json_schema(shallow: true, example: sub_example)
+          end
+
+          # Expose the more complex requirements to in the x-tended attribute
+          extended_requirements = self.requirements.each_with_object([]) do |req, list|
+            described_req = req.describe(shallow)
+            if described_req[:type] == :all
+              # Add the names of the attributes that have the required flag too
+              described_req[:attributes] |= required_names_from_attr
+              required_names_from_attr = []
+            end
+            list << described_req
+          end
+          all = extended_requirements.find{|r| r[:type] == :all }
+          if ( all && !all[:attributes].empty? )
+            hash[:required] = all[:attributes]
+          end
+          hash[:'x-requirements'] = extended_requirements unless extended_requirements.empty?
+        end
+      else
+        hash[:'x-value_type'] = value_type.as_json_schema(shallow:true)
+      end
+
+      if opts[:allow_extra]
+        hash[:additionalProperties] = if value_type == Attributor::Object
+          true
+        else
+          value_type.as_json_schema(shallow: true)
+        end
+      end
+      # TODO: minProperties and maxProperties and patternProperties
+      hash
+    end
+
+    def self.json_schema_type
+      :object
+    end
+
     # TODO: Think about the format of the subcontexts to use: let's use .at(key.to_s)
     attr_reader :contents
 
@@ -558,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)
@@ -567,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
@@ -606,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/integer.rb

@@ -1,7 +1,9 @@
 
 
 module Attributor
-  class Integer < Numeric
+  class Integer
+    include Attributor::Numeric
+
     EXAMPLE_RANGE = 1000
 
     def self.native_type
@@ -53,5 +55,9 @@ module Attributor
       end
       true
     end
+
+    def self.json_schema_type
+      :integer
+    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/types/object.rb

@@ -13,5 +13,10 @@ module Attributor
     def self.example(_context = nil, options: {})
       'An Object'
     end
+        
+    def self.json_schema_type
+      :object #FIXME: not sure this is the most appropriate, since an Attributor::Object can be anything
+    end
+
   end
 end

data/lib/attributor/types/polymorphic.rb

@@ -1,4 +1,3 @@
-require 'active_support'
 
 require_relative '../exceptions'
 

data/lib/attributor/types/string.rb

@@ -32,5 +32,24 @@ module Attributor
     def self.family
       'string'
     end
+
+    def self.json_schema_type
+      :string
+    end
+    
+    # TODO: we're passing the attribute options for now...might need to rethink ...although these are type-specific...
+    # TODO: multipleOf, minimum, maximum, exclusiveMinimum and exclusiveMaximum
+    def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+      h = super
+      opts = ( self.respond_to?(:options) ) ? self.options.merge( attribute_options ) : attribute_options
+      h[:pattern] = self.human_readable_regexp(opts[:regexp]) if opts[:regexp]
+      # TODO: minLength, maxLength
+      h
+    end
+
+    def self.human_readable_regexp( reg )
+      return $1 if reg.to_s =~ /\(\?[^:]+:(.+)\)/
+      reg
+    end
   end
 end

data/lib/attributor/types/symbol.rb

@@ -19,5 +19,10 @@ module Attributor
     def self.family
       String.family
     end
+
+    def self.json_schema_type
+      :string
+    end
+
   end
 end

data/lib/attributor/types/tempfile.rb

@@ -38,5 +38,9 @@ module Attributor
     def self.family
       String.family
     end
+
+    def self.json_schema_type
+      :string
+    end
   end
 end

data/lib/attributor/types/time.rb

@@ -1,8 +1,8 @@
 require 'date'
 
 module Attributor
-  class Time < Temporal
-    include Type
+  class Time
+    include Temporal
 
     def self.native_type
       ::Time
@@ -35,5 +35,9 @@ module Attributor
         raise CoercionError, context: context, from: value.class, to: self, value: value
       end
     end
+
+    def self.json_schema_string_format
+      :time
+    end
   end
 end

data/lib/attributor/types/uri.rb

@@ -22,6 +22,14 @@ module Attributor
       ::URI::Generic
     end
 
+    def self.json_schema_type
+      :string
+    end
+
+    def self.json_schema_string_format
+      :uri
+    end
+
     def self.example(_context = nil, options: {})
       URI(Randgen.uri)
     end

data/lib/attributor/version.rb

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

data/lib/attributor.rb

@@ -2,7 +2,7 @@ require 'json'
 require 'randexp'
 
 require 'hashie'
-
+require 'active_support/concern'
 require 'digest/sha1'
 
 module Attributor
@@ -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