ardm 0.0.1

data/spec/semipublic/property/discriminator_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Ardm::Property::Discriminator do
+  before do
+    Object.send(:remove_const, :Foo) if defined?(Foo)
+    Object.send(:remove_const, :Bar) if defined?(Bar)
+
+    class ::Foo; end
+    class ::Bar; end
+  end
+
+  let(:name)          { :type }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { Foo }
+  let(:other_value)   { Bar }
+  let(:invalid_value) { 1 }
+  let(:model)         { Blog::Article }
+  let(:property)      { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+end

data/spec/semipublic/property/float_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Ardm::Property::Float do
+  let(:name)          { :rating }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { 0.1 }
+  let(:other_value)   { 0.2 }
+  let(:invalid_value) { '1' }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#typecast' do
+    it 'returns same value if a float' do
+      value = 24.0
+      property.typecast(value).should equal(value)
+    end
+
+    it 'returns float representation of a zero string integer' do
+      property.typecast('0').should eql(0.0)
+    end
+
+    it 'returns float representation of a positive string integer' do
+      property.typecast('24').should eql(24.0)
+    end
+
+    it 'returns float representation of a negative string integer' do
+      property.typecast('-24').should eql(-24.0)
+    end
+
+    it 'returns float representation of a zero string float' do
+      property.typecast('0.0').should eql(0.0)
+    end
+
+    it 'returns float representation of a positive string float' do
+      property.typecast('24.35').should eql(24.35)
+    end
+
+    it 'returns float representation of a negative string float' do
+      property.typecast('-24.35').should eql(-24.35)
+    end
+
+    it 'returns float representation of a zero string float, with no leading digits' do
+      property.typecast('.0').should eql(0.0)
+    end
+
+    it 'returns float representation of a positive string float, with no leading digits' do
+      property.typecast('.41').should eql(0.41)
+    end
+
+    it 'returns float representation of a zero integer' do
+      property.typecast(0).should eql(0.0)
+    end
+
+    it 'returns float representation of a positive integer' do
+      property.typecast(24).should eql(24.0)
+    end
+
+    it 'returns float representation of a negative integer' do
+      property.typecast(-24).should eql(-24.0)
+    end
+
+    it 'returns float representation of a zero decimal' do
+      property.typecast(BigDecimal('0.0')).should eql(0.0)
+    end
+
+    it 'returns float representation of a positive decimal' do
+      property.typecast(BigDecimal('24.35')).should eql(24.35)
+    end
+
+    it 'returns float representation of a negative decimal' do
+      property.typecast(BigDecimal('-24.35')).should eql(-24.35)
+    end
+
+    [ Object.new, true, '0.', '-.0', 'string' ].each do |value|
+      it "does not typecast non-numeric value #{value.inspect}" do
+        property.typecast(value).should equal(value)
+      end
+    end
+  end
+end

data/spec/semipublic/property/integer_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Ardm::Property::Integer do
+  let(:name)          { :age }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { 1 }
+  let(:other_value)   { 2 }
+  let(:invalid_value) { '1' }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#typecast' do
+    it 'returns same value if an integer' do
+      value = 24
+      property.typecast(value).should equal(value)
+    end
+
+    it 'returns integer representation of a zero string integer' do
+      property.typecast('0').should eql(0)
+    end
+
+    it 'returns integer representation of a positive string integer' do
+      property.typecast('24').should eql(24)
+    end
+
+    it 'returns integer representation of a negative string integer' do
+      property.typecast('-24').should eql(-24)
+    end
+
+    it 'returns integer representation of a zero string float' do
+      property.typecast('0.0').should eql(0)
+    end
+
+    it 'returns integer representation of a positive string float' do
+      property.typecast('24.35').should eql(24)
+    end
+
+    it 'returns integer representation of a negative string float' do
+      property.typecast('-24.35').should eql(-24)
+    end
+
+    it 'returns integer representation of a zero string float, with no leading digits' do
+      property.typecast('.0').should eql(0)
+    end
+
+    it 'returns integer representation of a positive string float, with no leading digits' do
+      property.typecast('.41').should eql(0)
+    end
+
+    it 'returns integer representation of a zero float' do
+      property.typecast(0.0).should eql(0)
+    end
+
+    it 'returns integer representation of a positive float' do
+      property.typecast(24.35).should eql(24)
+    end
+
+    it 'returns integer representation of a negative float' do
+      property.typecast(-24.35).should eql(-24)
+    end
+
+    it 'returns integer representation of a zero decimal' do
+      property.typecast(BigDecimal('0.0')).should eql(0)
+    end
+
+    it 'returns integer representation of a positive decimal' do
+      property.typecast(BigDecimal('24.35')).should eql(24)
+    end
+
+    it 'returns integer representation of a negative decimal' do
+      property.typecast(BigDecimal('-24.35')).should eql(-24)
+    end
+
+    [ Object.new, true, '0.', '-.0', 'string' ].each do |value|
+      it "does not typecast non-numeric value #{value.inspect}" do
+        property.typecast(value).should equal(value)
+      end
+    end
+  end
+end

data/spec/semipublic/property/lookup_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module LookupFoo
+  class OtherProperty < Ardm::Property::String; end
+end
+
+describe Ardm::Property::Lookup do
+  before do
+    @klass = Class.new(Ardm::Record) do
+      self.table_name = "articles"
+    end
+  end
+
+  it 'should provide access to Property classes' do
+    @klass::Serial.should == Ardm::Property::Serial
+  end
+
+  it 'should provide access to Property classes from outside of the Property namespace' do
+    @klass::OtherProperty.should eq(LookupFoo::OtherProperty)
+  end
+
+  it 'should not provide access to unknown Property classes' do
+    lambda {
+      @klass::Bla
+    }.should raise_error(NameError)
+  end
+end

data/spec/semipublic/property/serial_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ardm::Property::Serial do
+  let(:name)          { :id }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { 1 }
+  let(:other_value)   { 2 }
+  let(:invalid_value) { 'foo' }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+end

data/spec/semipublic/property/string_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ardm::Property::String do
+  let(:name)          { :name }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { 'value' }
+  let(:other_value)   { 'return value' }
+  let(:invalid_value) { 1 }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+end

data/spec/semipublic/property/text_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Ardm::Property::Text do
+  let(:name)          { :title }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { 'value' }
+  let(:other_value)   { 'return value' }
+  let(:invalid_value) { 1 }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#load' do
+    before do
+      @value = 'value'
+    end
+
+    subject { property.load(@value) }
+
+    let(:property) { type.new(model, name) }
+
+    it 'should delegate to #type.load' do
+      return_value = 'return value'
+      property.should_receive(:load).with(@value).and_return(return_value)
+      subject.should == return_value
+    end
+  end
+end

data/spec/semipublic/property/time_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Ardm::Property::Time do
+  let(:name)          { :deleted_at }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { Time.now }
+  let(:other_value)   { Time.now + 15 }
+  let(:invalid_value) { 1 }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#typecast' do
+    describe 'and value given as a hash with keys like :year, :month, etc' do
+      it 'builds a Time instance from hash values' do
+        result = property.typecast(
+          :year  => '2006',
+          :month => '11',
+          :day   => '23',
+          :hour  => '12',
+          :min   => '0',
+          :sec   => '0'
+        )
+
+        result.should be_kind_of(Time)
+        result.year.should  eql(2006)
+        result.month.should eql(11)
+        result.day.should   eql(23)
+        result.hour.should  eql(12)
+        result.min.should   eql(0)
+        result.sec.should   eql(0)
+      end
+    end
+
+    describe 'and value is a string' do
+      it 'parses the string' do
+        result = property.typecast('22:24')
+        result.hour.should eql(22)
+        result.min.should eql(24)
+      end
+    end
+
+    it 'does not typecast non-time values' do
+      property.typecast('not-time').should eql('not-time')
+    end
+  end
+end

data/spec/semipublic/property_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+# instance methods
+describe Ardm::Property do
+  describe ".find_class" do
+    [ :Serial, :Text ].each do |type|
+      describe "with #{type}" do
+        subject { Ardm::Property.find_class(type) }
+
+        it { subject.should be(Ardm::Property.const_get(type)) }
+      end
+    end
+  end
+
+  describe ".determine_class" do
+    [ Integer, String, Float, Class, String, Time, DateTime, Date ].each do |type|
+      describe "with #{type}" do
+        subject { Ardm::Property.determine_class(type) }
+
+        it { subject.should be(Ardm::Property.const_get(type.name)) }
+      end
+    end
+
+    describe "with property subclasses" do
+      before do
+        Object.send(:remove_const, :CustomProps) if Object.const_defined?(:CustomProps)
+
+        module ::CustomProps
+          module Property
+            class Hash   < Ardm::Property::Object; end
+            class Other  < Ardm::Property::Object; end
+            class Serial < Ardm::Property::Object; end
+          end
+        end
+      end
+
+      describe "with ::Foo::Property::Hash" do
+        subject { Ardm::Property.determine_class(Hash) }
+
+        it { subject.should be(::CustomProps::Property::Hash) }
+      end
+
+      describe "with ::Foo::Property::Other" do
+        subject { Ardm::Property.determine_class(::CustomProps::Property::Other) }
+
+        it { subject.should be(::CustomProps::Property::Other) }
+      end
+
+    end
+  end
+end

data/spec/shared/flags_shared_spec.rb

@@ -0,0 +1,36 @@
+share_examples_for "A property with flags" do
+  before do
+    %w[ @property_klass ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
+    end
+
+    @flags = [ :one, :two, :three ]
+
+    class ::User < Ardm::Record
+    end
+
+    @property = User.property :item, @property_klass[@flags], :key => true
+  end
+
+  describe ".generated_classes" do
+    it "should cache the generated class" do
+      @property_klass.generated_classes[@flags].should_not be_nil
+    end
+  end
+
+  it "should include :flags in accepted_options" do
+    @property_klass.accepted_options.should include(:flags)
+  end
+
+  it "should respond to :generated_classes" do
+    @property_klass.should respond_to(:generated_classes)
+  end
+
+  it "should respond to :flag_map" do
+    @property.should respond_to(:flag_map)
+  end
+
+  it "should be custom" do
+    @property.custom?.should be(true)
+  end
+end

data/spec/shared/identity_function_group.rb

@@ -0,0 +1,5 @@
+shared_examples_for "identity function" do
+  it "returns value unchanged" do
+    @result.should == @input
+  end
+end

data/spec/shared/public_property_spec.rb

@@ -0,0 +1,229 @@
+share_examples_for 'A public Property' do
+  before do
+    %w[ @type @load_as @name @value @other_value ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
+    end
+
+    module ::Blog
+      class Article < Ardm::Record
+        self.table_name = "articles"
+        property :id, Serial
+      end
+    end
+
+    @model     = Blog::Article
+    @options ||= {}
+  end
+
+  describe "with a sub-type" do
+    before do
+      class ::SubType < @type; end
+      @subtype = ::SubType
+      @type.accept_options :foo, :bar
+    end
+
+    before do
+      @original = @type.accepted_options.dup
+    end
+
+    after do
+      @type.accepted_options.replace(@original - [ :foo, :bar ])
+    end
+
+    describe "predefined options" do
+      before do
+        class ::ChildSubType < @subtype
+          default nil
+        end
+        @child_subtype = ChildSubType
+      end
+
+      describe "when parent type overrides a default" do
+        before do
+          @subtype.default "foo"
+        end
+
+        after do
+          Ardm::Property.descendants.delete(ChildSubType)
+          Object.send(:remove_const, :ChildSubType)
+        end
+
+        it "should not override the child's type setting" do
+          @child_subtype.default.should eql(nil)
+        end
+      end
+    end
+
+    after do
+      Ardm::Property.descendants.delete(SubType)
+      Object.send(:remove_const, :SubType)
+    end
+
+    describe ".accept_options" do
+      describe "when provided :foo, :bar" do
+        it "should add new options" do
+          [@type, @subtype].each do |type|
+            type.accepted_options.include?(:foo).should be(true)
+            type.accepted_options.include?(:bar).should be(true)
+          end
+        end
+
+        it "should create predefined option setters" do
+          [@type, @subtype].each do |type|
+            type.should respond_to(:foo)
+            type.should respond_to(:bar)
+          end
+        end
+
+        describe "auto-generated option setters" do
+          before do
+            @type.foo true
+            @type.bar 1
+            @property = @type.new(@model, @name, @options)
+          end
+
+          it "should set the pre-defined option values" do
+            @property.options[:foo].should == true
+            @property.options[:bar].should == 1
+          end
+
+          it "should ask the superclass for the value if unknown" do
+            @subtype.foo.should == true
+            @subtype.bar.should == 1
+          end
+        end
+      end
+    end
+
+    describe ".descendants" do
+      it "should include the sub-type" do
+        @type.descendants.include?(SubType).should be(true)
+      end
+    end
+
+    describe ".load_as" do
+      it "should return the load_as" do
+        [@type, @subtype].each do |type|
+          type.load_as.should be(@load_as)
+        end
+      end
+
+      it "should change the load_as class" do
+        @subtype.load_as Object
+        @subtype.load_as.should be(Object)
+      end
+    end
+  end
+
+  [:allow_blank, :allow_nil].each do |opt|
+    describe "##{method = "#{opt}?"}" do
+      [true, false].each do |value|
+        describe "when created with :#{opt} => #{value}" do
+          before do
+            @property = @type.new(@model, @name, @options.merge(opt => value))
+          end
+
+          it "should return #{value}" do
+            @property.send(method).should be(value)
+          end
+        end
+      end
+
+      describe "when created with :#{opt} => true and :required => true" do
+        it "should fail with ArgumentError" do
+          lambda {
+            @property = @type.new(@model, @name, @options.merge(opt => true, :required => true))
+          }.should raise_error(ArgumentError,
+            "options[:required] cannot be mixed with :allow_nil or :allow_blank")
+        end
+      end
+    end
+  end
+
+  [:key?, :required?, :index, :unique_index, :unique?].each do |method|
+    describe "##{method}" do
+      [true, false].each do |value|
+        describe "when created with :#{method} => #{value}" do
+          before do
+            opt = method.to_s.chomp('?').to_sym
+            @property = @type.new(@model, @name, @options.merge(opt => value))
+          end
+
+          it "should return #{value}" do
+            @property.send(method).should be(value)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#lazy?" do
+    describe "when created with :lazy => true, :key => false" do
+      before do
+        @property = @type.new(@model, @name, @options.merge(:lazy => true, :key => false))
+      end
+
+      it "should return true" do
+        @property.lazy?.should be(true)
+      end
+    end
+
+    describe "when created with :lazy => true, :key => true" do
+      before do
+        @property = @type.new(@model, @name, @options.merge(:lazy => true, :key => true))
+      end
+
+      it "should return false" do
+        @property.lazy?.should be(false)
+      end
+    end
+  end
+
+  describe '#instance_of?' do
+    subject { property.instance_of?(klass) }
+
+    let(:property) { @type.new(@model, @name, @options) }
+
+    context 'when provided the property class' do
+      let(:klass) { @type }
+
+      it { should be(true) }
+    end
+
+    context 'when provided the property superclass' do
+      let(:klass) { @type.superclass }
+
+      it { should be(false) }
+    end
+
+    context 'when provided the Ardm::Property class' do
+      let(:klass) { Ardm::Property }
+
+      it { should be(false) }
+    end
+  end
+
+  describe '#kind_of?' do
+    subject { property.kind_of?(klass) }
+
+    let(:property) { @type.new(@model, @name, @options) }
+
+    context 'when provided the property class' do
+      let(:klass) { @type }
+
+      it { should be(true) }
+    end
+
+    context 'when provided the property superclass' do
+      let(:klass) { @type.superclass }
+
+      it { should be(true) }
+    end
+
+    context 'when provided the Ardm::Property class' do
+      let(:klass) { Ardm::Property }
+
+      it { should be(true) }
+    end
+  end
+end