attributor 5.0.2 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b19e77ce8b1772454840886e1a1bda5bc248c63
-  data.tar.gz: 32f9bca389ef6c112a7d8edf81cf8adc001ca2fd
+  metadata.gz: fe4a2dca77307723d8c18e4f37ded9cba8e54657
+  data.tar.gz: 175d9d21dd78aaba4e6c534559290cb79d3bf3a2
 SHA512:
-  metadata.gz: dc0fadeddc769124b2b60e717c48d435d88caf15cb6779b0784840c0bdcbbb4efce092fe4648dc8fd14a7b18958c0142dc8e6b52318b44f0b80b0c6f516e4a92
-  data.tar.gz: 6bfe838ad696d85db73ee1893a1d4f7739958180cb4f0f1a35ca5e8ff5ebb1a11bdde7bd10c23645623390cde56a6b95e72321ec819579068bac7b56037281c6
+  metadata.gz: 89de22ecae27da14b59f57b2ea87d3552c6d1dbdd338e07934bc29031fd4e65b664f4faf04fb50f56b2e3687cde7580ba217562a413856fa8cdb403c9bc4a335
+  data.tar.gz: d8beb7bba6e226b84d1608d080800e65ce632d3b9af0daeb6fa7415f0477d307d63ac9267b4ffd659fe846b9f1b0b3012d4853d8a1bb6a3d4bad4ff037aaa10b

data/.rubocop.yml

@@ -0,0 +1,30 @@
+AllCops:
+  TargetRubyVersion: 2.2
+Style/Documentation:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/LineLength:
+  Max: 200
+Style/RedundantSelf:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Lint/Debugger:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Style/CaseEquality:
+  Enabled: false
+Lint/UnusedMethodArgument:
+  AllowUnusedKeywordArguments: true
+
+# Offense count: 13
+Metrics/CyclomaticComplexity:
+  Max: 28
+
+# Offense count: 11
+Metrics/PerceivedComplexity:
+  Max: 23

data/.travis.yml

@@ -1,9 +1,11 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.1.5
-  - 2.2.2
-script: bundle exec rspec spec
+  - 2.2.5
+  - 2.3.1
+script:
+  - bundle exec rspec spec
+  - bundle exec rubocop --format=clang
 branches:
   only:
-    - master
+    - master

data/CHANGELOG.md

@@ -2,10 +2,15 @@
 
 ## next
 
+## 5.1
+
+* Added `Polymorphic` type. See [polymorphics.rb](spec/support/polymorphics.rb) for example usage.
+
 ## 5.0.2
 
 * Introduce the `Dumpable` (empty) module as an interface to indicate that instances of types that include it
-will respond to the `.dump` method, as a way to convert their internal substructure to primitive Ruby objects.    * Currently the only two directly dumpable types are Collection and Hash (with the caveat that there are several others that derive from them..i.e., CSV, Model, etc...)
+will respond to the `.dump` method, as a way to convert their internal substructure to primitive Ruby objects.
+  * Currently the only two directly dumpable types are Collection and Hash (with the caveat that there are several others that derive from them..i.e., CSV, Model, etc...)
   * The rest of types have `native_types` that are already Ruby primitive Objects.
 * Fixed Hash and Model requirements to treat nil values as missing keys (to be compatible with the `required: true` option on an attribute).
 

data/Gemfile

@@ -1,3 +1,3 @@
 source 'https://rubygems.org'
 
-gemspec
+gemspec

data/Guardfile

@@ -1,12 +1,18 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard :rspec, cmd: 'bundle exec rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/attributor/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-  watch('lib/attributor/base.rb') { "spec" }
-  watch('spec/support/models.rb') { "spec" }
-  watch('lib/attributor.rb') { 'spec' }
-end
+group :red_green_refactor, halt_on_fail: true do
+  guard :rspec, cmd: 'bundle exec rspec' do
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^lib/attributor/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+    watch('spec/spec_helper.rb') { 'spec' }
+    watch('lib/attributor/base.rb') { 'spec' }
+    watch('spec/support/models.rb') { 'spec' }
+    watch('lib/attributor.rb') { 'spec' }
+  end
 
+  guard :rubocop, cli: '--auto-correct --display-cop-names' do
+    watch(/.+\.rb$/)
+    watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+  end
+end

data/Rakefile

@@ -7,14 +7,13 @@ require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
 require 'rake/notes/rake_task'
 
-
-desc "Run RSpec code examples with simplecov"
+desc 'Run RSpec code examples with simplecov'
 RSpec::Core::RakeTask.new do |spec|
-  spec.rspec_opts = ["-c"]
+  spec.rspec_opts = ['-c']
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-desc "console"
+desc 'console'
 task :console do
   require 'bundler'
   Bundler.require(:default, :development, :test)
@@ -22,7 +21,7 @@ task :console do
   pry
 end
 
-task :default => :spec
+task default: :spec
 
 require 'yard'
 YARD::Rake::YardocTask.new

data/attributor.gemspec

@@ -5,38 +5,43 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'attributor/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "attributor"
-  spec.version       = Attributor::VERSION
-  spec.authors = ["Josep M. Blanquer","Dane Jensen"]
-  spec.summary = "A powerful attribute and type management library for Ruby"
-  spec.email = ["blanquer@gmail.com","dane.jensen@gmail.com"]
+  spec.name = 'attributor'
+  spec.version = Attributor::VERSION
+  spec.authors = ['Josep M. Blanquer', 'Dane Jensen']
+  spec.summary = 'A powerful attribute and type management library for Ruby'
+  spec.email = ['blanquer@gmail.com', 'dane.jensen@gmail.com']
 
-  spec.homepage = "https://github.com/rightscale/attributor"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">=2.1"
+  spec.homepage = 'https://github.com/rightscale/attributor'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>=2.1'
 
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
   spec.files         = `git ls-files -z`.split("\x0")
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 
-  spec.add_runtime_dependency(%q<hashie>, ["~> 3"])
-  spec.add_runtime_dependency(%q<randexp>, ["~> 0"])
-  spec.add_runtime_dependency(%q<activesupport>, ['>= 3'])
-
-  spec.add_development_dependency(%q<rspec>, ["< 2.99"])
-  spec.add_development_dependency(%q<yard>, ["~> 0.8.7"])
-  spec.add_development_dependency(%q<backports>, ["~> 3"])
-  spec.add_development_dependency(%q<yardstick>, ["~> 0"])
-  spec.add_development_dependency(%q<redcarpet>, ["< 3.0"])
-  spec.add_development_dependency(%q<bundler>, [">= 0"])
-  spec.add_development_dependency(%q<rake-notes>, ["~> 0"])
-  spec.add_development_dependency(%q<coveralls>)
-  spec.add_development_dependency(%q<guard>, ["~> 2"])
-  spec.add_development_dependency(%q<guard-rspec>, ["~> 4"])
-  spec.add_development_dependency(%q<pry>, ["~> 0"])
-  spec.add_development_dependency(%q<pry-byebug>, ["~> 1"])
-  spec.add_development_dependency(%q<pry-stack_explorer>, ["~> 0"])
-  spec.add_development_dependency(%q<fuubar>, ["~> 1"])
-
-  spec.add_development_dependency(%q<parslet>, [">= 0"])
+  spec.add_runtime_dependency('hashie', ['~> 3'])
+  spec.add_runtime_dependency('randexp', ['~> 0'])
+  spec.add_runtime_dependency('activesupport', ['>= 3'])
+
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'rspec-its'
+  spec.add_development_dependency 'rspec-collection_matchers', '~> 1'
+  spec.add_development_dependency('yard', ['~> 0.8.7'])
+  spec.add_development_dependency('backports', ['~> 3'])
+  spec.add_development_dependency('yardstick', ['~> 0'])
+  spec.add_development_dependency('bundler', ['>= 0'])
+  spec.add_development_dependency('rake-notes', ['~> 0'])
+  spec.add_development_dependency('coveralls')
+  spec.add_development_dependency('guard', ['~> 2'])
+  spec.add_development_dependency('guard-rspec', ['~> 4'])
+  spec.add_development_dependency('pry', ['~> 0'])
+  if RUBY_PLATFORM !~ /java/
+    spec.add_development_dependency('pry-byebug', ['~> 1'])
+    spec.add_development_dependency('pry-stack_explorer', ['~> 0'])
+  end
+  spec.add_development_dependency 'fuubar'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'guard-rubocop'
+
+  spec.add_development_dependency('parslet', ['>= 0'])
 end

data/lib/attributor.rb

@@ -6,7 +6,6 @@ require 'hashie'
 require 'digest/sha1'
 
 module Attributor
-
   require_relative 'attributor/dumpable'
 
   require_relative 'attributor/exceptions'
@@ -20,45 +19,41 @@ module Attributor
 
   require_relative 'attributor/extensions/randexp'
 
-
   # hierarchical separator string for composing human readable attributes
   SEPARATOR = '.'.freeze
   DEFAULT_ROOT_CONTEXT = ['$'].freeze
 
   # @param type [Class] The class of the type to resolve
   #
-  def self.resolve_type(attr_type, options={}, constructor_block=nil)
-    if attr_type < Attributor::Type
-      klass = attr_type
-    else
-      name = attr_type.name.split("::").last # TOO EXPENSIVE?
-
-      klass = const_get(name) if const_defined?(name)
-      raise AttributorException.new("Could not find class with name #{name}") unless klass
-      raise AttributorException.new("Could not find attribute type for: #{name} [klass: #{klass.name}]")  unless  klass < Attributor::Type
-    end
+  def self.resolve_type(attr_type, options = {}, constructor_block = nil)
+    klass = self.find_type(attr_type)
 
-    if klass.constructable?
-      return klass.construct(constructor_block, options)
-    end
+    return klass.construct(constructor_block, options) if klass.constructable?
+    raise AttributorException, "Type: #{attr_type} does not support anonymous generation" if constructor_block
+
+    klass
+  end
 
-    raise AttributorException.new("Type: #{attr_type} does not support anonymous generation") if constructor_block
+  def self.find_type(attr_type)
+    return attr_type if attr_type < Attributor::Type
+    name = attr_type.name.split('::').last # TOO EXPENSIVE?
 
+    klass = const_get(name) if const_defined?(name)
+    raise AttributorException, "Could not find class with name #{name}" unless klass
+    raise AttributorException, "Could not find attribute type for: #{name} [klass: #{klass.name}]" unless klass < Attributor::Type
     klass
   end
 
   def self.type_name(type)
-    return self.type_name(type.class) unless type.kind_of?(::Class)
+    return type_name(type.class) unless type.is_a?(::Class)
 
     type.ancestors.find { |k| k.name && !k.name.empty? }.name
   end
 
-  def self.humanize_context( context )
-    return "" unless context
+  def self.humanize_context(context)
+    return '' unless context
 
-    if context.kind_of? ::String
-      context = Array(context)
-    end
+    context = Array(context) if context.is_a? ::String
 
     unless context.is_a? Enumerable
       raise "INVALID CONTEXT!!! (got: #{context.inspect})"
@@ -66,18 +61,18 @@ module Attributor
 
     begin
       return context.join('.')
-    rescue Exception => e
+    rescue e
       raise "Error creating context string: #{e.message}"
     end
   end
 
-  def self.errorize_value( value )
-    inspection =value.inspect
-    inspection = inspection[0..500]+ "...[truncated]" if inspection.size>500
+  def self.errorize_value(value)
+    inspection = value.inspect
+    inspection = inspection[0..500] + '...[truncated]' if inspection.size > 500
     inspection
   end
 
-  MODULE_PREFIX       = "Attributor\:\:".freeze
+  MODULE_PREFIX       = 'Attributor::'.freeze
   MODULE_PREFIX_REGEX = ::Regexp.new(MODULE_PREFIX)
 
   require_relative 'attributor/families/numeric'
@@ -101,7 +96,7 @@ module Attributor
   require_relative 'attributor/types/model'
   require_relative 'attributor/types/struct'
   require_relative 'attributor/types/class'
-
+  require_relative 'attributor/types/polymorphic'
 
   require_relative 'attributor/types/csv'
   require_relative 'attributor/types/ids'
@@ -110,5 +105,4 @@ module Attributor
   require_relative 'attributor/types/tempfile'
   require_relative 'attributor/types/file_upload'
   require_relative 'attributor/types/uri'
-
 end

data/lib/attributor/attribute.rb

@@ -1,13 +1,15 @@
 # TODO: profile keys for attributes, test as frozen strings
 
 module Attributor
-
   class FakeParent < ::BasicObject
+    def respond_to_missing?(_method_name)
+      true
+    end
 
-    def method_missing(name, *args)
-      ::Kernel.warn "Warning, you have tried to access the '#{name}' method of the 'parent' argument of a Proc-defined :default values." +
-                    "Those Procs should completely ignore the 'parent' attribute for the moment as it will be set to an " +
-                    "instance of a useless class (until the framework can provide such functionality)"
+    def method_missing(name, *_args) # rubocop:disable Style/MethodMissing
+      ::Kernel.warn "Warning, you have tried to access the '#{name}' method of the 'parent' argument of a Proc-defined :default values." \
+                    "Those Procs should completely ignore the 'parent' attribute for the moment as it will be set to an " \
+                    'instance of a useless class (until the framework can provide such functionality)'
       nil
     end
 
@@ -18,58 +20,53 @@ 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?
   class Attribute
-
     attr_reader :type, :options
 
     # @options: metadata about the attribute
     # @block: code definition for struct attributes (nil for predefined types or leaf/simple types)
-    def initialize(type, options={}, &block)
+    def initialize(type, options = {}, &block)
       @type = Attributor.resolve_type(type, options, block)
 
       @options = options
-      if @type.respond_to?(:options)
-        @options = @type.options.merge(@options)
-      end
+      @options = @type.options.merge(@options) if @type.respond_to?(:options)
 
       check_options!
     end
 
-    def ==(attribute)
-      raise ArgumentError, "can not compare Attribute with #{attribute.class.name}" unless attribute.kind_of?(Attribute)
+    def ==(other)
+      raise ArgumentError, "can not compare Attribute with #{other.class.name}" unless other.is_a?(Attribute)
 
-      self.type == attribute.type &&
-        self.options == attribute.options
+      type == other.type &&
+        options == other.options
     end
 
+    def parse(value, context = Attributor::DEFAULT_ROOT_CONTEXT)
+      object = load(value, context)
 
-   def parse(value, context=Attributor::DEFAULT_ROOT_CONTEXT)
-     object = self.load(value,context)
-
-     errors = self.validate(object,context)
-     [ object, errors ]
-   end
-
+      errors = validate(object, context)
+      [object, errors]
+    end
 
-    def load(value, context=Attributor::DEFAULT_ROOT_CONTEXT,  **options)
-      value = type.load(value,context,**options)
+    def load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      value = type.load(value, context, **options)
 
-      if value.nil? && self.options.has_key?(:default)
+      if value.nil? && self.options.key?(:default)
         defined_val = self.options[:default]
         val = case defined_val
-        when ::Proc
-          fake_parent = FakeParent.new
-          # TODO: we can only support "context" as a parameter to the proc for now, since we don't have the parent...
-          if defined_val.arity == 2
-            defined_val.call(fake_parent, context)
-          elsif defined_val.arity == 1
-            defined_val.call(fake_parent)
-          else
-            defined_val.call
-          end
-        else
-          defined_val
-        end
-        value = val #Need to load?
+              when ::Proc
+                fake_parent = FakeParent.new
+                # TODO: we can only support "context" as a parameter to the proc for now, since we don't have the parent...
+                if defined_val.arity == 2
+                  defined_val.call(fake_parent, context)
+                elsif defined_val.arity == 1
+                  defined_val.call(fake_parent)
+                else
+                  defined_val.call
+                end
+              else
+                defined_val
+              end
+        value = val # Need to load?
       end
 
       value
@@ -83,148 +80,136 @@ module Attributor
       type.dump(value, **opts)
     end
 
-
     def validate_type(value, context)
       # delegate check to type subclass if it exists
-      unless self.type.valid_type?(value)
+      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: #{self.type.name})"
+        msg += "(got: #{value.class.name}, expected: #{type.name})"
         return [msg]
       end
       []
     end
 
+    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
 
-    TOP_LEVEL_OPTIONS = [ :description, :values, :default, :example, :required, :required_if, :custom_data ]
-    INTERNAL_OPTIONS = [:dsl_compiler,:dsl_compiler_options] # Options we don't want to expose when describing attributes
-
-    def describe(shallow=true, example: nil)
-      description = { }
+    def describe(shallow = true, example: nil)
+      description = {}
       # Clone the common options
       TOP_LEVEL_OPTIONS.each do |option_name|
-        description[option_name] = self.options[option_name] if self.options.has_key? option_name
+        description[option_name] = options[option_name] if options.key? option_name
       end
 
       # Make sure this option definition is not mistaken for the real generated example
-      if ( ex_def = description.delete(:example) )
+      if (ex_def = description.delete(:example))
         description[:example_definition] = ex_def
       end
 
-      special_options = self.options.keys - TOP_LEVEL_OPTIONS - INTERNAL_OPTIONS
+      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] = self.options[opt_name]
+        description[:options][opt_name] = options[opt_name]
       end
       # Change the reference option to the actual class name.
-      if ( reference = self.options[:reference] )
+      if (reference = options[:reference])
         description[:options][:reference] = reference.name
       end
 
-      description[:type] = self.type.describe(shallow, example: example )
+      description[:type] = type.describe(shallow, example: example)
       # Move over any example from the type, into the attribute itself
-      if ( ex = description[:type].delete(:example) )
-        description[:example] = self.dump(ex)
+      if (ex = description[:type].delete(:example))
+        description[:example] = dump(ex)
       end
 
       description
     end
 
-
     def example_from_options(parent, context)
-      val = self.options[:example]
+      val = options[:example]
       generated = case val
-      when ::Regexp
-        val.gen
-      when ::Proc
-        if val.arity == 2
-          val.call(parent, context)
-        elsif val.arity == 1
-          val.call(parent)
-        else
-          val.call
-        end
-      when nil
-        nil
-      else
-        val
-      end
-      self.load( generated, context )
+                  when ::Regexp
+                    val.gen
+                  when ::Proc
+                    if val.arity == 2
+                      val.call(parent, context)
+                    elsif val.arity == 1
+                      val.call(parent)
+                    else
+                      val.call
+                    end
+                  when nil
+                    nil
+                  else
+                    val
+                  end
+      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 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")
+        seed, = Digest::SHA1.digest(ctx).unpack('QQ')
         Random.srand(seed)
       else
         context = Attributor::DEFAULT_ROOT_CONTEXT
       end
 
-      if self.options.has_key? :example
+      if options.key? :example
         loaded = example_from_options(parent, context)
-        errors = self.validate(loaded, context)
+        errors = validate(loaded, context)
         raise AttributorException, "Error generating example for #{Attributor.humanize_context(context)}. Errors: #{errors.inspect}" if errors.any?
-        loaded
-      else
-        if (option_values = self.options[:values])
-          option_values.pick
-        else
-          if type.respond_to?(:attributes)
-            self.type.example(context, values)
-          else
-            self.type.example(context, options: self.options)
-          end
-        end
+        return loaded
       end
-    end
 
+      return options[:values].pick if options.key? :values
 
-    def attributes
-      if (@type_has_attributes ||= type.respond_to?(:attributes))
-        type.attributes
+      if type.respond_to?(:attributes)
+        type.example(context, values)
       else
-        nil
+        type.example(context, options: options)
       end
     end
 
+    def attributes
+      type.attributes if @type_has_attributes ||= type.respond_to?(:attributes)
+    end
 
     # Validates stuff and checks dependencies
-    def validate(object, context=Attributor::DEFAULT_ROOT_CONTEXT )
+    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 self.validate_missing_value(context)
+        return validate_missing_value(context)
       end
 
       # TODO: support validation for other types of conditional dependencies based on values of other attributes
 
-      errors = self.validate_type(object,context)
+      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 self.options[:values] && !self.options[:values].include?(object)
-        errors << "Attribute #{Attributor.humanize_context(context)}: #{Attributor.errorize_value(object)} is not within the allowed values=#{self.options[:values].inspect} "
+      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 + self.type.validate(object,context,self)
+      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 self.options[:required]
+      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 = self.options[:required_if]
+      requirement = options[:required_if]
       return [] unless requirement
 
       case requirement
@@ -237,7 +222,7 @@ module Attributor
         predicate = requirement.values.first
       else
         # should never get here if the option validation worked...
-        raise AttributorException.new("unknown type of dependency: #{requirement.inspect} for #{Attributor.humanize_context(context)}")
+        raise AttributorException, "unknown type of dependency: #{requirement.inspect} for #{Attributor.humanize_context(context)}"
       end
 
       # chop off the last part
@@ -253,11 +238,11 @@ module Attributor
           message << "(for #{Attributor.humanize_context(requirement_context)}) "
         end
 
-        if predicate
-          message << "matches #{predicate.inspect}."
-        else
-          message << "is present."
-        end
+        message << if predicate
+                     "matches #{predicate.inspect}."
+                   else
+                     'is present.'
+                   end
 
         [message]
       else
@@ -265,48 +250,44 @@ module Attributor
       end
     end
 
-
     def check_options!
-      self.options.each do |option_name, option_value|
-        if self.check_option!(option_name, option_value) == :unknown
-          if self.type.check_option!(option_name, option_value) == :unknown
-            raise AttributorException.new("unsupported option: #{option_name} with value: #{option_value.inspect} for attribute: #{self.inspect}")
-          end
+      options.each do |option_name, option_value|
+        next unless check_option!(option_name, option_value) == :unknown
+        if type.check_option!(option_name, option_value) == :unknown
+          raise AttributorException, "unsupported option: #{option_name} with value: #{option_value.inspect} for attribute: #{inspect}"
         end
       end
 
       true
     end
 
-
     # TODO: override in type subclass
     def check_option!(name, definition)
       case name
       when :values
-        raise AttributorException.new("Allowed set of values requires an array. Got (#{definition})") unless definition.is_a? ::Array
+        raise AttributorException, "Allowed set of values requires an array. Got (#{definition})" unless definition.is_a? ::Array
       when :default
-        raise AttributorException.new("Default value doesn't have the correct attribute type. Got (#{definition.inspect})") unless self.type.valid_type?(definition) || definition.kind_of?(Proc)
-        self.options[:default] = self.load(definition) unless definition.kind_of?(Proc)
+        raise AttributorException, "Default value doesn't have the correct attribute type. Got (#{definition.inspect})" unless type.valid_type?(definition) || definition.is_a?(Proc)
+        options[:default] = load(definition) unless definition.is_a?(Proc)
       when :description
-        raise AttributorException.new("Description value must be a string. Got (#{definition})") unless definition.is_a? ::String
+        raise AttributorException, "Description value must be a string. Got (#{definition})" unless definition.is_a? ::String
       when :required
-        raise AttributorException.new("Required must be a boolean") unless !!definition == definition # Boolean check
-        raise AttributorException.new("Required cannot be enabled in combination with :default") if definition == true && options.has_key?(:default)
+        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.new("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.new("Required_if cannot be specified together with :required") if self.options[:required]
+        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 :example
-        unless definition.is_a?(::Regexp) || definition.is_a?(::String) || definition.is_a?(::Array) || definition.is_a?(::Proc) || definition.nil? || self.type.valid_type?(definition)
-          raise AttributorException.new("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)")
+        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)"
         end
       when :custom_data
-        raise AttributorException.new("custom_data must be a Hash. Got (#{definition})") unless definition.is_a?(::Hash)
+        raise AttributorException, "custom_data must be a Hash. Got (#{definition})" unless definition.is_a?(::Hash)
       else
         return :unknown # unknown option
       end
 
       :ok # passes
     end
-
   end
 end