attributor 5.0.2 → 5.1.0

data/lib/attributor/types/ids.rb

@@ -1,8 +1,5 @@
 module Attributor
-
   class Ids < CSV
-
-
     def self.for(type)
       identity_name = type.options.fetch(:identity) do
         raise AttributorException, "no identity found for #{type.name}"
@@ -16,11 +13,10 @@ module Attributor
         @member_attribute = identity_attribute
         @member_type = identity_attribute.type
       end
-
     end
 
-    def self.of(type)
-      raise "Invalid definition of Ids type. Defining Ids.of(type) is not allowed, you probably meant to do Ids.for(type) instead"
+    def self.of(_type)
+      raise 'Invalid definition of Ids type. Defining Ids.of(type) is not allowed, you probably meant to do Ids.for(type) instead'
     end
   end
 end

data/lib/attributor/types/integer.rb

@@ -1,17 +1,14 @@
 
 
 module Attributor
-
   class Integer < Numeric
-
-    EXAMPLE_RANGE = 1000.freeze
+    EXAMPLE_RANGE = 1000
 
     def self.native_type
-      return ::Integer
+      ::Integer
     end
 
-
-    def self.example(context=nil, options: {})
+    def self.example(_context = nil, options: {})
       validate_options(options)
 
       # Set default values
@@ -30,33 +27,31 @@ module Attributor
       end
 
       # Generate random number on interval [min,max]
-      rand(max-min+1) + min
+      rand(max - min + 1) + min
     end
 
-    def self.load(value, context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
       Integer(value)
     rescue TypeError
       super
     end
 
     def self.validate_options(options)
-      if options.has_key?(:min) && options.has_key?(:max)
+      if options.key?(:min) && options.key?(:max)
         # Both :max and :min must be integers
-        raise AttributorException.new("Invalid range: [#{options[:min].inspect}, #{options[:max].inspect}]") if !options[:min].is_a?(::Integer) || !options[:max].is_a?(::Integer)
+        raise AttributorException, "Invalid range: [#{options[:min].inspect}, #{options[:max].inspect}]" if !options[:min].is_a?(::Integer) || !options[:max].is_a?(::Integer)
 
         # :max cannot be less than :min
-        raise AttributorException.new("Invalid range: [#{options[:min].inspect}, #{options[:max].inspect}]") if options[:max] < options[:min]
-      elsif !options.has_key?(:min) && options.has_key?(:max)
+        raise AttributorException, "Invalid range: [#{options[:min].inspect}, #{options[:max].inspect}]" if options[:max] < options[:min]
+      elsif !options.key?(:min) && options.key?(:max)
         # :max must be an integer
-        raise AttributorException.new("Invalid range: [, #{options[:max].inspect}]") if !options[:max].is_a?(::Integer)
-      elsif options.has_key?(:min) && !options.has_key?(:max)
+        raise AttributorException, "Invalid range: [, #{options[:max].inspect}]" unless options[:max].is_a?(::Integer)
+      elsif options.key?(:min) && !options.key?(:max)
         # :min must be an integer
-        raise AttributorException.new("Invalid range: [#{options[:min].inspect},]") if !options[:min].is_a?(::Integer)
-      else
+        raise AttributorException, "Invalid range: [#{options[:min].inspect},]" unless options[:min].is_a?(::Integer)
         # Neither :min nor :max were given, noop
       end
       true
     end
-
   end
 end

data/lib/attributor/types/model.rb

@@ -1,10 +1,13 @@
 module Attributor
   class Model < Hash
-
     # FIXME: this is not the way to fix this. Really we should add finalize! to Models.
-    undef :timeout
-    undef :format
-    undef :test rescue nil
+    begin
+      undef :timeout
+      undef :format
+      undef :test
+    rescue
+      nil
+    end
 
     if RUBY_ENGINE =~ /^jruby/
       # We are "forced" to require it here (in case hasn't been yet) to make sure the added methods have been applied
@@ -25,13 +28,12 @@ module Attributor
     @key_attribute = Attribute.new(@key_type)
     @value_attribute = Attribute.new(@value_type)
 
-
     def self.inherited(klass)
-      k = self.key_type
-      ka = self.key_attribute
+      k = key_type
+      ka = key_attribute
 
-      v = self.value_type
-      va = self.value_attribute
+      v = value_type
+      va = value_attribute
 
       klass.instance_eval do
         @saved_blocks = []
@@ -54,8 +56,8 @@ module Attributor
     #
     def self.define_accessors(name)
       name = name.to_sym
-      self.define_reader(name)
-      self.define_writer(name)
+      define_reader(name)
+      define_writer(name)
     end
 
     def self.define_reader(name)
@@ -66,12 +68,11 @@ module Attributor
       RUBY
     end
 
-
     def self.define_writer(name)
-      context = ["assignment","of(#{name})"].freeze
+      context = ['assignment', "of(#{name})"].freeze
       module_eval do
-        define_method(name.to_s + "=") do |value|
-          self.set(name, value, context: context)
+        define_method(name.to_s + '=') do |value|
+          set(name, value, context: context)
         end
       end
     end
@@ -79,12 +80,12 @@ module Attributor
     def self.check_option!(name, value)
       case name
       when :identity
-        raise AttributorException, "Invalid identity type #{value.inspect}" unless value.kind_of?(::Symbol)
-        :ok # FIXME ... actually do something smart, that doesn't break lazy attribute creation
+        raise AttributorException, "Invalid identity type #{value.inspect}" unless value.is_a?(::Symbol)
+        :ok # FIXME: ... actually do something smart, that doesn't break lazy attribute creation
       when :reference
-        :ok # FIXME ... actually do something smart
+        :ok # FIXME: ... actually do something smart
       when :dsl_compiler
-        :ok # FIXME ... actually do something smart
+        :ok # FIXME: ... actually do something smart
       when :dsl_compiler_options
         :ok
       else
@@ -96,17 +97,17 @@ module Attributor
       context + [subname]
     end
 
-    def self.example(context=nil, **values)
-      context ||= ["#{self.name || 'Struct'}-#{rand(10000000)}"]
+    def self.example(context = nil, **values)
+      context ||= ["#{name || 'Struct'}-#{rand(10_000_000)}"]
       context = Array(context)
 
-      if self.keys.any?
-        result = self.new
+      if keys.any?
+        result = new
         result.extend(ExampleMixin)
 
-        result.lazy_attributes = self.example_contents(context, result, values)
+        result.lazy_attributes = example_contents(context, result, values)
       else
-        result = self.new
+        result = new
       end
       result
     end
@@ -120,13 +121,11 @@ module Attributor
       end
     end
 
-
     # TODO: memoize validation results here, but only after rejiggering how we store the context.
     #       Two calls to validate() with different contexts should return get the same errors,
     #       but with their respective contexts.
-    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
-
-      raise AttributorException, "validation conflict" if @validating
+    def validate(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      raise AttributorException, 'validation conflict' if @validating
       @validating = true
 
       context = [context] if context.is_a? ::String
@@ -134,22 +133,20 @@ module Attributor
       errors = []
 
       self.class.attributes.each do |sub_attribute_name, sub_attribute|
-        sub_context = self.class.generate_subcontext(context,sub_attribute_name)
+        sub_context = self.class.generate_subcontext(context, sub_attribute_name)
 
-        value = self.__send__(sub_attribute_name)
-        unless value.nil?
-          keys_with_values << sub_attribute_name
-        end
+        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.push(*sub_attribute.validate(value, sub_context))
+        errors.concat sub_attribute.validate(value, sub_context)
       end
       self.class.requirements.each do |req|
         validation_errors = req.validate(keys_with_values, context)
-        errors.push(*validation_errors) unless validation_errors.empty?
+        errors.concat(validation_errors) unless validation_errors.empty?
       end
 
       errors
@@ -157,13 +154,11 @@ module Attributor
       @validating = false
     end
 
-
     def attributes
       @contents
     end
 
-
-    def respond_to_missing?(name,*)
+    def respond_to_missing?(name, *)
       attribute_name = name.to_s
       attribute_name.chomp!('=')
 
@@ -172,25 +167,23 @@ module Attributor
       super
     end
 
-
     def method_missing(name, *args)
       attribute_name = name.to_s
       attribute_name.chomp!('=')
 
-      if self.class.attributes.has_key?(attribute_name.to_sym)
+      if self.class.attributes.key?(attribute_name.to_sym)
         self.class.define_accessors(attribute_name)
-        return self.__send__(name, *args)
+        return __send__(name, *args)
       end
 
       super
     end
 
-
-    def dump(context: Attributor::DEFAULT_ROOT_CONTEXT, **opts)
+    def dump(context: Attributor::DEFAULT_ROOT_CONTEXT, **_opts)
       return CIRCULAR_REFERENCE_MARKER if @dumping
       @dumping = true
 
-      self.attributes.each_with_object({}) do |(name, value), hash|
+      attributes.each_with_object({}) do |(name, value), hash|
         attribute = self.class.attributes[name]
 
         # skip dumping undefined attributes
@@ -199,12 +192,10 @@ module Attributor
           next
         end
 
-        hash[name.to_sym] = attribute.dump(value, context: context + [name] )
+        hash[name.to_sym] = attribute.dump(value, context: context + [name])
       end
     ensure
       @dumping = false
     end
-
   end
-
 end

data/lib/attributor/types/object.rb

@@ -3,17 +3,15 @@
 require_relative '../exceptions'
 
 module Attributor
-
   class Object
     include Type
 
     def self.native_type
-      return ::BasicObject
+      ::BasicObject
     end
 
-    def self.example(context=nil, options:{})
+    def self.example(_context = nil, options: {})
       'An Object'
     end
-
   end
 end

data/lib/attributor/types/polymorphic.rb

@@ -0,0 +1,118 @@
+require 'active_support'
+
+require_relative '../exceptions'
+
+module Attributor
+  class Polymorphic
+    include Type
+
+    class << self
+      attr_reader :discriminator
+      attr_reader :types
+    end
+
+    def self.on(discriminator)
+      ::Class.new(self) do
+        @discriminator = discriminator
+      end
+    end
+
+    def self.given(value, type)
+      @types[value] = type
+    end
+
+    def self.inherited(klass)
+      klass.instance_eval do
+        @types = {}
+      end
+    end
+
+    def self.example(context = nil, **values)
+      types.values.pick.example(context, **values)
+    end
+
+    def self.valid_type?(value)
+      self.types.values.include?(value.class)
+    end
+
+    def self.constructable?
+      true
+    end
+
+    def self.native_type
+      self
+    end
+
+    def self.construct(constructor_block, **_options)
+      return self if constructor_block.nil?
+
+      self.instance_eval(&constructor_block)
+      self
+    end
+
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
+      return nil if value.nil?
+
+      return value if self.types.values.include?(value.class)
+
+      parsed_value = self.parse(value, context)
+
+      discriminator_value = discriminator_value_for(parsed_value)
+
+      type = self.types.fetch(discriminator_value) do
+        raise LoadError, "invalid value for discriminator: #{discriminator_value}"
+      end
+      type.load(parsed_value)
+    end
+
+    def self.discriminator_value_for(parsed_value)
+      return parsed_value[self.discriminator] if parsed_value.key?(self.discriminator)
+
+      value = case self.discriminator
+              when ::String
+                parsed_value[self.discriminator.to_sym]
+              when ::Symbol
+                parsed_value[self.discriminator.to_s]
+              end
+
+      return value if value
+
+      raise LoadError, "can't find key #{self.discriminator.inspect} in #{parsed_value.inspect}"
+    end
+
+    def self.dump(value, **opts)
+      if (loaded = load(value))
+        loaded.dump(**opts)
+      end
+    end
+
+    def self.parse(value, context)
+      if value.nil?
+        {}
+      elsif value.is_a?(Attributor::Hash)
+        value.contents
+      elsif value.is_a?(::Hash)
+        value
+      elsif value.is_a?(::String)
+        decode_json(value, context)
+      elsif value.respond_to?(:to_hash)
+        value.to_hash
+      else
+        raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self
+      end
+    end
+
+    def self.describe(shallow = false, example: nil)
+      super.merge(
+        discriminator: self.discriminator,
+        types: self.describe_types
+      )
+    end
+
+    def self.describe_types
+      self.types.each_with_object({}) do |(key, value), description|
+        description[key] = { type: value.describe(true) }
+      end
+    end
+  end
+end

data/lib/attributor/types/regexp.rb

@@ -5,11 +5,11 @@ module Attributor
     include Type
 
     def self.native_type
-      return ::Regexp
+      ::Regexp
     end
 
-    def self.load(value, context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-      unless value.kind_of?(::String) || value.nil?
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      unless value.is_a?(::String) || value.nil?
         raise IncompatibleTypeError,  context: context, value_type: value.class, type: self
       end
 
@@ -18,13 +18,12 @@ module Attributor
       super
     end
 
-    def self.example(context=nil, options:{})
+    def self.example(_context = nil, options: {})
       ::Regexp.new(/^pattern\d{0,3}$/).to_s
     end
 
     def self.family
       'string'
     end
-
   end
 end