ardm 0.0.1

data/spec/public/property_spec.rb

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'addressable/uri'
+
+# instance methods
+describe Ardm::Property do
+
+  # define the model prior to supported_by
+  before do
+    class ::Track < Ardm::Record
+      property :id,               Serial
+      property :artist,           String, :lazy => false, :index => :artist_album
+      property :title,            String, :field => 'name', :index => true
+      property :album,            String, :index => :artist_album
+      property :musicbrainz_hash, String, :unique => true, :unique_index => true
+    end
+
+    class ::Image < Ardm::Record
+      property :md5hash,      String, :key => true, :length => 32
+      property :title,        String, :required => true, :unique => true
+      property :description,  Text,   :length => 1..1024, :lazy => [ :detail ]
+      property :width,        Integer, :lazy => [:dimensions]
+      property :height,       Integer, :lazy => [:dimensions]
+      property :format,       String, :default => 'jpeg'
+      property :taken_at,     Time,   :default => proc { Time.now }
+
+      validates_presence_of :format
+    end
+  end
+
+  describe '#field' do
+    it 'returns @field value if it is present' do
+      Track.properties[:title].field.should eql('name')
+    end
+  end
+
+  describe '#default_for' do
+    it 'returns default value for non-callables' do
+      Image.properties[:format].default_for(Image.new).should == 'jpeg'
+    end
+
+    it 'returns result of a call for callable values' do
+      Image.properties[:taken_at].default_for(Image.new).year.should == Time.now.year
+    end
+
+    it "sets the default when the record is created" do
+      img = Image.create!(title: 'My Picture')
+      img.format.should == 'jpeg'
+    end
+  end
+
+  describe '#eql?' do
+    it 'is true for properties with the same model and name' do
+      Track.properties[:title].should eql(Track.properties[:title])
+    end
+
+
+    it 'is false for properties of different models' do
+      Track.properties[:title].should_not eql(Image.properties[:title])
+    end
+
+    it 'is false for properties with different names' do
+      Track.properties[:title].should_not eql(Track.properties[:id])
+    end
+  end
+
+  describe '#get!' do
+    before do
+      @image = Image.new
+
+      # now some dark Ruby magic
+      @image.instance_variable_set(:@description, 'Is set by magic')
+    end
+
+    it 'gets instance variable value from the resource directly' do
+      pending "support for this in ActiveRecord is questionable" do
+        # if you know a better way to test direct instance variable access,
+        # go ahead and make changes to this example
+        Image.properties[:description].get!(@image).should == 'Is set by magic'
+      end
+    end
+  end
+
+  describe '#index' do
+    it 'returns true when property has an index' do
+      Track.properties[:title].index.should be(true)
+    end
+
+    it 'returns index name when property has a named index' do
+      Track.properties[:album].index.should eql(:artist_album)
+    end
+
+    it 'returns false when property has no index' do
+      Track.properties[:musicbrainz_hash].index.should be(false)
+    end
+  end
+
+  describe '#initialize' do
+    describe 'when tracking strategy is explicitly given' do
+      it 'uses tracking strategy from options'
+    end
+  end
+
+  describe '#inspect' do
+    before do
+      @str = Track.properties[:title].inspect
+    end
+
+    it 'features model name' do
+      @str.should =~ /@model=Track/
+    end
+
+    it 'features property name' do
+      @str.should =~ /@name=:title/
+    end
+  end
+
+  describe '#key?' do
+    describe 'returns true when property is a ' do
+      it 'serial key' do
+        Track.properties[:id].key?.should be(true)
+      end
+      it 'natural key' do
+        Image.properties[:md5hash].key?.should be(true)
+      end
+    end
+
+    it 'returns true when property is a part of composite key'
+
+    it 'returns false when property does not relate to a key' do
+      Track.properties[:title].key?.should be(false)
+    end
+  end
+
+  describe '#lazy?' do
+    it 'returns true when property is lazy loaded' do
+      Image.properties[:description].lazy?.should be(true)
+    end
+
+    it 'returns false when property is not lazy loaded' do
+      Track.properties[:artist].lazy?.should be(false)
+    end
+  end
+
+  describe '#length' do
+    it 'returns upper bound for Range values' do
+      Image.properties[:description].length.should eql(1024)
+    end
+
+    it 'returns value as is for integer values' do
+      Image.properties[:md5hash].length.should eql(32)
+    end
+  end
+
+  describe '#min' do
+    describe 'when :min and :max options not provided to constructor' do
+      before do
+        @property = Image.property(:integer_with_nil_min, Integer)
+      end
+
+      it 'should be nil' do
+        @property.min.should be_nil
+      end
+    end
+
+    describe 'when :min option not provided to constructor, but :max is provided' do
+      before do
+        @property = Image.property(:integer_with_default_min, Integer, :max => 1)
+      end
+
+      it 'should be the default value' do
+        @property.min.should == 0
+      end
+    end
+
+    describe 'when :min and :max options provided to constructor' do
+      before do
+        @min = 1
+        @property = Image.property(:integer_with_explicit_min, Integer, :min => @min, :max => 2)
+      end
+
+      it 'should be the expected value' do
+        @property.min.should == @min
+      end
+    end
+  end
+
+  describe '#max' do
+    describe 'when :min and :max options not provided to constructor' do
+      before do
+        @property = Image.property(:integer_with_nil_max, Integer)
+      end
+
+      it 'should be nil' do
+        @property.max.should be_nil
+      end
+    end
+
+    describe 'when :max option not provided to constructor, but :min is provided' do
+      before do
+        @property = Image.property(:integer_with_default_max, Integer, :min => 1)
+      end
+
+      it 'should be the default value' do
+        @property.max.should == 2**31-1
+      end
+    end
+
+    describe 'when :min and :max options provided to constructor' do
+      before do
+        @max = 2
+        @property = Image.property(:integer_with_explicit_max, Integer, :min => 1, :max => @max)
+      end
+
+      it 'should be the expected value' do
+        @property.max.should == @max
+      end
+    end
+  end
+
+  describe '#allow_nil?' do
+    it 'returns true when property can accept nil as its value' do
+      Track.properties[:artist].allow_nil?.should be(true)
+    end
+
+    it 'returns false when property nil value is prohibited for this property' do
+      Image.properties[:title].allow_nil?.should be(false)
+    end
+  end
+
+  describe '#serial?' do
+    it 'returns true when property is serial (auto incrementing)' do
+      Track.properties[:id].serial?.should be(true)
+    end
+
+    it 'returns false when property is NOT serial (auto incrementing)' do
+      Image.properties[:md5hash].serial?.should be(false)
+    end
+  end
+
+  describe '#set' do
+    before do
+      # keep in mind we must run these examples with a
+      # saved model instance
+      @image = Image.create(
+        :md5hash     => '5268f0f3f452844c79843e820f998869',
+        :title       => 'Rome at the sunset',
+        :description => 'Just wow'
+      )
+
+      @property = Image.properties[:title]
+    end
+
+    it 'triggers lazy loading for given resource'
+
+    it 'type casts given value' do
+      @property.set(@image, Addressable::URI.parse('http://test.example/'))
+      # get a string that has been typecasted using #to_str
+      @image.title.should == 'http://test.example/'
+    end
+
+    it 'sets new property value' do
+      @property.set(@image, 'Updated value')
+      @image.title.should == 'Updated value'
+    end
+  end
+
+  describe '#set!' do
+    before do
+      @image = Image.new(:md5hash      => '5268f0f3f452844c79843e820f998869',
+                         :title       => 'Rome at the sunset',
+                         :description => 'Just wow')
+
+      @property = Image.properties[:title]
+    end
+
+    it 'directly sets instance variable on given resource' do
+      @property.set!(@image, 'Set with dark Ruby magic')
+      @image.title.should == 'Set with dark Ruby magic'
+    end
+  end
+
+  describe '#unique?' do
+    it 'is true for fields that explicitly given uniq index' do
+      Track.properties[:musicbrainz_hash].unique?.should be(true)
+    end
+
+    it 'is true for serial fields' do
+      pending do
+        Track.properties[:title].unique?.should be(true)
+      end
+    end
+
+    it 'is true for keys' do
+      Image.properties[:md5hash].unique?.should be(true)
+    end
+  end
+
+  describe '#unique_index' do
+    it 'returns true when property has unique index' do
+      Track.properties[:musicbrainz_hash].unique_index.should be(true)
+    end
+
+    it 'returns false when property has no unique index' do
+      Track.properties[:title].unique_index.should be(false)
+    end
+
+    it 'returns true when property is unique' do
+      Image.properties[:title].unique_index.should be(true)
+    end
+
+    it 'returns :key when property is a key' do
+      Track.properties[:id].unique_index.should == :key
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/schema.rb

@@ -0,0 +1,86 @@
+::ActiveRecord::Schema.define do
+
+  create_table :api_users, :force => true do |t|
+    t.string :name
+    t.string :api_key
+  end
+
+  create_table :articles, :force => true do |t|
+    t.string   :title
+    t.text     :body
+    t.timestamps
+    t.datetime :published_at
+    t.boolean  :deleted
+    t.datetime :deleted_at
+    t.string   :slug
+  end
+
+  create_table :bookmarks, :force => true do |t|
+    t.string     :title
+    t.boolean    :shared
+    t.string     :uri
+    t.text       :tags
+  end
+
+  create_table :images, :force => true, :id => false do |t|
+    t.string   :md5hash, :length => 32
+    t.index    :md5hash, :unique => true
+    t.string   :title
+    t.text     :description, :length => 1024
+    t.integer  :width
+    t.integer  :height
+    t.string   :format
+    t.time     :taken_at
+  end
+
+  create_table :network_nodes, :force => true do |t|
+    t.string     :ip_address
+    t.integer    :cidr_subnet_bits
+    t.string     :node_uuid
+  end
+
+  create_table :people, :force => true do |t|
+    t.string :name
+    t.text   :positions
+    t.text   :inventions
+    t.time   :birthday
+    t.text   :interests
+    t.string :password
+  end
+
+  create_table :software_packages, :force => true do |t|
+    t.integer  :node_number
+    t.string   :source_path
+    t.string   :destination_path
+    t.string   :product
+    t.string   :version
+    t.datetime :released_at
+    t.boolean  :security_update
+    t.datetime :installed_at
+    t.string   :installed_by
+  end
+
+  create_table :tickets, :force => true do |t|
+    t.string   :title
+    t.text     :body
+    t.integer  :status
+  end
+
+  create_table :tracks, :force => true do |t|
+    t.string   :artist
+    t.string   :name
+    t.string   :album
+    t.string   :musicbrainz_hash
+    t.index    [:artist, :album]
+    t.index    :name
+    t.index    :musicbrainz_hash, :unique => true
+  end
+
+  create_table :tshirts, :force => true do |t|
+    t.string   :writing
+    t.boolean  :has_picture
+    t.text     :picture
+    t.text     :color
+    t.text     :size
+  end
+end

data/spec/semipublic/property/binary_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ardm::Property::Binary 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'
+end

data/spec/semipublic/property/boolean_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Ardm::Property::Boolean do
+  let(:name)          { :active }
+  let(:type)          { described_class }
+  let(:options)       { {:set => [true, false]} }
+  let(:value)         { true }
+  let(:other_value)   { false }
+  let(:invalid_value) { 1 }
+  let(:model) { Blog::Article }
+  let(:property) { type.new(model, name, options) }
+
+  it_should_behave_like 'A semipublic Property'
+
+  describe '#valid?' do
+    [ true, false ].each do |value|
+      it "returns true when value is #{value.inspect}" do
+        property.valid?(value).should be(true)
+      end
+    end
+
+    [ 'true', 'TRUE', '1', 1, 't', 'T', 'false', 'FALSE', '0', 0, 'f', 'F' ].each do |value|
+      it "returns false for #{value.inspect}" do
+        property.valid?(value).should be(false)
+      end
+    end
+  end
+
+  describe '#typecast' do
+    [ true, 'true', 'TRUE', '1', 1, 't', 'T' ].each do |value|
+      it "returns true when value is #{value.inspect}" do
+        property.typecast(value).should be(true)
+      end
+    end
+
+    [ false, 'false', 'FALSE', '0', 0, 'f', 'F' ].each do |value|
+      it "returns false when value is #{value.inspect}" do
+        property.typecast(value).should be(false)
+      end
+    end
+
+    [ 'string', 2, 1.0, BigDecimal('1.0'), DateTime.now, Time.now, Date.today, Class, Object.new, ].each do |value|
+      it "does not typecast value #{value.inspect}" do
+        property.typecast(value).should equal(value)
+      end
+    end
+  end
+end

data/spec/semipublic/property/class_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Ardm::Property::Class 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'
+
+  describe '#typecast' do
+    it 'returns same value if a class' do
+      property.typecast(model).should equal(model)
+    end
+
+    it 'returns the class if found' do
+      property.typecast(model.name).should eql(model)
+    end
+
+    it 'does not typecast non-class values' do
+      property.typecast('NoClass').should eql('NoClass')
+    end
+  end
+end

data/spec/semipublic/property/date_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Ardm::Property::Date do
+  let(:name)          { :created_on }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { Date.today }
+  let(:other_value)   { Date.today + 1 }
+  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 Date instance from hash values' do
+        result = property.typecast(
+          :year  => '2007',
+          :month => '3',
+          :day   => '25'
+        )
+
+        result.should be_kind_of(Date)
+        result.year.should eql(2007)
+        result.month.should eql(3)
+        result.day.should eql(25)
+      end
+    end
+
+    describe 'and value is a string' do
+      it 'parses the string' do
+        result = property.typecast('Dec 20th, 2006')
+        result.month.should == 12
+        result.day.should == 20
+        result.year.should == 2006
+      end
+    end
+
+    it 'does not typecast non-date values' do
+      property.typecast('not-date').should eql('not-date')
+    end
+  end
+end

data/spec/semipublic/property/date_time_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Ardm::Property::DateTime do
+  let(:name)          { :created_at }
+  let(:type)          { described_class }
+  let(:options)       { {} }
+  let(:value)         { DateTime.now }
+  let(:other_value)   { DateTime.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 DateTime 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(DateTime)
+        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
+        property.typecast('Dec, 2006').month.should == 12
+      end
+    end
+
+    it 'does not typecast non-datetime values' do
+      property.typecast('not-datetime').should eql('not-datetime')
+    end
+  end
+end

data/spec/semipublic/property/decimal_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Ardm::Property::Decimal do
+  let(:name)          { :rate }
+  let(:type)          { described_class }
+  let(:options)       { { :precision => 5, :scale => 2 } }
+  let(:value)         { BigDecimal('1.0') }
+  let(:other_value)   { BigDecimal('2.0') }
+  let(:invalid_value) { true }
+  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 decimal' do
+      @value = BigDecimal('24.0')
+      property.typecast(@value).should equal(@value)
+    end
+
+    it 'returns decimal representation of a zero string integer' do
+      property.typecast('0').should eql(BigDecimal('0.0'))
+    end
+
+    it 'returns decimal representation of a positive string integer' do
+      property.typecast('24').should eql(BigDecimal('24.0'))
+    end
+
+    it 'returns decimal representation of a negative string integer' do
+      property.typecast('-24').should eql(BigDecimal('-24.0'))
+    end
+
+    it 'returns decimal representation of a zero string float' do
+      property.typecast('0.0').should eql(BigDecimal('0.0'))
+    end
+
+    it 'returns decimal representation of a positive string float' do
+      property.typecast('24.35').should eql(BigDecimal('24.35'))
+    end
+
+    it 'returns decimal representation of a negative string float' do
+      property.typecast('-24.35').should eql(BigDecimal('-24.35'))
+    end
+
+    it 'returns decimal representation of a zero string float, with no leading digits' do
+      property.typecast('.0').should eql(BigDecimal('0.0'))
+    end
+
+    it 'returns decimal representation of a positive string float, with no leading digits' do
+      property.typecast('.41').should eql(BigDecimal('0.41'))
+    end
+
+    it 'returns decimal representation of a zero integer' do
+      property.typecast(0).should eql(BigDecimal('0.0'))
+    end
+
+    it 'returns decimal representation of a positive integer' do
+      property.typecast(24).should eql(BigDecimal('24.0'))
+    end
+
+    it 'returns decimal representation of a negative integer' do
+      property.typecast(-24).should eql(BigDecimal('-24.0'))
+    end
+
+    it 'returns decimal representation of a zero float' do
+      property.typecast(0.0).should eql(BigDecimal('0.0'))
+    end
+
+    it 'returns decimal representation of a positive float' do
+      property.typecast(24.35).should eql(BigDecimal('24.35'))
+    end
+
+    it 'returns decimal representation of a negative float' do
+      property.typecast(-24.35).should eql(BigDecimal('-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