virtus 0.0.1

data/lib/virtus/support/chainable.rb

@@ -0,0 +1,15 @@
+module Virtus
+  module Support
+    module Chainable
+      MODULES = {}
+
+      def chainable(key, &block)
+        begin
+          mod = (MODULES[key] ||= Module.new)
+          include mod
+          mod
+        end.module_eval(&block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Virtus::ClassMethods, '.attribute' do
+  let(:described_class) do
+    Class.new { include Virtus }
+  end
+
+  it { described_class.should respond_to(:attribute)  }
+
+  describe ".attribute" 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 "should create an attribute" do
+      described_class.attributes.should have_key(:name)
+    end
+
+    it "should create an attribute of a correct type" do
+      described_class.attributes[:name].should be_instance_of(Virtus::Attributes::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
+end

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

@@ -0,0 +1,24 @@
+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 an attributes hash" do
+      subject.should == {
+        :name => described_class.attributes[:name],
+        :age  => described_class.attributes[:age] }
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+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::Attributes::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::Attributes::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/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'pathname'
+require 'rubygems'
+require 'rspec'
+
+if ENV['SPEC_COV'] && RUBY_VERSION >= '1.9.2'
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_group "lib", "lib"
+  end
+end
+
+require 'virtus'
+
+ENV['TZ'] = 'UTC'
+
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+
+Pathname.glob((SPEC_ROOT + '**/shared/**/*.rb').to_s).each { |file| require file }

data/spec/unit/shared/attribute.rb

@@ -0,0 +1,157 @@
+# TODO: split this into separate files
+
+shared_examples_for "Attribute" do
+  def attribute_name
+    raise "+attribute_name+ should be defined"
+  end
+
+  before :all do
+    Object.send(:remove_const, :SubAttribute) if Object.const_defined?(:SubAttribute)
+    Object.send(:remove_const, :User)         if Object.const_defined?(:User)
+  end
+
+  let(:sub_attribute) { class SubAttribute < described_class; end; SubAttribute }
+
+  let(:model) do
+    Class.new { include Virtus }
+  end
+
+  describe ".options" do
+    subject { described_class.options }
+    it { should be_instance_of(Hash) }
+  end
+
+  describe ".accepted_options" do
+    it "returns an array of accepted options" do
+      described_class.accepted_options.should be_instance_of(Array)
+    end
+
+    it "accepts base options" do
+      described_class.accepted_options.should include(*Virtus::Attributes::Attribute::OPTIONS)
+    end
+  end
+
+  describe ".accept_options" do
+    let(:new_option) { :width }
+
+    before :all do
+      described_class.accepted_options.should_not include(new_option)
+      described_class.accept_options(new_option)
+    end
+
+    it "sets new accepted options on itself" do
+      described_class.accepted_options.should include(new_option)
+    end
+
+    it "sets new accepted option on its descendants" do
+      sub_attribute.accepted_options.should include(new_option)
+    end
+
+    it "creates option accessors" do
+      described_class.should respond_to(new_option)
+    end
+
+    it "creates option accessors on descendants" do
+      sub_attribute.should respond_to(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, model) }
+
+        it "sets the default value" do
+          subject.options[option].should == 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, model, option => new_value) }
+
+        it "sets the new value" do
+          subject.options[option].should == new_value
+        end
+      end
+    end
+  end
+
+  describe "#set" do
+    let(:attribute) { model.attribute(attribute_name, described_class) }
+    let(:object)    { model.new }
+
+    context "with nil" do
+      subject { attribute.set(object, nil) }
+
+      it "doesn't set the ivar" do
+        subject
+        object.instance_variable_defined?(attribute.instance_variable_name).should be(false)
+      end
+
+      it "returns nil" do
+        subject.should be(nil)
+      end
+    end
+
+    context "with a primitive value" do
+      before { attribute.set(object, attribute_value) }
+
+      it "sets the value in an ivar" do
+        object.instance_variable_get(attribute.instance_variable_name).should == attribute_value
+      end
+    end
+
+    context "with a non-primitive value" do
+      before { attribute.set(object, attribute_value_other) }
+
+      it "sets the value in an ivar converted to the primitive type" do
+        object.instance_variable_get(attribute.instance_variable_name).should be_kind_of(described_class.primitive)
+      end
+    end
+  end
+
+  describe "#get" do
+    let(:attribute) { model.attribute(attribute_name, described_class) }
+    let(:object)    { model.new }
+
+    context "when a non-nil value is set" do
+      before { attribute.set(object, attribute_value) }
+
+      subject { attribute.get(object) }
+
+      it { should == attribute_value }
+    end
+
+    context "when nil is set" do
+      before { attribute.set(object, nil) }
+
+      subject { attribute.get(object) }
+
+      it { should be(nil) }
+    end
+  end
+
+  describe "#complex" do
+    let(:attribute) { model.attribute(attribute_name, described_class, :complex => complex) }
+
+    subject { attribute.complex? }
+
+    context "when set to true" do
+      let(:complex) { true }
+      it { should be(true) }
+    end
+
+    context "when set to false" do
+      let(:complex) { false }
+      it { should be(false) }
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attributes::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' ] }
+  end
+end

data/spec/unit/virtus/attributes/attribute_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virtus::Attributes::Attribute do
+  describe '#typecast_to_primitive' do
+    let(:model)     { Class.new { include Virtus } }
+    let(:attribute) { Virtus::Attributes::Attribute.new(:name, model) }
+    let(:value)     { 'value' }
+
+    it "returns original value" do
+      attribute.typecast_to_primitive(value, model).should == value
+    end
+  end
+end

data/spec/unit/virtus/attributes/boolean_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Virtus::Attributes::Boolean do
+  it_should_behave_like 'Attribute' do
+    let(:attribute_name)        { :is_admin }
+    let(:attribute_value)       { true }
+    let(:attribute_value_other) { '1' }
+  end
+
+  describe "accessor names" do
+    let(:model) do
+      Class.new do
+        include Virtus
+
+        attribute :is_admin, Virtus::Attributes::Boolean
+      end
+    end
+
+    let(:object) { model.new(:is_admin => true) }
+
+    it "uses standard boolean reader naming conventions" do
+      object.is_admin?.should be_true
+    end
+  end
+
+  describe '#typecast' do
+    let(:model)     { Class.new { include Virtus } }
+    let(:attribute) { model.attribute(:is_admin, Virtus::Attributes::Boolean) }
+
+    subject { attribute.typecast(value) }
+
+    context "with 1" do
+      let(:value) { 1 }
+      it { should be(true) }
+    end
+
+    context "with '1'" do
+      let(:value) { '1' }
+      it { should be(true) }
+    end
+
+    context "with 'true'" do
+      let(:value) { 'true' }
+      it { should be(true) }
+    end
+
+    context "with 'TRUE'" do
+      let(:value) { 'TRUE' }
+      it { should be(true) }
+    end
+
+    context "with 't'" do
+      let(:value) { 't' }
+      it { should be(true) }
+    end
+
+    context "with 'T'" do
+      let(:value) { 'T' }
+      it { should be(true) }
+    end
+
+    context "with 0" do
+      let(:value) { 0 }
+      it { should be(false) }
+    end
+
+    context "with '0'" do
+      let(:value) { '0' }
+      it { should be(false) }
+    end
+
+    context "with 'false'" do
+      let(:value) { 'false' }
+      it { should be(false) }
+    end
+
+    context "with 'FALSE'" do
+      let(:value) { 'FALSE' }
+      it { should be(false) }
+    end
+
+    context "with 'f'" do
+      let(:value) { 'f' }
+      it { should be(false) }
+    end
+
+    context "with 'F'" do
+      let(:value) { 'F' }
+      it { should be(false) }
+    end
+
+    context "with 'Foo'" do
+      let(:value) { 'Foo' }
+      it { should == value }
+    end
+  end
+end