attributor 5.0.2 → 5.1.0

data/spec/spec_helper.rb

@@ -11,8 +11,10 @@ Coveralls.wear! do
 end
 
 require 'rspec'
-require 'attributor'
+require 'rspec/its'
+require 'rspec/collection_matchers'
 
+require 'attributor'
 require 'pry'
 
 # Requires supporting files with custom matchers and macros, etc,
@@ -20,13 +22,11 @@ require 'pry'
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
-
   config.around(:each) do |example|
     Attributor::AttributeResolver.current = Attributor::AttributeResolver.new
     example.run
     Attributor::AttributeResolver.current = nil
   end
-
 end
 
 RSpec::Matchers.define :be_in_family do |expected|
@@ -34,3 +34,9 @@ RSpec::Matchers.define :be_in_family do |expected|
     actual.family == expected
   end
 end
+
+RSpec::Matchers.define :be_subclass_of do |expected|
+  match do |actual|
+    actual < expected
+  end
+end

data/spec/support/hashes.rb

@@ -1,14 +1,13 @@
 class HashWithModel < Attributor::Hash
   keys do
-    key :name, String, :default => "Turkey McDucken", :description => "Turducken name", :example => /[:name:]/
+    key :name, String, default: 'Turkey McDucken', description: 'Turducken name', example: Randgen.name
     key :chicken, Chicken
   end
 end
 
-
 class HashWithStrings < Attributor::Hash
   keys do
     key :name, String
     key :something, String
   end
-end
+end

data/spec/support/models.rb

@@ -1,42 +1,41 @@
 class Chicken < Attributor::Model
-  attributes(:identity => :email) do
-    attribute :name, Attributor::String, example: /[:first_name:]/
-    attribute :age, Attributor::Integer, :default => 1, :min => 0, :max => 120, :description => "The age of the chicken"
-    attribute :email, Attributor::String, :example => /[:email:]/, :regexp => /@/, :description => "The email address of the chicken"
-    attribute :angry, Attributor::Boolean, :example => "true", :description => "Angry bird?"
-    attribute :weight, Attributor::Float, :example => /\d{1,2}\.\d/, :description => "The weight of the chicken"
+  attributes(identity: :email) do
+    attribute :name, Attributor::String, example: Randgen.first_name
+    attribute :age, Attributor::Integer, default: 1, min: 0, max: 120, description: 'The age of the chicken'
+    attribute :email, Attributor::String, example: Randgen.email, regexp: /@/, description: 'The email address of the chicken'
+    attribute :angry, Attributor::Boolean, example: 'true', description: 'Angry bird?'
+    attribute :weight, Attributor::Float, example: /\d{1,2}\.\d/, description: 'The weight of the chicken'
+    attribute :type, Attributor::Symbol, values: [:chicken]
   end
 end
 
-
 class Duck < Attributor::Model
   attributes do
-    attribute :age, Attributor::Integer, :required_if => {"name" => "Daffy" }
+    attribute :age, Attributor::Integer, required_if: { 'name' => 'Daffy' }
     attribute :name, Attributor::String
-    attribute :email, Attributor::String, :required_if => "name"
-    attribute :angry, Attributor::Boolean, :default => true, :example => /true|false/, :description => "Angry bird?"
-    attribute :weight, Attributor::Float, :example => /\d{1,2}\.\d/, :description => "The weight of the duck"
+    attribute :email, Attributor::String, required_if: 'name'
+    attribute :angry, Attributor::Boolean, default: true, example: /true|false/, description: 'Angry bird?'
+    attribute :weight, Attributor::Float, example: /\d{1,2}\.\d/, description: 'The weight of the duck'
+    attribute :type, Attributor::Symbol, values: [:duck]
   end
 end
 
-
 class Turkey < Attributor::Model
   attributes do
-    attribute :age, Integer, :default => 1, :min => 0, :max => 120, :description => "The age of the turkey"
-    attribute :name, String , :description => "name of the turkey", :example => /[:name:]/ #, :default => "Providencia Zboncak"
-    attribute :email, String, :example => /[:email:]/, :regexp => /@/, :description => "The email address of the turkey"
-    attribute :weight, Attributor::Float, :example => /\d{1,2}\.\d/, :max => 86.7, :description => "The weight of the turkey"
+    attribute :age, Integer, default: 1, min: 0, max: 120, description: 'The age of the turkey'
+    attribute :name, String, description: 'name of the turkey', example: Randgen.name # , :default => "Providencia Zboncak"
+    attribute :email, String, example: Randgen.email, regexp: /@/, description: 'The email address of the turkey'
+    attribute :weight, Attributor::Float, example: /\d{1,2}\.\d/, max: 100.0, description: 'The weight of the turkey'
+    attribute :type, Attributor::Symbol, values: [:turkey]
   end
 end
 
-
-
 class Turducken < Attributor::Model
   attributes do
-    attribute :name, String, :default => "Turkey McDucken", :description => "Turducken name", :example => /[:name:]/
+    attribute :name, String, default: 'Turkey McDucken', description: 'Turducken name', example: Randgen.name
     attribute :chicken, Chicken
     attribute :duck, Duck
-    attribute :turkey, Turkey, :description => "The turkey"
+    attribute :turkey, Turkey, description: 'The turkey'
   end
 end
 
@@ -44,54 +43,49 @@ end
 
 class Cormorant < Attributor::Model
   attributes do
-    attribute :name, String, :description => "Name of the Cormorant", :example => /[:name:]/
+    attribute :name, String, description: 'Name of the Cormorant', example: Randgen.name
     attribute :timestamps do
       attribute :born_at, DateTime
-      attribute :died_at, DateTime, example: Proc.new {|timestamps| timestamps.born_at + 10}
+      attribute :died_at, DateTime, example: proc { |timestamps| timestamps.born_at + 10 }
     end
 
     # This will be a collection of arbitrary Ruby Objects
-    attribute :fish, Attributor::Collection, :description => "All kinds of fish for feeding the babies"
+    attribute :fish, Attributor::Collection, description: 'All kinds of fish for feeding the babies'
 
     # This will be a collection of Cormorants (note, this relationship is circular)
-    attribute :neighbors, Attributor::Collection.of(Cormorant), :description => "Neighbor cormorants"
+    attribute :neighbors, Attributor::Collection.of(Cormorant), description: 'Neighbor cormorants'
 
     # This will be a collection of instances of an anonymous Struct class, each having two well-defined attributes
 
-    attribute :babies, Attributor::Collection.of(Attributor::Struct), :description => "All the babies", :member_options => {:identity => :name} do
-      attribute :name, Attributor::String, :example => /[:name]/, :description => "The name of the baby cormorant"
-      attribute :months, Attributor::Integer, :default => 0, :min => 0, :description => "The age in months of the baby cormorant"
-      attribute :weight, Attributor::Float, :example => /\d{1,2}\.\d{3}/, :description => "The weight in kg of the baby cormorant"
+    attribute :babies, Attributor::Collection.of(Attributor::Struct), description: 'All the babies', member_options: { identity: :name } do
+      attribute :name, Attributor::String, example: /[:name]/, description: 'The name of the baby cormorant'
+      attribute :months, Attributor::Integer, default: 0, min: 0, description: 'The age in months of the baby cormorant'
+      attribute :weight, Attributor::Float, example: /\d{1,2}\.\d{3}/, description: 'The weight in kg of the baby cormorant'
     end
-
   end
 end
 
-
 class Person < Attributor::Model
   attributes do
-    attribute :name, String, example: /[:first_name:]/
-    attribute :title, String, values: %w{Mr Mrs Ms Dr}
+    attribute :name, String, example: Randgen.first_name
+    attribute :title, String, values: %w(Mr Mrs Ms Dr)
     attribute :okay, Attributor::Boolean, values: [true]
     attribute :address, Address, example: proc { |person, context| Address.example(context, person: person) }
   end
 end
 
-
 class Address < Attributor::Model
   attributes do
     attribute :name, String, example: /\w+/
-    attribute :state, String, values: %w{OR CA}
+    attribute :state, String, values: %w(OR CA)
     attribute :person, Person, example: proc { |address, context| Person.example(context, address: address) }
     requires :name
   end
 end
 
-
 class Post < Attributor::Model
   attributes do
     attribute :title, String
     attribute :tags, Attributor::Collection.of(String)
   end
 end
-

data/spec/support/polymorphics.rb

@@ -0,0 +1,10 @@
+class Sandwich < Attributor::Model
+  attributes do
+    attribute :name, String
+    attribute :meat, Attributor::Polymorphic.on(:type) do
+      given :chicken, Chicken
+      given :turkey, Turkey
+      given :duck, Duck
+    end
+  end
+end

data/spec/type_spec.rb

@@ -1,8 +1,6 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
-
 describe Attributor::Type do
-
   subject(:test_type) do
     Class.new do
       include Attributor::Type
@@ -24,14 +22,13 @@ describe Attributor::Type do
   let(:attribute_attributes) { Hash.new }
 
   let(:attribute) do
-    double "attribute",
-      :options => attribute_options,
-      :attributes => attribute_attributes
+    double 'attribute',
+           options: attribute_options,
+           attributes: attribute_attributes
   end
 
-
   its(:native_type) { should be(::String) }
-  its(:id) { should eq('Testing')}
+  its(:id) { should eq('Testing') }
 
   context 'anonymous' do
     its(:anonymous?) { should be(false) }
@@ -39,13 +36,13 @@ describe Attributor::Type do
       klass = Class.new do
         include Attributor::Type
       end
-      expect( klass.anonymous? ).to be(true)
+      expect(klass.anonymous?).to be(true)
     end
     it 'can be set to true explicitly' do
       klass = Class.new(test_type) do
         anonymous_type
       end
-      expect( klass.anonymous? ).to be(true)
+      expect(klass.anonymous?).to be(true)
     end
   end
 
@@ -53,80 +50,69 @@ describe Attributor::Type do
     let(:value) { nil }
     let(:context) { nil }
 
-    context "when given a nil value" do
+    context 'when given a nil value' do
       it 'always successfully returns it (i.e., you can always load nil)' do
-        test_type.load(value).should be(value)
+        expect(test_type.load(value)).to be(value)
       end
     end
 
-    context "when given a value that is of native_type" do
-      let(:value) { "one" }
+    context 'when given a value that is of native_type' do
+      let(:value) { 'one' }
       it 'returns the value' do
-        test_type.load(value).should be(value)
+        expect(test_type.load(value)).to be(value)
       end
     end
 
-    context "when given a value that is not of native_type" do
+    context 'when given a value that is not of native_type' do
       let(:value) { 1 }
-      let(:context) { ['top','sub'] }
+      let(:context) { %w(top sub) }
 
       it 'raises an exception' do
-        expect { test_type.load(value,context) }.to raise_error( Attributor::IncompatibleTypeError, /cannot load values of type Fixnum.*while loading top.sub/)
+        expect { test_type.load(value, context) }.to raise_error(Attributor::IncompatibleTypeError, /cannot load values of type Fixnum.*while loading top.sub/)
       end
-
-
     end
-
   end
 
-
   context 'validate' do
     let(:context) { ['some_attribute'] }
 
     let(:attribute_options) { {} }
 
-      let(:attribute) { double("some_attribute", :options => attribute_options)}
-      subject(:errors) { test_type.validate(value, context, attribute) }
+    let(:attribute) { double('some_attribute', options: attribute_options) }
+    subject(:errors) { test_type.validate(value, context, attribute) }
 
     context 'min and max' do
       let(:min) { 10 }
-      let(:max) { 100}
+      let(:max) { 100 }
 
-      let(:attribute_options) { {:min => min, :max => max} }
+      let(:attribute_options) { { min: min, max: max } }
 
-
-
-      context "with a value <= min" do
+      context 'with a value <= min' do
         let(:value) { 1 }
 
         it { should_not be_empty }
         it 'returns the correct error message' do
-          errors.first.should =~ /value \(#{value}\) is smaller than the allowed min/
+          expect(errors.first).to match(/value \(#{value}\) is smaller than the allowed min/)
         end
       end
 
-      context "with a value >= max" do
+      context 'with a value >= max' do
         let(:value) { 1000 }
         it { should_not be_empty }
         it 'returns the correct error message' do
-          errors.first.should =~ /value \(#{value}\) is larger than the allowed max/
+          expect(errors.first).to match(/value \(#{value}\) is larger than the allowed max/)
         end
-
       end
 
       context 'with a value within the range' do
         let(:value) { 50 }
         it { should be_empty }
       end
-
-
     end
 
-
-
-     context 'regexp' do
+    context 'regexp' do
       let(:regexp) { /dog/ }
-      let(:attribute_options) { {:regexp => regexp} }
+      let(:attribute_options) { { regexp: regexp } }
 
       context 'with a value that matches' do
         let(:value) { 'bulldog' }
@@ -134,68 +120,59 @@ describe Attributor::Type do
         it { should be_empty }
       end
 
-
       context 'with a value that does not match' do
         let(:value) { 'chicken' }
-        it { should_not be_empty}
+        it { should_not be_empty }
         it 'returns the correct error message' do
-          errors.first.should =~ /value \(#{value}\) does not match regexp/
+          expect(errors.first).to match(/value \(#{value}\) does not match regexp/)
         end
       end
-
-     end
-
-
+    end
   end
 
-
   context 'example' do
-
   end
 
   context 'id' do
     it 'works for built-in types' do
-      Attributor::String.id.should eq('Attributor-String')
+      expect(Attributor::String.id).to eq('Attributor-String')
     end
 
     it 'returns nil for anonymous types' do
       type = Class.new(Attributor::Model)
-      type.id.should eq(nil)
+      expect(type.id).to eq(nil)
     end
   end
 
   context 'describe' do
-    let(:example){ "Foo" }
+    let(:example) { 'Foo' }
     subject(:description) { test_type.describe }
     it 'outputs the type name' do
-      description[:name].should eq(test_type.name)
+      expect(description[:name]).to eq(test_type.name)
     end
     it 'outputs the type id' do
-      description[:id].should eq(test_type.name)
+      expect(description[:id]).to eq(test_type.name)
     end
 
     context 'with an example' do
       subject(:description) { test_type.describe(example: example) }
       it 'includes it in the :example key' do
-        description.should have_key(:example)
-        description[:example].should be(example)
+        expect(description).to have_key(:example)
+        expect(description[:example]).to be(example)
       end
     end
 
     context 'when anonymous' do
-
       it 'reports true in the output when set (to true default)' do
         anon_type = Class.new(test_type) { anonymous_type }
-        anon_type.describe.should have_key(:anonymous)
-        anon_type.describe[:anonymous].should be(true)
+        expect(anon_type.describe).to have_key(:anonymous)
+        expect(anon_type.describe[:anonymous]).to be(true)
       end
       it 'reports false in the output when set false explicitly' do
         anon_type = Class.new(test_type) { anonymous_type false }
-        anon_type.describe.should have_key(:anonymous)
-        anon_type.describe[:anonymous].should be(false)
+        expect(anon_type.describe).to have_key(:anonymous)
+        expect(anon_type.describe[:anonymous]).to be(false)
       end
-
     end
   end
-
 end

data/spec/types/bigdecimal_spec.rb

@@ -4,7 +4,7 @@ describe Attributor::BigDecimal do
   subject(:type) { Attributor::BigDecimal }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   context '.native_type' do
@@ -13,40 +13,36 @@ describe Attributor::BigDecimal do
 
   context '.example' do
     its(:example) { should be_a(::BigDecimal) }
-    it do
-      ex = type.example
-    end
   end
 
   context '.load' do
     let(:value) { nil }
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming Float values' do
-     it 'returns the incoming value' do
-       [0.0, -1.0, 1.0, 1e-10, 0.25135].each do |value|
-         type.load(value).should eq(value)
-       end
-     end
+      it 'returns the incoming value' do
+        [0.0, -1.0, 1.0, 1e-10, 0.25135].each do |value|
+          expect(type.load(value)).to eq(value)
+        end
+      end
     end
 
     context 'for incoming Integer values' do
       it 'should equal the incoming value' do
         [0, -1, 1].each do |value|
-          type.load(value).should eq(value)
+          expect(type.load(value)).to eq(value)
         end
       end
     end
 
     context 'for incoming String values' do
       it 'should equal the value' do
-        type.load('0').should eq(0)
-        type.load('100').should eq(100)
-        type.load('0.1').should eq(0.1)
+        expect(type.load('0')).to eq(0)
+        expect(type.load('100')).to eq(100)
+        expect(type.load('0.1')).to eq(0.1)
       end
     end
-
   end
 end