attributor 5.0.2 → 5.1.0

data/lib/attributor/type.rb

@@ -1,38 +1,34 @@
 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
 
     module ClassMethods
-
       # Does this type support the generation of subtypes?
       def constructable?
         false
       end
 
       # Allow a type to be marked as if it was anonymous (i.e. not referenceable by name)
-      def anonymous_type(val=true)
+      def anonymous_type(val = true)
         @_anonymous = val
       end
 
       def anonymous?
-        if @_anonymous == nil
-          self.name == nil # if nothing is set, consider it anonymous if the class does not have a name
+        if @_anonymous.nil?
+          name.nil? # if nothing is set, consider it anonymous if the class does not have a name
         else
           @_anonymous
         end
       end
 
-
       # Generic decoding and coercion of the attribute.
-      def load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      def load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
         return nil if value.nil?
-        unless value.is_a?(self.native_type)
+        unless value.is_a?(native_type)
           raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self
         end
 
@@ -40,13 +36,13 @@ module Attributor
       end
 
       # Generic encoding of the attribute
-      def dump(value,**opts)
+      def dump(value, **_opts)
         value
       end
 
       # TODO: refactor this to take just the options instead of the full attribute?
       # TODO: delegate to subclass
-      def validate(value,context=Attributor::DEFAULT_ROOT_CONTEXT,attribute)
+      def validate(value, context = Attributor::DEFAULT_ROOT_CONTEXT, attribute) # rubocop:disable Style/OptionalArguments
         errors = []
         attribute.options.each do |option, opt_definition|
           case option
@@ -55,7 +51,7 @@ module Attributor
           when :min
             errors << "#{Attributor.humanize_context(context)} value (#{value}) is smaller than the allowed min (#{opt_definition.inspect})" unless value >= opt_definition
           when :regexp
-            errors << "#{Attributor.humanize_context(context)} value (#{value}) does not match regexp (#{opt_definition.inspect})"  unless value =~ opt_definition
+            errors << "#{Attributor.humanize_context(context)} value (#{value}) does not match regexp (#{opt_definition.inspect})" unless value =~ opt_definition
           end
         end
         errors
@@ -65,35 +61,32 @@ module Attributor
       def valid_type?(value)
         return value.is_a?(native_type) if respond_to?(:native_type)
 
-        raise AttributorException.new("#{self} must implement #valid_type? or #native_type")
+        raise AttributorException, "#{self} must implement #valid_type? or #native_type"
       end
 
       # Default, overridable example function
-      def example(context=nil, options:{})
-        raise AttributorException.new("#{self} must implement #example")
+      def example(_context = nil, options: {})
+        raise AttributorException, "#{self} must implement #example"
       end
 
-
       # HELPER FUNCTIONS
 
-
       def check_option!(name, definition)
         case name
         when :min
-          raise AttributorException.new("Value for option :min does not implement '<='. Got: (#{definition.inspect})") unless definition.respond_to?(:<=)
+          raise AttributorException, "Value for option :min does not implement '<='. Got: (#{definition.inspect})" unless definition.respond_to?(:<=)
         when :max
-          raise AttributorException.new("Value for option :max does not implement '>='. Got(#{definition.inspect})") unless definition.respond_to?(:>=)
+          raise AttributorException, "Value for option :max does not implement '>='. Got(#{definition.inspect})" unless definition.respond_to?(:>=)
         when :regexp
           # could go for a respoind_to? :=~ here, but that seems overly... cute... and not useful.
-          raise AttributorException.new("Value for option :regexp is not a Regexp object. Got (#{definition.inspect})") unless definition.is_a? ::Regexp
+          raise AttributorException, "Value for option :regexp is not a Regexp object. Got (#{definition.inspect})" unless definition.is_a? ::Regexp
         else
           return :unknown
         end
 
-        return :ok
+        :ok
       end
 
-
       def generate_subcontext(context, subname)
         context + [subname]
       end
@@ -103,20 +96,20 @@ module Attributor
       end
 
       # By default, non complex types will not have a DSL subdefinition this handles such case
-      def compile_dsl( options, block )
-        raise AttributorException.new("Basic structures cannot take extra block definitions") if block
+      def compile_dsl(options, block)
+        raise AttributorException, 'Basic structures cannot take extra block definitions' if block
         # Simply create a DSL compiler to store the options, and not to parse any DSL
-        sub_definition=dsl_compiler.new( options )
-        return sub_definition
+        sub_definition = dsl_compiler.new(options)
+        sub_definition
       end
 
       # Default describe for simple types...only their name (stripping the base attributor module)
-      def describe(root=false, example: nil)
+      def describe(_root = false, example: nil)
         type_name = Attributor.type_name(self)
         hash = {
           name: type_name.gsub(Attributor::MODULE_PREFIX_REGEX, ''),
-          family: self.family,
-          id: self.id
+          family: family,
+          id: id
         }
         hash[:anonymous] = @_anonymous unless @_anonymous.nil?
         hash[:example] = example if example
@@ -124,14 +117,13 @@ module Attributor
       end
 
       def id
-        return nil if self.name.nil?
-        self.name.gsub('::'.freeze,'-'.freeze)
+        return nil if name.nil?
+        name.gsub('::'.freeze, '-'.freeze)
       end
 
       def family
         'any'
       end
-
     end
   end
 end

data/lib/attributor/types/bigdecimal.rb

@@ -1,27 +1,20 @@
 require 'bigdecimal'
 
 module Attributor
-
   class BigDecimal < Numeric
-
     def self.native_type
-      return ::BigDecimal
+      ::BigDecimal
     end
 
-    def self.example(context=nil, **options)
-      return ::BigDecimal.new("#{/\d{3}/.gen}.#{/\d{3}/.gen}")
+    def self.example(_context = nil, options: {})
+      ::BigDecimal.new("#{/\d{3}/.gen}.#{/\d{3}/.gen}")
     end
 
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, _context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
       return nil if value.nil?
-      return value if value.is_a?(self.native_type)
-      if value.kind_of?(::Float)
-        return BigDecimal(value, 10)
-      end
-      return BigDecimal(value)
+      return value if value.is_a?(native_type)
+      return BigDecimal(value, 10) if value.is_a?(::Float)
+      BigDecimal(value)
     end
-
   end
-
 end
-

data/lib/attributor/types/boolean.rb

@@ -3,7 +3,6 @@
 require_relative '../exceptions'
 
 module Attributor
-
   class Boolean
     include Type
 
@@ -11,23 +10,21 @@ module Attributor
       value == true || value == false
     end
 
-    def self.example(context=nil, options: {})
+    def self.example(_context = nil, options: {})
       [true, false].sample
     end
 
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
       return nil if value.nil?
 
-      raise CoercionError, context: context, from: value.class, to: self, value: value  if value.is_a?(::Float)
-      return false if [ false, 'false', 'FALSE', '0', 0, 'f', 'F' ].include?(value)
-      return true if [ true, 'true', 'TRUE', '1', 1, 't', 'T' ].include?(value)
+      raise CoercionError, context: context, from: value.class, to: self, value: value if value.is_a?(::Float)
+      return false if [false, 'false', 'FALSE', '0', 0, 'f', 'F'].include?(value)
+      return true if [true, 'true', 'TRUE', '1', 1, 't', 'T'].include?(value)
       raise CoercionError, context: context, from: value.class, to: self
     end
 
     def self.family
       'boolean'
     end
-
   end
 end
-

data/lib/attributor/types/class.rb

@@ -2,38 +2,37 @@ require 'active_support'
 
 require_relative '../exceptions'
 
-
 module Attributor
   class Class
     include Type
 
     def self.native_type
-      return ::Class
+      ::Class
     end
 
-    def self.load(value, context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-      return value if value.is_a?(self.native_type)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
+      return value if value.is_a?(native_type)
       return @klass || nil if value.nil?
 
       # Must be given a String object or nil
-      unless value.kind_of?(::String) || value.nil?
+      unless value.is_a?(::String) || value.nil?
         raise IncompatibleTypeError,  context: context, value_type: value.class, type: self
       end
 
-      value = "::" + value if value[0..1] != '::'
+      value = '::' + value if value[0..1] != '::'
       result = value.constantize
 
       # Class given must match class specified when type created using .of() method
       unless @klass.nil? || result == @klass
-        raise LoadError, "Error loading class #{value} for attribute with " +
-          "defined class #{@klass} while loading #{Attributor.humanize_context(context)}."
+        raise LoadError, "Error loading class #{value} for attribute with " \
+                         "defined class #{@klass} while loading #{Attributor.humanize_context(context)}."
       end
 
       result
     end
 
-    def self.example(context=nil, options:{})
-      @klass.nil? ? "MyClass" : @klass.name
+    def self.example(_context = nil, options: {})
+      @klass.nil? ? 'MyClass' : @klass.name
     end
 
     # Create a Class attribute type of a specific Class.

data/lib/attributor/types/collection.rb

@@ -2,7 +2,6 @@
 #
 
 module Attributor
-
   class Collection < Array
     include Container
     include Dumpable
@@ -15,7 +14,7 @@ module Attributor
     def self.of(type)
       resolved_type = Attributor.resolve_type(type)
       unless resolved_type.ancestors.include?(Attributor::Type)
-        raise Attributor::AttributorException.new("Collections can only have members that are Attributor::Types")
+        raise Attributor::AttributorException, 'Collections can only have members that are Attributor::Types'
       end
       ::Class.new(self) do
         @member_type = resolved_type
@@ -30,17 +29,16 @@ module Attributor
       end
     end
 
-    def self.options
-      @options
+    class << self
+      attr_reader :options
     end
 
-
     def self.native_type
       self
     end
 
     def self.valid_type?(type)
-      type.kind_of?(self) || type.kind_of?(::Enumerable)
+      type.is_a?(self) || type.is_a?(::Enumerable)
     end
 
     def self.family
@@ -53,16 +51,15 @@ module Attributor
 
     def self.member_attribute
       @member_attribute ||= begin
-        self.construct(nil,{})
+        construct(nil, {})
 
         @member_attribute
       end
     end
 
-
     # generates an example Collection
     # @return An Array of native type objects conforming to the specified member_type
-    def self.example(context=nil, options: {})
+    def self.example(context = nil, options: {})
       result = []
       size = options[:size] || (rand(3) + 1)
       size = [*size].sample if size.is_a?(Range)
@@ -76,74 +73,70 @@ module Attributor
 
       size.times do |i|
         subcontext = context + ["at(#{i})"]
-        result << self.member_attribute.example(subcontext)
+        result << member_attribute.example(subcontext)
       end
 
-      self.new(result)
+      new(result)
     end
 
-
     # The incoming value should be array-like here, so the only decoding that we need to do
     # is from the members (if there's an :member_type defined option).
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-      if value.nil?
-        return nil
-      elsif value.is_a?(Enumerable)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
+      return nil if value.nil?
+      if value.is_a?(Enumerable)
         loaded_value = value
       elsif value.is_a?(::String)
-        loaded_value = decode_string(value,context)
+        loaded_value = decode_string(value, context)
       elsif value.respond_to?(:to_a)
         loaded_value = value.to_a
       else
         raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self
       end
 
-      self.new(loaded_value.collect { |member| self.member_attribute.load(member,context) })
+      new(loaded_value.collect { |member| member_attribute.load(member, context) })
     end
 
-
-    def self.decode_string(value,context)
-      decode_json(value,context)
+    def self.decode_string(value, context)
+      decode_json(value, context)
     end
 
-
     def self.dump(values, **opts)
       return nil if values.nil?
-      values.collect { |value| member_attribute.dump(value,opts) }
+      values.collect { |value| member_attribute.dump(value, opts) }
     end
 
-    def self.describe(shallow=false, example: nil)
+    def self.describe(shallow = false, example: nil)
       hash = super(shallow)
       hash[:options] = {} unless hash[:options]
-      member_example = example.first if example
-      hash[:member_attribute] = self.member_attribute.describe(true, example: member_example )
+      if example
+        hash[:example] = example
+        member_example = example.first
+      end
+      hash[:member_attribute] = member_attribute.describe(true, example: member_example)
       hash
     end
 
-
     def self.constructable?
       true
     end
 
-
     def self.construct(constructor_block, options)
-      member_options =  (options[:member_options]  || {} ).clone
-      if options.has_key?(:reference) && !member_options.has_key?(:reference)
+      member_options = (options[:member_options] || {}).clone
+      if options.key?(:reference) && !member_options.key?(:reference)
         member_options[:reference] = options[:reference]
       end
 
       # create the member_attribute, passing in our member_type and whatever constructor_block is.
       # that in turn will call construct on the type if applicable.
-      @member_attribute = Attributor::Attribute.new self.member_type, member_options, &constructor_block
+      @member_attribute = Attributor::Attribute.new member_type, member_options, &constructor_block
 
       # overwrite our type with whatever type comes out of the attribute
       @member_type = @member_attribute.type
 
-      return self
+      self
     end
 
-
-    def self.check_option!(name, definition)
+    def self.check_option!(name, _definition)
       # TODO: support more options like :max_size
       case name
       when :reference
@@ -156,33 +149,30 @@ module Attributor
     end
 
     # @param object [Collection] Collection instance to validate.
-    def self.validate(object, context=Attributor::DEFAULT_ROOT_CONTEXT, attribute=nil)
+    def self.validate(object, context = Attributor::DEFAULT_ROOT_CONTEXT, _attribute = nil)
       context = [context] if context.is_a? ::String
 
-      unless object.kind_of?(self)
-        raise ArgumentError, "#{self.name} can not validate object of type #{object.class.name} for #{Attributor.humanize_context(context)}."
+      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
 
-    def self.validate_options( value, context, attribute )
+    def self.validate_options(_value, _context, _attribute)
       errors = []
       errors
     end
 
-
-    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      self.each_with_index.collect do |value, i|
+    def validate(context = Attributor::DEFAULT_ROOT_CONTEXT)
+      each_with_index.collect do |value, i|
         subcontext = context + ["at(#{i})"]
         self.class.member_attribute.validate(value, subcontext)
       end.flatten.compact
     end
 
-
     def dump(**opts)
-      self.collect { |value| self.class.member_attribute.dump(value,opts) }
+      collect { |value| self.class.member_attribute.dump(value, opts) }
     end
-
   end
 end