attributor 5.1.0 → 5.5

data/lib/attributor/attribute.rb

@@ -93,12 +93,12 @@ module Attributor
 
     TOP_LEVEL_OPTIONS = [:description, :values, :default, :example, :required, :required_if, :custom_data].freeze
     INTERNAL_OPTIONS = [:dsl_compiler, :dsl_compiler_options].freeze # Options we don't want to expose when describing attributes
-
-    def describe(shallow = true, example: nil)
-      description = {}
+    JSON_SCHEMA_UNSUPPORTED_OPTIONS = [ :required, :required_if ].freeze
+    def describe(shallow=true, example: nil)
+      description = { }
       # Clone the common options
       TOP_LEVEL_OPTIONS.each do |option_name|
-        description[option_name] = options[option_name] if options.key? option_name
+        description[option_name] = self.describe_option(option_name) if self.options.has_key? option_name
       end
 
       # Make sure this option definition is not mistaken for the real generated example
@@ -109,7 +109,7 @@ module Attributor
       special_options = options.keys - TOP_LEVEL_OPTIONS - INTERNAL_OPTIONS
       description[:options] = {} unless special_options.empty?
       special_options.each do |opt_name|
-        description[:options][opt_name] = options[opt_name]
+        description[:options][opt_name] = self.describe_option(opt_name)
       end
       # Change the reference option to the actual class name.
       if (reference = options[:reference])
@@ -146,8 +146,37 @@ module Attributor
       load(generated, context)
     end
 
-    def example(context = nil, parent: nil, values: {})
-      raise ArgumentError, 'attribute example cannot take a context of type String' if context.is_a? ::String
+    def describe_option( option_name )
+      self.type.describe_option( option_name, self.options[option_name] )
+    end
+
+    # FiXME: pass and utilize the "shallow" parameter
+    #required
+    #options
+    #type
+    #example
+    # UTILIZE THIS SITE! http://jsonschema.net/#/
+    def as_json_schema(shallow: true, example: nil)
+      description = self.type.as_json_schema(shallow: shallow, example: example, attribute_options: self.options )
+
+      description[:description] = self.options[:description] if self.options[:description]
+      description[:enum] = self.options[:values] if self.options[:values]
+      description[:default] = self.options[:default] if self.options[:default]
+      #TODO      description[:title] = "TODO: do we want to use a title??..."
+
+      # Change the reference option to the actual class name.
+      if ( reference = self.options[:reference] )
+        description[:'x-reference'] = reference.name
+      end
+
+      # TODO: not sure if that's correct (we used to get it from the described hash...
+      description[:example] = self.dump(example) if example
+
+      description
+    end
+
+    def example(context=nil, parent: nil, values:{})
+      raise ArgumentError, "attribute example cannot take a context of type String" if (context.is_a? ::String )
       if context
         ctx = Attributor.humanize_context(context)
         seed, = Digest::SHA1.digest(ctx).unpack('QQ')
@@ -158,7 +187,8 @@ module Attributor
 
       if options.key? :example
         loaded = example_from_options(parent, context)
-        errors = validate(loaded, context)
+        # Only validate the type, if the proc-generated example is "complex" (has attributes)
+        errors = loaded.class.respond_to?(:attributes) ? validate_type(loaded, context) : validate(loaded, context)
         raise AttributorException, "Error generating example for #{Attributor.humanize_context(context)}. Errors: #{errors.inspect}" if errors.any?
         return loaded
       end
@@ -166,7 +196,7 @@ module Attributor
       return options[:values].pick if options.key? :values
 
       if type.respond_to?(:attributes)
-        type.example(context, values)
+        type.example(context, **values)
       else
         type.example(context, options: options)
       end

data/lib/attributor/dsl_compiler.rb

@@ -78,6 +78,8 @@ module Attributor
     #     end
     # @api semiprivate
     def define(name, attr_type = nil, **opts, &block)
+      example_given = opts.key? :example
+
       # add to existing attribute if present
       if (existing_attribute = attributes[name])
         if existing_attribute.attributes
@@ -86,27 +88,33 @@ module Attributor
         end
       end
 
-      # determine inherited attribute
-      inherited_attribute = nil
-      if (reference = options[:reference])
-        if (inherited_attribute = reference.attributes[name])
+      # determine inherited type (giving preference to the direct attribute options)
+      inherited_type = opts[:reference]
+      unless inherited_type
+        reference = options[:reference]
+        if reference && reference.respond_to?(:attributes) && reference.attributes.key?(name)
+          inherited_attribute = reference.attributes[name]
           opts = inherited_attribute.options.merge(opts) unless attr_type
-          opts[:reference] = inherited_attribute.type if block_given?
+          inherited_type = inherited_attribute.type
+          opts[:reference] = inherited_type if block_given?
         end
       end
 
       # determine attribute type to use
       if attr_type.nil?
         if block_given?
-          attr_type = if inherited_attribute && inherited_attribute.type < Attributor::Collection
+          # Don't inherit explicit examples if we've redefined the structure 
+          # (but preserve the direct example if given here)
+          opts.delete :example unless  example_given
+          attr_type = if inherited_type && inherited_type < Attributor::Collection
                         # override the reference to be the member_attribute's type for collections
-                        opts[:reference] = inherited_attribute.type.member_attribute.type
+                        opts[:reference] = inherited_type.member_attribute.type
                         Attributor::Collection.of(Struct)
                       else
                         Attributor::Struct
                       end
-        elsif inherited_attribute
-          attr_type = inherited_attribute.type
+        elsif inherited_type
+          attr_type = inherited_type
         else
           raise AttributorException, "type for attribute with name: #{name} could not be determined"
         end

data/lib/attributor/exceptions.rb

@@ -34,4 +34,9 @@ module Attributor
       super msg
     end
   end
+
+  # Thrown from SmartAttributeSelector when the requirements of attributes are certainly unfeasible
+  class UnfeasibleRequirementsError < AttributorException
+  end
+
 end

data/lib/attributor/extras/field_selector.rb

@@ -12,6 +12,10 @@ module Attributor
 
     include Attributor::Type
 
+    def self.json_schema_type
+      :string
+    end
+
     def self.native_type
       ::Hash
     end

data/lib/attributor/families/numeric.rb

@@ -1,15 +1,28 @@
 # Abstract type for the 'numeric' family
 
 module Attributor
-  class Numeric
+  module Numeric
+    extend ActiveSupport::Concern
     include Type
 
-    def self.native_type
-      raise NotImplementedError
-    end
+    module ClassMethods
+      
+      def native_type
+        raise NotImplementedError
+      end
+
+      def family
+        'numeric'
+      end
 
-    def self.family
-      'numeric'
+      def as_json_schema( shallow: false, example: nil, attribute_options: {} )
+        h = super
+        opts = ( self.respond_to?(:options) ) ? self.options.merge( attribute_options ) : attribute_options
+        h[:minimum] = opts[:min] if opts[:min]
+        h[:maximum] = opts[:max] if opts[:max]
+        # We're not explicitly setting false to exclusiveMinimum and exclusiveMaximum (as that's the default)
+        h
+      end
     end
   end
 end

data/lib/attributor/families/temporal.rb

@@ -1,19 +1,26 @@
 # Abstract type for the 'temporal' family
 
 module Attributor
-  class Temporal
+  module Temporal
+    extend ActiveSupport::Concern
     include Type
 
-    def self.native_type
-      raise NotImplementedError
-    end
+    module ClassMethods
+      def native_type
+        raise NotImplementedError
+      end
 
-    def self.family
-      'temporal'
-    end
+      def family
+        'temporal'
+      end
+
+      def dump(value, **_opts)
+        value && value.iso8601
+      end
 
-    def self.dump(value, **_opts)
-      value && value.iso8601
+      def json_schema_type
+        :string
+      end
     end
   end
 end

data/lib/attributor/hash_dsl_compiler.rb

@@ -89,31 +89,31 @@ module Attributor
       end
 
       def all(*attr_names, **opts)
-        req = Requirement.new(options.merge(opts).merge(all: attr_names))
+        req = Requirement.new(**options.merge(opts).merge(all: attr_names))
         target.add_requirement req
         req
       end
 
       def at_most(number)
-        req = Requirement.new(options.merge(at_most: number))
+        req = Requirement.new(**options.merge(at_most: number))
         target.add_requirement req
         req
       end
 
       def at_least(number)
-        req = Requirement.new(options.merge(at_least: number))
+        req = Requirement.new(**options.merge(at_least: number))
         target.add_requirement req
         req
       end
 
       def exactly(number)
-        req = Requirement.new(options.merge(exactly: number))
+        req = Requirement.new(**options.merge(exactly: number))
         target.add_requirement req
         req
       end
 
       def exclusive(*attr_names, **opts)
-        req = Requirement.new(options.merge(opts).merge(exclusive: attr_names))
+        req = Requirement.new(**options.merge(opts).merge(exclusive: attr_names))
         target.add_requirement req
         req
       end
@@ -132,7 +132,7 @@ module Attributor
           _requirements_dsl
         end
       else
-        _requirements_dsl.all(*spec, opts)
+        _requirements_dsl.all(*spec, **opts)
       end
     end
   end

data/lib/attributor/smart_attribute_selector.rb

@@ -0,0 +1,149 @@
+module Attributor
+  class SmartAttributeSelector
+    attr_accessor :reqs, :accepted, :banned, :remaining
+    attr_reader :reqs, :accepted, :banned, :remaining, :keys_with_values
+
+    def initialize( reqs , attributes, values)
+      @reqs = reqs.dup
+      @accepted = []
+      @banned = []
+      @remaining = attributes.dup
+      @keys_with_values = values.each_with_object([]){|(k,v),populated| populated.push(k) unless v == nil}
+    end
+
+    def process
+      process_required
+      process_exclusive
+      process_exactly
+      process_at_least
+      process_at_most
+      # Just add the ones that haven't been explicitly rejected
+      self.accepted += self.remaining
+      self.remaining = []
+      self.accepted.uniq!
+      self.accepted
+    end
+
+    def process_required
+      self.reqs = reqs.each_with_object([]) do |req, rest|
+        if req[:type] == :all
+          self.accepted += req[:attributes]
+          self.remaining -= req[:attributes]
+        else
+          rest.push req
+        end
+      end
+    end
+
+     def process_exclusive
+       self.reqs = reqs.each_with_object([]) do |req, rest|
+         if req[:type] == :exclusive ||
+           (req[:type] == :exactly && req[:count] == 1 ) ||
+           (req[:type] == :at_most && req[:count] == 1 )
+           process_exclusive_set(Array.new(req[:attributes]))
+         else
+           rest.push req
+         end
+       end
+     end
+
+     def process_at_least
+       self.reqs = reqs.each_with_object([]) do |req, rest|
+         if req[:type] == :at_least
+           process_at_least_set(Array.new(req[:attributes]), req[:count])
+         else
+           rest.push req
+         end
+       end
+     end
+
+     def process_at_most
+      self.reqs = reqs.each_with_object([]) do |req, rest|
+        if req[:type] == :at_most && req[:count] > 1 # count=1 is already handled in exclusive
+          process_at_most_set(Array.new(req[:attributes]), req[:count])
+        else
+          rest.push req
+        end
+      end
+     end
+
+     def process_exactly
+      self.reqs = reqs.each_with_object([]) do |req, rest|
+        if req[:type] == :exactly && req[:count] > 1 # count=1 is already handled in exclusive
+          process_exactly_set(Array.new(req[:attributes]), req[:count])
+        else
+          rest.push req
+        end
+      end
+     end
+
+     #################
+
+     def process_exclusive_set( exclusive_set )
+       feasible = exclusive_set - banned # available ones to pick (that are not banned)
+       # Try to favor attributes that come in with some values, otherwise get the first feasible one
+       preferred = feasible & keys_with_values
+       pick = (preferred.size == 0 ? feasible : preferred).first
+
+       if pick
+         self.accepted.push( pick )
+       else
+         raise UnfeasibleRequirementsError unless exclusive_set.empty?
+       end
+       self.banned += (feasible - [pick])
+       self.remaining -= exclusive_set
+     end
+
+     def process_at_least_set( at_least_set, count)
+       feasible = at_least_set - banned # available ones to pick (that are not banned)
+       preferred = (feasible & keys_with_values)[0,count]
+       # Add more if not enough
+       pick = if preferred.size < count
+         preferred + (feasible - preferred)[0,count-preferred.size]
+       else
+         preferred
+       end
+
+       unless pick.size == count
+         raise UnfeasibleRequirementsError
+       end
+       self.accepted += pick
+       self.remaining -= pick
+     end
+
+     def process_at_most_set( set, count)
+       ceil=(count+1)/2
+       feasible = set - banned # available ones to pick (that are not banned)
+       preferred = (feasible & keys_with_values)[0,ceil]
+
+       pick = if preferred.size < ceil
+         preferred + (feasible - preferred)[0,(ceil)-preferred.size]
+       else
+         preferred
+       end
+
+       self.accepted += pick
+       self.remaining -= pick
+     end
+
+     def process_exactly_set( set, count)
+       feasible = set - banned # available ones to pick (that are not banned)
+       preferred = (feasible & keys_with_values)[0,count]
+
+       pick = if preferred.size < count
+         preferred + (feasible - preferred)[0,count-preferred.size]
+       else
+         preferred
+       end
+
+       unless pick.size == count
+         raise UnfeasibleRequirementsError
+       end
+
+       self.accepted += pick
+       self.remaining -= pick
+     end
+
+
+  end
+end

data/lib/attributor/type.rb

@@ -2,9 +2,7 @@ module Attributor
   # It is the abstract base class to hold an attribute, both a leaf and a container (hash/Array...)
   # TODO: should this be a mixin since it is an abstract class?
   module Type
-    def self.included(klass)
-      klass.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
       # Does this type support the generation of subtypes?
@@ -29,7 +27,7 @@ module Attributor
       def load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
         return nil if value.nil?
         unless value.is_a?(native_type)
-          raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self
+          raise Attributor::IncompatibleTypeError.new(context: context, value_type: value.class, type: self)
         end
 
         value
@@ -124,6 +122,31 @@ module Attributor
       def family
         'any'
       end
+
+      # Default no format in case it's a string type
+      def json_schema_string_format
+        nil
+      end
+  
+      def as_json_schema( shallow: false, example: nil, attribute_options: {} )
+        type_name = self.ancestors.find { |k| k.name && !k.name.empty? }.name
+        hash = { type: json_schema_type, 'x-type_name': type_name.gsub( Attributor::MODULE_PREFIX_REGEX, '' )}
+        # Add a format, if the type has defined
+        if hash[:type] == :string && the_format = json_schema_string_format
+          hash[:format] = the_format
+        end
+        hash
+      end
+
+      def describe_option( option_name, option_value )
+        return case option_name
+        when :description
+          option_value
+        else
+          option_value  # By default, describing an option returns the hash with the specification
+        end
+      end
+
     end
   end
 end