attributor 5.0.2 → 5.1.0

data/lib/attributor/types/string.rb

@@ -3,12 +3,12 @@ module Attributor
     include Type
 
     def self.native_type
-      return ::String
+      ::String
     end
 
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-      if value.kind_of?(Enumerable)
-        raise IncompatibleTypeError,  context: context, value_type: value.class, type: self
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      if value.is_a?(Enumerable)
+        raise IncompatibleTypeError, context: context, value_type: value.class, type: self
       end
 
       value && String(value)
@@ -16,13 +16,13 @@ module Attributor
       super
     end
 
-    def self.example(context=nil, options:{})
+    def self.example(_context = nil, options: {})
       if options[:regexp]
         begin
           # It may fail to generate an example, see bug #72.
           options[:regexp].gen
         rescue => e
-          'Failed to generate example for %s : %s' % [ options[:regexp].inspect, e.message]
+          format('Failed to generate example for %s : %s', options[:regexp].inspect, e.message)
         end
       else
         /\w+/.gen
@@ -32,6 +32,5 @@ module Attributor
     def self.family
       'string'
     end
-
   end
 end

data/lib/attributor/types/struct.rb

@@ -1,13 +1,12 @@
 
 module Attributor
   class Struct < Attributor::Model
-
     def self.constructable?
       true
     end
 
     # Construct a new subclass, using attribute_definition to define attributes.
-    def self.construct(attribute_definition, options={})
+    def self.construct(attribute_definition, options = {})
       # if we're in a subclass of Struct, but not attribute_definition is provided, we're
       # not REALLY trying to define a new struct. more than likely Collection is calling
       # construct on us.
@@ -21,7 +20,7 @@ module Attributor
       return self if attribute_definition.nil?
 
       if options[:reference]
-        options.merge!(options[:reference].options) do |key, oldval, newval|
+        options.merge!(options[:reference].options) do |_key, oldval, _newval|
           oldval
         end
       end
@@ -29,25 +28,19 @@ module Attributor
       ::Class.new(self) do
         attributes options, &attribute_definition
       end
-
     end
 
-
     def self.definition
       # Could probably do this better, but its use should be memoized in the enclosing Attribute
-      if self == Attributor::Struct
-        raise AttributorException, "Can not use a pure Struct without defining sub-attributes"
-      else
-        super
-      end
-    end
+      raise AttributorException, 'Can not use a pure Struct without defining sub-attributes' if self == Attributor::Struct
 
+      super
+    end
 
     # Two structs are equal if their attributes are equal
-    def ==(other_object)
-      return false if other_object == nil || !other_object.respond_to?(:attributes)
-      self.attributes == other_object.attributes
+    def ==(other)
+      return false if other.nil? || !other.respond_to?(:attributes)
+      attributes == other.attributes
     end
-
   end
 end

data/lib/attributor/types/symbol.rb

@@ -3,24 +3,21 @@ module Attributor
     include Type
 
     def self.native_type
-      return ::Symbol
+      ::Symbol
     end
 
-
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
       value.to_sym
     rescue
       super
     end
 
-    def self.example(context=nil, options:{})
+    def self.example(_context = nil, options: {})
       :example
     end
 
     def self.family
       String.family
     end
-    
   end
-
 end

data/lib/attributor/types/tempfile.rb

@@ -5,22 +5,22 @@ module Attributor
     include Attributor::Type
 
     def self.native_type
-      return ::Tempfile
+      ::Tempfile
     end
 
-    def self.example(context=Attributor::DEFAULT_ROOT_CONTEXT, options:{})
+    def self.example(context = Attributor::DEFAULT_ROOT_CONTEXT, options: {})
       file = ::Tempfile.new(Attributor.humanize_context(context))
-      file.write /[:sentence:]/.gen
+      file.write Randgen.sentence
       file.write '.'
       file.rewind
       file
     end
 
-    def self.dump(value, **opts)
+    def self.dump(value, **_opts)
       value && value.read
     end
 
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
       # TODO: handle additional cases that make sense
       case value
       when ::String
@@ -38,6 +38,5 @@ module Attributor
     def self.family
       String.family
     end
-
   end
 end

data/lib/attributor/types/time.rb

@@ -1,39 +1,39 @@
 require 'date'
 
 module Attributor
-
   class Time < Temporal
     include Type
 
     def self.native_type
-      return ::Time
+      ::Time
     end
 
-    def self.example(context=nil, options: {})
-      return self.load(/[:time:]/.gen, context)
+    def self.example(context = nil, options: {})
+      load(Randgen.time, context)
     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 nil if value.nil?
 
       return value.to_time if value.respond_to?(:to_time)
 
+      self.parse(value, context)
+    end
+
+    def self.parse(value, context)
       case value
       when ::Integer
         return ::Time.at(value)
       when ::String
         begin
           return ::Time.parse(value)
-        rescue ArgumentError => e
-          raise Attributor::DeserializationError, context: context, from: value.class, encoding: "Time" , value: value
+        rescue ArgumentError
+          raise Attributor::DeserializationError, context: context, from: value.class, encoding: 'Time', value: value
         end
       else
         raise CoercionError, context: context, from: value.class, to: self, value: value
       end
     end
-
-    
   end
-
 end

data/lib/attributor/types/uri.rb

@@ -19,17 +19,17 @@ module Attributor
     end
 
     def self.native_type
-      return ::URI::Generic
+      ::URI::Generic
     end
 
-    def self.example(context=nil, options={})
-      URI(/[:uri:]/.gen)
+    def self.example(_context = nil, options: {})
+      URI(Randgen.uri)
     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?
       case value
-      when self.native_type
+      when native_type
         value
       when ::String
         URI(value)
@@ -38,11 +38,11 @@ module Attributor
       end
     end
 
-    def self.dump(value, **opts)
+    def self.dump(value, **_opts)
       value.to_s
     end
 
-    def self.validate(value,context=Attributor::DEFAULT_ROOT_CONTEXT,attribute)
+    def self.validate(value, context = Attributor::DEFAULT_ROOT_CONTEXT, attribute)
       errors = []
 
       if attribute && (definition = attribute.options[:path])
@@ -57,19 +57,18 @@ module Attributor
       case name
       when :path
         unless definition.is_a? ::Regexp
-          raise AttributorException.new("Value for option :path is not a Regexp object. Got (#{definition.inspect})")
+          raise AttributorException, "Value for option :path is not a Regexp object. Got (#{definition.inspect})"
         end
         :ok
       else
         :unknown
       end
     end
-
   end
 end
 
 class Randgen
   def self.uri
-    "http://example.com/#{word}/#{rand(10 ** 9)}"
+    "http://example.com/#{word}/#{rand(10**9)}"
   end
 end

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = '5.0.2'
+  VERSION = '5.1.0'.freeze
 end

data/spec/attribute_resolver_spec.rb

@@ -1,108 +1,102 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
-
 describe Attributor::AttributeResolver do
   let(:value) { /\w+/.gen }
 
   context 'registering and querying simple values' do
-    let(:name) { "string_value" }
-    before { subject.register(name,value) }
+    let(:name) { 'string_value' }
+    before { subject.register(name, value) }
 
     it 'works' do
-      subject.query(name).should be value
+      expect(subject.query(name)).to be value
     end
   end
 
-
   context 'querying and registering nested values' do
-    let(:one) { double(:two => value) }
-    let(:key) { "one.two" }
-    before { subject.register("one", one) }
+    let(:one) { double(two: value) }
+    let(:key) { 'one.two' }
+    before { subject.register('one', one) }
 
     it 'works' do
-      subject.query(key).should be value
+      expect(subject.query(key)).to be value
     end
   end
 
-
   context 'querying nested values from models' do
-    let(:instance) { double("instance", :ssh_key => ssh_key) }
-    let(:ssh_key) { double("ssh_key", :name => value) }
-    let(:key) { "instance.ssh_key.name" }
+    let(:instance) { double('instance', ssh_key: ssh_key) }
+    let(:ssh_key) { double('ssh_key', name: value) }
+    let(:key) { 'instance.ssh_key.name' }
 
     before { subject.register('instance', instance) }
 
     it 'works' do
-      subject.query("instance").should be instance
-      subject.query("instance.ssh_key").should be ssh_key
-      subject.query(key).should be value
+      expect(subject.query('instance')).to be instance
+      expect(subject.query('instance.ssh_key')).to be ssh_key
+      expect(subject.query(key)).to be value
     end
 
-
     context 'with a prefix' do
-      let(:key) { "name" }
-      let(:prefix) { "$.instance.ssh_key"}
+      let(:key) { 'name' }
+      let(:prefix) { '$.instance.ssh_key' }
       let(:value) { 'some_name' }
       it 'works' do
-        subject.query(key,prefix).should be(value)
+        expect(subject.query(key, prefix)).to be(value)
       end
     end
-
   end
 
-
   context 'querying values that do not exist' do
     context 'for a straight key' do
-      let(:key) { "missing" }
+      let(:key) { 'missing' }
       it 'returns nil' do
-        subject.query(key).should be_nil
+        expect(subject.query(key)).to be_nil
       end
     end
     context 'for a nested key' do
-      let(:key) { "nested.missing" }
+      let(:key) { 'nested.missing' }
       it 'returns nil' do
-        subject.query(key).should be_nil
+        expect(subject.query(key)).to be_nil
       end
     end
   end
 
   context 'querying collection indices from models' do
     let(:instances) { [instance1, instance2] }
-    let(:instance1) { double('instance1', :ssh_key => ssh_key1) }
-    let(:instance2) { double('instance2', :ssh_key => ssh_key2) }
-    let(:ssh_key1) { double('ssh_key', :name => value) }
-    let(:ssh_key2) { double('ssh_key', :name => 'second') }
+    let(:instance1) { double('instance1', ssh_key: ssh_key1) }
+    let(:instance2) { double('instance2', ssh_key: ssh_key2) }
+    let(:ssh_key1) { double('ssh_key', name: value) }
+    let(:ssh_key2) { double('ssh_key', name: 'second') }
     let(:args) { [path, prefix].compact }
 
     before { subject.register('instances', instances) }
 
     it 'resolves the index to the correct member of the collection' do
-      subject.query('instances').should be instances
-      subject.query('instances.at(1).ssh_key').should be ssh_key2
-      subject.query('instances.at(0).ssh_key.name').should be value
+      expect(subject.query('instances')).to be instances
+      expect(subject.query('instances.at(1).ssh_key')).to be ssh_key2
+      expect(subject.query('instances.at(0).ssh_key.name')).to be value
     end
 
     it 'returns nil for index out of range' do
-      subject.query('instances.at(2)').should be(nil)
-      subject.query('instances.at(-1)').should be(nil)
+      expect(subject.query('instances.at(2)')).to be(nil)
+      expect(subject.query('instances.at(-1)')).to be(nil)
     end
 
     context 'with a prefix' do
       let(:key) { 'name' }
-      let(:prefix) { '$.instances.at(0).ssh_key'}
+      let(:prefix) { '$.instances.at(0).ssh_key' }
       let(:value) { 'some_name' }
 
       it 'resolves the index to the correct member of the collection' do
-        subject.query(key, prefix).should be(value)
+        expect(subject.query(key, prefix)).to be(value)
       end
     end
   end
 
   context 'checking attribute conditions' do
-    let(:key) { "instance.ssh_key.name" }
-    let(:ssh_key) { double("ssh_key", :name => value) }
+    let(:key) { 'instance.ssh_key.name' }
+    let(:ssh_key) { double('ssh_key', name: value) }
     let(:instance_id) { 123 }
-    let(:instance) { double("instance", ssh_key: ssh_key, id: instance_id) }
+    let(:instance) { double('instance', ssh_key: ssh_key, id: instance_id) }
 
     let(:context) { '$' }
 
@@ -113,89 +107,82 @@ describe Attributor::AttributeResolver do
 
     context 'with no condition' do
       let(:condition) { nil }
-      before { ssh_key.should_receive(:something_else).and_return(nil) }
+      before { expect(ssh_key).to receive(:something_else).and_return(nil) }
       it 'works' do
-        subject.check(context, present_key, condition).should be true
-        subject.check(context, missing_key, condition).should be false
+        expect(subject.check(context, present_key, condition)).to be true
+        expect(subject.check(context, missing_key, condition)).to be false
       end
     end
 
-
     context 'with a string condition' do
       let(:passing_condition) { value }
       let(:failing_condition) { /\w+/.gen }
 
       it 'works' do
-        subject.check(context, key, passing_condition).should be true
-        subject.check(context, key, failing_condition).should be false
+        expect(subject.check(context, key, passing_condition)).to be true
+        expect(subject.check(context, key, failing_condition)).to be false
       end
     end
 
-
     context 'with a regex condition' do
       let(:passing_condition) { /\w+/ }
       let(:failing_condition) { /\d+/ }
 
       it 'works' do
-        subject.check(context, key, passing_condition).should be true
-        subject.check(context, key, failing_condition).should be false
+        expect(subject.check(context, key, passing_condition)).to be true
+        expect(subject.check(context, key, failing_condition)).to be false
       end
-
     end
 
     context 'with an integer condition' do
-      let(:key) { "instance.id" }
+      let(:key) { 'instance.id' }
       let(:passing_condition) { instance_id }
       let(:failing_condition) { /\w+/.gen }
 
       it 'works' do
-        subject.check(context, key, passing_condition).should be true
-        subject.check(context, key, failing_condition).should be false
+        expect(subject.check(context, key, passing_condition)).to be true
+        expect(subject.check(context, key, failing_condition)).to be false
       end
     end
-    
-    pending 'with a hash condition' do
+
+    skip 'with a hash condition' do
     end
 
     context 'with a proc condition' do
-      let(:passing_condition) { Proc.new { |test_value| test_value == value } }
-      let(:failing_condition) { Proc.new { |test_value| test_value != value } }
+      let(:passing_condition) { proc { |test_value| test_value == value } }
+      let(:failing_condition) { proc { |test_value| test_value != value } }
 
       it 'works' do
         expect(subject.check(context, key, passing_condition)).to eq(true)
         expect(subject.check(context, key, failing_condition)).to eq(false)
       end
-
     end
 
     context 'with an unsupported condition type' do
-      let(:condition) { double("weird condition type") }
+      let(:condition) { double('weird condition type') }
       it 'raises an error' do
-        expect { subject.check(context, present_key, condition) }.to raise_error
+        expect { subject.check(context, present_key, condition) }.to raise_error(Attributor::AttributorException)
       end
     end
 
     context 'with a condition that asserts something IS nil' do
-      let(:ssh_key) { double("ssh_key", :name => nil) }
+      let(:ssh_key) { double('ssh_key', name: nil) }
       it 'can be done using the almighty Proc' do
-        cond = Proc.new { |value| !value.nil? }
-        subject.check(context, key, cond).should be false
+        cond = proc { |value| !value.nil? }
+        expect(subject.check(context, key, cond)).to be false
       end
     end
 
     context 'with a relative path' do
-      let(:context) { "$.instance.ssh_key"}
-      let(:key) { "name" }
+      let(:context) { '$.instance.ssh_key' }
+      let(:key) { 'name' }
 
       it 'works' do
-        subject.check(context, key, value).should be true
+        expect(subject.check(context, key, value)).to be true
       end
-
     end
-
   end
 
-
   # context 'with context stuff...' do
 
   #   let(:ssh_key) { double("ssh_key", name:value) }
@@ -219,14 +206,12 @@ describe Attributor::AttributeResolver do
 
   # end
 
-
   # context 'integration with attributes that have sub-attributes' do
-  #when you start to parse... do you set the root in the resolver?
+  # when you start to parse... do you set the root in the resolver?
   # end
   #
   #  context 'actually using the thing' do
 
-
   #   # we'll always want to add... right? never really remove?
   #   # at least not remove for the duration of a given resolver...
   #   # which will last for one request.
@@ -246,13 +231,7 @@ describe Attributor::AttributeResolver do
 
   #     resolver.query '$.parsed_params.account_id'
 
-
   #   end
 
-
   # end
-
 end
-
-
-