virtus 0.0.10 → 0.1.0

data/examples/override_attribute_methods_spec.rb

@@ -1,40 +0,0 @@
-require './spec/spec_helper'
-
-class Article
-  include Virtus
-
-  attribute :author, String
-
-  def author
-    super || '<unknown>'
-  end
-
-  def author=(name)
-    super unless name == 'Brad'
-  end
-
-end
-
-describe Article, 'override' do
-
-  it 'Alice is an allowed author' do
-    Article.new(:author => 'Alice').author.should == 'Alice'
-  end
-
-  it 'Brad isn not an allowed author' do
-    Article.new(:author => 'Brad').author.should == '<unknown>'
-  end
-
-  context 'with author' do
-    subject { Article.new(:author => 'John') }
-
-    its(:author) { should == 'John' }
-  end
-
-  context 'without author' do
-    subject { Article.new }
-
-    its(:author) { should == '<unknown>' }
-  end
-
-end

data/spec/integration/virtus/attributes/attribute/set_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute, '#set' do
-  let(:attribute_class) do
-    Class.new(Virtus::Attribute::Integer) do
-      def set(instance, value)
-        super(instance, coerce(value) + 1) unless value.nil?
-      end
-    end
-  end
-
-  let(:model) do
-    model = Class.new do
-      include Virtus
-    end
-    model.attribute(:count, attribute_class)
-    model
-  end
-
-  let(:object) do
-    model.new
-  end
-
-  context 'when overridden' do
-    let(:input_value)  { 1 }
-    let(:output_value) { 2 }
-
-    before do
-      object.count = input_value
-    end
-
-    subject { object }
-
-    its(:count) { should eql(output_value) }
-  end
-end

data/spec/integration/virtus/class_methods/attribute_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::ClassMethods, '.attribute' do
-  let(:described_class) do
-    Class.new { include Virtus }
-  end
-
-  (Virtus::Attribute.descendants + [Virtus::Attribute::Object]).each do |attribute_class|
-    context "with #{attribute_class.inspect}" do
-      subject { described_class.attribute(:name, attribute_class) }
-      specify { subject.attributes[:name].should be_instance_of(attribute_class) }
-    end
-  end
-
-  specify { described_class.should respond_to(:attribute)  }
-
-  context "in the class" do
-    before do
-      described_class.attribute(:name,    String)
-      described_class.attribute(:email,   String,  :accessor => :private)
-      described_class.attribute(:address, String,  :accessor => :protected)
-      described_class.attribute(:age,     Integer, :reader   => :private)
-      described_class.attribute(:bday,    Date,    :writer   => :protected)
-    end
-
-    let(:public_instance_methods)    { described_class.public_instance_methods.map    { |method| method.to_s } }
-    let(:protected_instance_methods) { described_class.protected_instance_methods.map { |method| method.to_s } }
-    let(:private_instance_methods)   { described_class.private_instance_methods.map   { |method| method.to_s } }
-
-    it "returns self" do
-      described_class.attribute(:name, String).should be(described_class)
-    end
-
-    it "creates an attribute of a correct type" do
-      described_class.attributes[:name].should be_instance_of(Virtus::Attribute::String)
-    end
-
-    it "creates attribute writer" do
-      public_instance_methods.should include('name=')
-    end
-
-    it "creates attribute reader" do
-      public_instance_methods.should include('name')
-    end
-
-    it "creates attribute private reader when :accessor => :private" do
-      private_instance_methods.should include('email')
-    end
-
-    it "creates attribute private writer when :accessor => :private" do
-      private_instance_methods.should include('email=')
-    end
-
-    it "creates attribute protected reader when :accessor => :protected" do
-      protected_instance_methods.should include('address')
-    end
-
-    it "creates attribute protected writer when :accessor => :protected" do
-      protected_instance_methods.should include('address=')
-    end
-
-    it "creates attribute private reader when :reader => :private" do
-      private_instance_methods.should include('age')
-    end
-
-    it "creates attribute protected writer when :writer => :protected" do
-      protected_instance_methods.should include('bday=')
-    end
-  end
-
-  context "in the descendants" do
-    subject { described_class.attribute(:name, String).attributes[:name] }
-
-    let(:descendant) { Class.new(described_class) }
-
-    it 'updates the descendant attributes' do
-      descendant.attributes.to_a.should be_empty
-      @attribute = subject
-      descendant.attributes.to_a.should eql([ @attribute ])
-    end
-  end
-end

data/spec/integration/virtus/class_methods/attributes_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::ClassMethods, '.attributes' do
-  let(:described_class) do
-    Class.new { include Virtus }
-  end
-
-  it { described_class.should respond_to(:attributes)  }
-
-  describe ".attributes" do
-    before do
-      described_class.attribute(:name, String)
-      described_class.attribute(:age,  Integer)
-    end
-
-    subject { described_class.attributes }
-
-    it "returns a set of attributes" do
-      subject.should be_kind_of(Virtus::AttributeSet)
-    end
-  end
-end

data/spec/integration/virtus/class_methods/const_missing_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::ClassMethods, '.const_missing' do
-  after do
-    Object.send(:remove_const, :User)
-  end
-
-  context "with an existing attribute constant which doesn't exist in the global ns" do
-    before do
-      class User
-        include Virtus
-        attribute :name, String
-      end
-    end
-
-    it "should create attribute of the correct type" do
-      User.attributes[:name].should be_instance_of(Virtus::Attribute::String)
-    end
-  end
-
-  context "with an existing attribute constant which doesn't exist in the global ns" do
-    before do
-      class User
-        include Virtus
-        attribute :admin, Boolean
-      end
-    end
-
-    it "should create attribute of the correct type" do
-      User.attributes[:admin].should be_instance_of(Virtus::Attribute::Boolean)
-    end
-  end
-
-  context "with an unknown constant" do
-    it "should raise NameError" do
-      expect {
-        class User
-          include Virtus
-          attribute :not_gonna_work, NoSuchThing
-        end
-      }.to raise_error(NameError)
-    end
-  end
-end

data/spec/unit/shared/attribute.rb

@@ -1,7 +0,0 @@
-shared_examples_for 'Attribute' do
-  it_behaves_like 'Attribute.accept_options'
-  it_behaves_like 'Attribute.accepted_options'
-  it_behaves_like 'Attribute#inspect'
-  it_behaves_like 'Attribute#set'
-  it_behaves_like 'Attribute#get'
-end

data/spec/unit/shared/attribute/accept_options.rb

@@ -1,37 +0,0 @@
-shared_examples_for 'Attribute.accept_options' do
-  let(:sub_attribute) { Class.new(described_class) }
-  let(:new_option)    { :width }
-
-  before :all do
-    described_class.accepted_options.should_not include(new_option)
-    described_class.accept_options(new_option)
-  end
-
-  context 'with default option value' do
-    let(:option) { :height }
-    let(:value)  { 10 }
-
-    before :all do
-      sub_attribute.accept_options(option)
-      sub_attribute.height(value)
-    end
-
-    context "when new attribute is created" do
-      subject { sub_attribute.new(attribute_name) }
-
-      it "sets the default value" do
-        subject.options[option].should eql(value)
-      end
-    end
-
-    context "when new attribute is created and overrides option's default value" do
-      let(:new_value) { 11 }
-
-      subject { sub_attribute.new(attribute_name, option => new_value) }
-
-      it "sets the new value" do
-        subject.options[option].should eql(new_value)
-      end
-    end
-  end
-end

data/spec/unit/shared/attribute/accepted_options.rb

@@ -1,5 +0,0 @@
-shared_examples_for 'Attribute.accepted_options' do
-  it "includes base options" do
-    described_class.accepted_options.should include(*Virtus::Attribute::OPTIONS)
-  end
-end

data/spec/unit/shared/attribute/get.rb

@@ -1,44 +0,0 @@
-shared_examples_for 'Attribute#get' do
-  subject { attribute.get(instance) }
-
-  let(:model)     { Class.new }
-  let(:instance)  { model.new }
-
-  context 'without default value' do
-    let(:attribute) { described_class.new(attribute_name) }
-
-    before { attribute.set(instance, value) }
-
-    context "when a non-nil value is set" do
-      let(:value) { attribute_value }
-      it { should eql(attribute_value) }
-    end
-
-    context "when nil is set" do
-      let(:value) { nil }
-      it { should be(value) }
-    end
-  end
-
-  context 'with default value' do
-    context 'set to proc' do
-      let(:attribute) do
-        described_class.new(attribute_name, :default => attribute_default_proc)
-      end
-
-      let(:evaluated_proc_value) do
-        attribute.default.evaluate(attribute)
-      end
-
-      it { should == evaluated_proc_value }
-    end
-
-    context 'not set to proc' do
-      let(:attribute) do
-        described_class.new(attribute_name, :default => attribute_default)
-      end
-
-      it { should == attribute_default }
-    end
-  end
-end

data/spec/unit/shared/attribute/inspect.rb

@@ -1,7 +0,0 @@
-shared_examples_for 'Attribute#inspect' do
-  subject { attribute.inspect }
-
-  let(:attribute) { described_class.new(attribute_name) }
-
-  it { should == "#<#{described_class.inspect} @name=#{attribute_name.inspect}>" }
-end

data/spec/unit/shared/attribute/set.rb

@@ -1,37 +0,0 @@
-shared_examples_for 'Attribute#set' do
-  subject { attribute.set(instance, value) }
-
-  let(:attribute) { described_class.new(attribute_name) }
-  let(:model)     { Class.new }
-  let(:instance)  { model.new }
-
-  before { subject }
-
-  context "with nil" do
-    let(:value) { nil }
-
-    it { should be(nil) }
-
-    it "sets the value in an ivar" do
-      instance.instance_variable_get(attribute.instance_variable_name).should be(nil)
-    end
-  end
-
-  context "with a primitive value" do
-    let(:value) { attribute_value }
-
-    it { should == attribute_value }
-
-    it "sets the value in an ivar" do
-      instance.instance_variable_get(attribute.instance_variable_name).should eql(attribute_value)
-    end
-  end
-
-  context "with a non-primitive value" do
-    let(:value) { attribute_value_other }
-
-    it "sets the value in an ivar coerced to the primitive type" do
-      instance.instance_variable_get(attribute.instance_variable_name).should be_kind_of(described_class.primitive)
-    end
-  end
-end

data/spec/unit/virtus/attribute/array_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::Array do
-  it_should_behave_like 'Attribute' do
-    let(:attribute_name)         { :colors }
-    let(:attribute_value)        { [ 'red', 'green', 'blue' ] }
-    let(:attribute_value_other)  { [ 'orange', 'yellow', 'gray' ] }
-    let(:attribute_default)      { [] }
-    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :colors } }
-  end
-
-  describe '#coerce' do
-    let(:attribute) { described_class.new(:colors) }
-
-    subject { attribute.coerce(value) }
-
-    context 'with a Hash' do
-      let(:value) { { :foo => 'bar' } }
-
-      it { should == [ [:foo, 'bar'] ] }
-    end
-  end
-
-end

data/spec/unit/virtus/attribute/class_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::Class do
-  it_should_behave_like 'Attribute' do
-    let(:attribute_name)         { :String }
-    let(:attribute_value)        { String }
-    let(:attribute_value_other)  { 'String' }
-    let(:attribute_default)      { 'Object' }
-    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name.to_s } }
-  end
-
-  describe '#coerce' do
-    let(:attribute) { described_class.new(:type) }
-
-    subject { attribute.coerce(value) }
-
-    context 'with a String' do
-      let(:value) { 'String' }
-
-      it { should be(String) }
-    end
-  end
-
-end

data/spec/unit/virtus/attribute/date_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::Date do
-  it_should_behave_like 'Attribute' do
-    let(:attribute_name)         { :created_on }
-    let(:attribute_value)        { Date.today }
-    let(:attribute_value_other)  { (Date.today+1).to_s }
-    let(:attribute_default)      { Date.today-1 }
-    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :created_on } }
-  end
-
-  describe '#coerce' do
-    let(:attribute) { described_class.new(:bday) }
-
-    let(:year)  { 2011 }
-    let(:month) { 4 }
-    let(:day)   { 7 }
-
-    subject { attribute.coerce(value) }
-
-    shared_examples_for "a correct date" do
-      it          { should be_kind_of(Date) }
-      its(:year)  { should eql(year)  }
-      its(:month) { should eql(month) }
-      its(:day)   { should eql(day)   }
-    end
-
-    context 'with a time' do
-      it_should_behave_like "a correct date" do
-        let(:value) { Time.local(year, month, day) }
-      end
-    end
-
-    context 'with a date time' do
-      it_should_behave_like "a correct date" do
-        let(:value) { DateTime.new(year, month, day) }
-      end
-    end
-
-    context 'with a hash' do
-      it_should_behave_like "a correct date" do
-        let(:value) do
-          { :year => year, :month => month, :day => day }
-        end
-      end
-    end
-
-    context 'with a string' do
-      it_should_behave_like "a correct date" do
-        let(:value) { "April #{day}th, #{year}" }
-      end
-    end
-
-    context 'with a non-date value' do
-      let(:value) { 'non-date' }
-      it { should equal(value) }
-    end
-  end
-end