attributor 2.1.0

data/spec/attributor_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+
+describe Attributor do
+  context '.resolve_type' do
+    context 'given valid types' do
+      {
+        ::Integer => Attributor::Integer,
+        Integer => Attributor::Integer,
+        Attributor::Integer => Attributor::Integer,
+        ::Attributor::Integer => Attributor::Integer,
+        ::Attributor::DateTime => Attributor::DateTime,
+        # FIXME: Boolean doesn't exist in Ruby, thus this causes and error
+        # https://github.com/rightscale/attributor/issues/25
+        #Boolean => Attributor::Boolean,
+        Attributor::Boolean => Attributor::Boolean,
+        Attributor::Struct => Attributor::Struct
+      }.each do |type, expected_type|
+        it "resolves #{type} as #{expected_type}" do
+          Attributor.resolve_type(type).should == expected_type
+        end
+      end
+    end
+  end
+end

data/spec/dsl_compiler_spec.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+
+describe Attributor::DSLCompiler do
+
+  let(:target) { double("model", attributes: {}) }
+
+  let(:dsl_compiler_options) { {} }
+  subject(:dsl_compiler) { Attributor::DSLCompiler.new(target, dsl_compiler_options) }
+
+  let(:attribute_name) { :name }
+  let(:type) { Attributor::String }
+
+  let!(:reference_attributes) { Turducken.attributes }
+  let(:reference_type) { reference_attribute.type }
+  let(:reference_attribute_options) { reference_attribute.options }
+  let(:reference_attribute) {reference_attributes[attribute_name] }
+
+  context '#attribute' do
+    let(:attribute_options) { {} }
+
+    let(:expected_options) { attribute_options }
+    let(:expected_type) { type }
+
+    context 'when not not given a block for a sub-definition' do
+      context 'without a reference' do
+        it 'raises an error for a missing type' do
+          expect {
+            dsl_compiler.attribute(attribute_name)
+          }.to raise_error(/type for attribute/)
+
+        end
+
+        it 'creates an attribute given a name and type' do
+          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          dsl_compiler.attribute(attribute_name, type)
+        end
+
+
+        it 'creates an attribute given a name, type, and options' do
+          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          dsl_compiler.attribute(attribute_name, type, attribute_options)
+        end
+
+      end
+
+
+      context 'with a reference' do
+        let(:dsl_compiler_options) { {:reference => Turducken} }
+
+        context 'with no options' do
+          let(:expected_options) { reference_attribute_options }
+
+          it 'creates an attribute with the inherited type' do
+            Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+            dsl_compiler.attribute(attribute_name)
+          end
+        end
+
+        context 'with options' do
+          let(:attribute_options) { {:description => "some new description", :required => true} }
+          let(:expected_options) { reference_attribute_options.merge(attribute_options) }
+
+          before do
+            Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          end
+
+          it 'creates an attribute with the inherited type and merged options' do
+            dsl_compiler.attribute(attribute_name, attribute_options)
+          end
+
+          it 'accepts explicit nil type' do
+            dsl_compiler.attribute(attribute_name, nil, attribute_options)
+          end
+
+        end
+
+        context 'for a referenced Model attribute' do
+          let(:attribute_name) { :turkey }
+          let(:expected_type) { Turkey }
+          let(:expected_options) { reference_attribute_options.merge(attribute_options) }
+
+          it 'creates an attribute with the inherited type' do
+            Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+            dsl_compiler.attribute(attribute_name)
+          end
+        end
+
+      end
+
+    end
+
+
+    context 'when given a block for sub-attributes' do
+      let(:attribute_block) { Proc.new { } }
+      let(:attribute_name) { :turkey }
+      let(:type) { Attributor::Struct }
+      let(:expected_type) { Attributor::Struct }
+
+      context 'without a reference' do
+        it 'defaults type to Struct' do
+          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          dsl_compiler.attribute(attribute_name, &attribute_block)
+        end
+      end
+
+      context 'with a reference' do
+        let(:dsl_compiler_options) { {:reference => Turducken} }
+        let(:expected_options) do
+          attribute_options.merge(:reference => reference_type)
+        end
+
+        it 'is unhappy from somewhere else if you do not specify a type' do
+          expect {
+            dsl_compiler.attribute(attribute_name, attribute_options, &attribute_block)
+          }.to raise_error(/does not support anonymous generation/)
+        end
+
+        it 'passes the correct reference to the created attribute' do
+          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          dsl_compiler.attribute(attribute_name, type,  attribute_options, &attribute_block)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+Encoding.default_external = Encoding::UTF_8
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+# Configure simplecov gem (must be here at top of file)
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec' # Don't include RSpec stuff
+  add_group 'Types', 'lib/attributor/types'
+end
+
+require 'rspec'
+require 'attributor'
+
+require 'pry'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+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

data/spec/support/models.rb

@@ -0,0 +1,81 @@
+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"
+  end
+end
+
+
+class Duck < Attributor::Model
+  attributes do
+    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"
+  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"
+  end
+end
+
+
+
+class Turducken < Attributor::Model
+  attributes do
+    attribute :name, String, :description => "Turducken name", :example => /[:name:]/
+    attribute :chicken, Chicken
+    attribute :duck, Duck
+    attribute :turkey, Turkey, :description => "The turkey"
+  end
+end
+
+
+# http://en.wikipedia.org/wiki/Cormorant
+class Cormorant < Attributor::Model
+  attributes do
+    # This will be a collection of arbitrary Ruby Objects
+    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"
+
+    # 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"
+    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 :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 :person, Person, example: proc { |address, context| Person.example(context, address: address) }
+  end
+end

data/spec/support/types.rb

@@ -0,0 +1,21 @@
+class AttributeType
+  include Attributor::Type
+  def self.native_type
+    ::String
+  end
+end
+
+
+class IntegerAttributeType
+  include Attributor::Type
+  def self.native_type
+    ::Integer
+  end
+
+  def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+    value.to_i
+  end
+
+end
+
+

data/spec/type_spec.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+
+describe Attributor::Type do
+
+
+  subject(:test_type) { AttributeType }
+
+  let(:attribute_options) { Hash.new }
+  let(:attribute_attributes) { Hash.new }
+
+  let(:attribute) do
+    double "attribute",
+      :options => attribute_options,
+      :attributes => attribute_attributes
+  end
+
+
+  its(:native_type) { should be(::String) }
+
+
+  context 'load' do
+    let(:value) { nil }
+    let(:context) { nil }
+
+    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)
+      end
+    end
+    
+    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)
+      end
+    end
+
+    context "when given a value that is not of native_type" do
+      let(:value) { 1 }
+      let(:context) { ['top','sub'] }
+      
+      it 'raises an exception' do
+        expect { test_type.load(value,context) }.to raise_error( Attributor::IncompatibleTypeError, /AttributeType 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) }
+
+    context 'min and max' do
+      let(:min) { 10 }
+      let(:max) { 100}
+
+      let(:attribute_options) { {:min => min, :max => max} }
+
+
+
+      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/
+        end
+      end
+
+      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/
+        end
+
+      end
+
+      context 'with a value within the range' do
+        let(:value) { 50 }
+        it { should be_empty }
+      end
+
+
+    end
+
+
+
+     context 'regexp' do
+      let(:regexp) { /dog/ }
+      let(:attribute_options) { {:regexp => regexp} }
+
+      context 'with a value that matches' do
+        let(:value) { 'bulldog' }
+
+        it { should be_empty }
+      end
+
+
+      context 'with a value that does not match' do
+        let(:value) { 'chicken' }
+        it { should_not be_empty}
+        it 'returns the correct error message' do
+          errors.first.should =~ /value \(#{value}\) does not match regexp/
+        end
+      end
+
+     end
+
+
+  end
+
+
+  context 'example' do
+
+  end
+
+  context 'describe' do
+    subject(:description) { test_type.describe }
+    it 'outputs the type name' do
+      description[:name].should == test_type.name
+    end
+
+  end
+
+end

data/spec/types/boolean_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+describe Attributor::Boolean do
+
+  subject(:type) { Attributor::Boolean }
+
+  context '.valid_type?' do
+
+    context 'for incoming Boolean values' do
+
+      [false, true].each do |value|
+
+        it "returns true for #{value.inspect}" do
+          type.valid_type?(value).should be_true
+        end
+
+      end
+
+    end
+
+    context 'for incoming non-Boolean values' do
+
+      ['false', 2, 1.0, Class, Object.new].each do |value|
+
+        it "returns false for #{value.inspect}" do
+          type.valid_type?(value).should be_false
+        end
+
+      end
+
+    end
+
+  end
+
+  context '.example' do
+    it "should return a valid Boolean" do
+      [true, false].should include type.example
+    end
+  end
+
+  context '.load' do
+
+    context 'for incoming Boolean false values' do
+
+      [false, 'false', 'FALSE', '0', 0, 'f', 'F'].each do |value|
+
+        it "returns false for #{value.inspect}" do
+          type.load(value).should be(false)
+        end
+
+      end
+
+    end
+
+    context 'for incoming Boolean false values' do
+
+      [true, 'true', 'TRUE', '1', 1, 't', 'T'].each do |value|
+
+        it "returns true for #{value.inspect}" do
+          type.load(value).should be(true)
+        end
+
+      end
+
+    end
+
+    context 'that are not valid Booleans' do
+      let(:context){ ['root','subattr'] }
+      ['string', 2, 1.0, Class, Object.new].each do |value|
+
+        it "raises Attributor::CoercionError for #{value.inspect}" do
+          expect {
+            type.load(value,context)
+          }.to raise_error(Attributor::CoercionError, /Error coercing from .+ to Attributor::Boolean.* #{context.join('.')}/)
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+