mongomodel 0.1

data/lib/mongomodel/support/types.rb

@@ -0,0 +1,35 @@
+require 'mongomodel/support/types/object'
+require 'mongomodel/support/types/string'
+require 'mongomodel/support/types/integer'
+require 'mongomodel/support/types/float'
+require 'mongomodel/support/types/boolean'
+require 'mongomodel/support/types/symbol'
+require 'mongomodel/support/types/date'
+require 'mongomodel/support/types/time'
+require 'mongomodel/support/types/custom'
+require 'mongomodel/support/types/array'
+require 'mongomodel/support/types/hash'
+
+module MongoModel
+  module Types
+    CONVERTERS = {
+      ::String  => Types::String.new,
+      ::Integer => Types::Integer.new,
+      ::Float   => Types::Float.new,
+      ::Boolean => Types::Boolean.new,
+      ::Symbol  => Types::Symbol.new,
+      ::Date    => Types::Date.new,
+      ::Time    => Types::Time.new,
+      ::Array   => Types::Array.new,
+      ::Hash    => Types::Hash.new
+    }
+    
+    def self.converter_for(type)
+      if CONVERTERS[type]
+        CONVERTERS[type]
+      else
+        CONVERTERS[type] = Types::Custom.new(type)
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/array.rb

@@ -0,0 +1,11 @@
+module MongoModel
+  module Types
+    class Array < Object
+      def to_mongo(array)
+        array.map { |i|
+          Types.converter_for(i.class).to_mongo(i)
+        }
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/boolean.rb

@@ -0,0 +1,25 @@
+module MongoModel
+  module Types
+    class Boolean < Object
+      TRUE_VALUES = [ true, 'true', 't', 'TRUE', 'T', 'YES', 'y', '1', 1 ]
+      FALSE_VALUES = [ false, 'false', 'f', 'FALSE', 'F', 'NO', 'n', '0', 0 ]
+      
+      def cast(value)
+        if true?(value)
+          true
+        elsif false?(value)
+          false
+        end
+      end
+    
+    private
+      def true?(value)
+        TRUE_VALUES.include?(value)
+      end
+      
+      def false?(value)
+        FALSE_VALUES.include?(value)
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/custom.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module MongoModel
+  module Types
+    class Custom < Object
+      def initialize(type)
+        @type = type
+      end
+      
+      def cast(value)
+        if value.is_a?(@type)
+          value
+        elsif @type.respond_to?(:cast)
+          @type.cast(value)
+        else
+          @type.new(value)
+        end
+      end
+      
+      def to_mongo(value)
+        if value.respond_to?(:to_mongo)
+          value.to_mongo
+        else
+          value
+        end
+      end
+      
+      def from_mongo(value)
+        if @type.respond_to?(:from_mongo)
+          value = value.with_indifferent_access if value.respond_to?(:with_indifferent_access)
+          @type.from_mongo(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/date.rb

@@ -0,0 +1,20 @@
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/string/conversions'
+
+module MongoModel
+  module Types
+    class Date < Object
+      def cast(value)
+        value.to_date rescue nil
+      end
+      
+      def to_mongo(value)
+        value.strftime("%Y/%m/%d") if value
+      end
+      
+      def from_mongo(value)
+        value.to_date if value
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/float.rb

@@ -0,0 +1,13 @@
+module MongoModel
+  module Types
+    class Float < Object
+      def cast(value)
+        value.to_f if value.respond_to?(:to_f)
+      end
+      
+      def boolean(value)
+        !value.zero?
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/hash.rb

@@ -0,0 +1,18 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module MongoModel
+  module Types
+    class Hash < Object
+      def to_mongo(hash)
+        hash.inject({}) { |result, (k, v)|
+          result[k] = Types.converter_for(v.class).to_mongo(v)
+          result
+        }
+      end
+      
+      def from_mongo(hash)
+        hash.with_indifferent_access if hash
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/integer.rb

@@ -0,0 +1,13 @@
+module MongoModel
+  module Types
+    class Integer < Object
+      def cast(value)
+        value.to_i if value.respond_to?(:to_i)
+      end
+      
+      def boolean(value)
+        !value.zero?
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/object.rb

@@ -0,0 +1,21 @@
+module MongoModel
+  module Types
+    class Object
+      def cast(value)
+        value
+      end
+      
+      def boolean(value)
+        !value.blank?
+      end
+      
+      def to_mongo(value)
+        value
+      end
+      
+      def from_mongo(value)
+        value
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/string.rb

@@ -0,0 +1,9 @@
+module MongoModel
+  module Types
+    class String < Object
+      def cast(value)
+        value.to_s if value.respond_to?(:to_s)
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/symbol.rb

@@ -0,0 +1,9 @@
+module MongoModel
+  module Types
+    class Symbol < Object
+      def cast(value)
+        value.to_sym if value.respond_to?(:to_sym)
+      end
+    end
+  end
+end

data/lib/mongomodel/support/types/time.rb

@@ -0,0 +1,12 @@
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/string/conversions'
+
+module MongoModel
+  module Types
+    class Time < Object
+      def cast(value)
+        value.to_time.utc rescue nil
+      end
+    end
+  end
+end

data/lib/mongomodel/version.rb

@@ -0,0 +1,3 @@
+module MongoModel
+  VERSION = "0.1"
+end

data/spec/mongomodel/attributes/store_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module MongoModel
+  describe Attributes::Store do
+    let(:properties) do
+      properties = ActiveSupport::OrderedHash.new
+      properties[:string]  = MongoModel::Properties::Property.new(:string, String)
+      properties[:integer] = MongoModel::Properties::Property.new(:integer, Integer)
+      properties[:float]   = MongoModel::Properties::Property.new(:float, Float)
+      properties[:boolean] = MongoModel::Properties::Property.new(:boolean, Boolean)
+      properties[:symbol]  = MongoModel::Properties::Property.new(:symbol, Symbol)
+      properties[:hash]    = MongoModel::Properties::Property.new(:hash, Hash)
+      properties[:array]   = MongoModel::Properties::Property.new(:array, Array)
+      properties[:date]    = MongoModel::Properties::Property.new(:date, Date)
+      properties[:time]    = MongoModel::Properties::Property.new(:time, Time)
+      properties[:custom]  = MongoModel::Properties::Property.new(:custom, CustomClass)
+      properties[:default] = MongoModel::Properties::Property.new(:default, String, :default => 'Default')
+      properties[:as]      = MongoModel::Properties::Property.new(:as, String, :as => '_custom_as')
+      properties
+    end
+    let(:instance) { mock('instance', :properties => properties) }
+    
+    subject { Attributes::Store.new(instance) }
+    
+    it "should set default property values" do
+      subject.keys.should == properties.keys
+      subject[:default].should == 'Default'
+    end
+    
+    describe "setting to nil" do
+      specify "all property types should be nullable" do
+        properties.keys.each do |property|
+          subject[property] = nil
+          subject[property].should be_nil
+        end
+      end
+    end
+        
+    it "should set attributes that aren't properties" do
+      subject[:non_property] = "Hello World"
+      subject[:non_property].should == "Hello World"
+    end
+        
+    describe "type-casting" do
+      TypeCastExamples = {
+        :string =>
+          {
+            "abc" => "abc",
+            123   => "123"
+          },
+        :integer =>
+          {
+            123      => 123,
+            55.123   => 55,
+            "999"    => 999,
+            "12.123" => 12
+          },
+        :float =>
+          {
+            55.123   => 55.123,
+            123      => 123.0,
+            "12.123" => 12.123
+          },
+        :boolean =>
+          {
+            true    => true,
+            false   => false,
+            "true"  => true,
+            "false" => false,
+            1       => true,
+            0       => false,
+            "1"     => true,
+            "0"     => false,
+            ''      => nil
+          },
+        :symbol =>
+          {
+            :some_symbol  => :some_symbol,
+            "some_string" => :some_string
+          },
+        :hash =>
+          {
+            { :foo => 'bar' } => { :foo => 'bar' }
+          },
+        :array =>
+          {
+            [123, 'abc', :foo, true] => [123, 'abc', :foo, true]
+          },
+        :date =>
+          {
+            Date.civil(2009, 11, 15)             => Date.civil(2009, 11, 15),
+            Time.local(2008, 12, 3, 0, 0, 0, 0)  => Date.civil(2008, 12, 3),
+            "2009/3/4"                           => Date.civil(2009, 3, 4),
+            "Sat Jan 01 20:15:01 UTC 2000"       => Date.civil(2000, 1, 1)
+          },
+        :time =>
+          {
+            Time.local(2008, 5, 14, 1, 2, 3, 4) => Time.local(2008, 5, 14, 1, 2, 3, 4),
+            Date.civil(2009, 11, 15)            => Time.local(2009, 11, 15, 0, 0, 0, 0),
+            "Sat Jan 01 20:15:01 UTC 2000"      => Time.utc(2000, 1, 1, 20, 15, 1, 0),
+            "2009/3/4"                          => Time.utc(2009, 3, 4, 0, 0, 0, 0)
+          }
+      }
+    
+      TypeCastExamples.each do |type, examples|
+        context "assigning to #{type} property" do
+          examples.each do |assigned, expected|
+            it "should cast #{assigned.inspect} to #{expected.inspect}" do
+              subject[type] = assigned
+              subject[type].should == expected
+            end
+          end
+        end
+      end
+    
+      context "assigning to custom property" do
+        before(:each) do
+          @custom = CustomClass.new('instance name')
+        end
+      
+        it "should not alter instances of CustomClass" do
+          subject[:custom] = @custom
+          subject[:custom].should == @custom
+        end
+      
+        it "should cast strings to CustomClass" do
+          subject[:custom] = "foobar"
+          subject[:custom].should == CustomClass.new('foobar')
+        end
+      end
+    end
+        
+    describe "#before_type_cast" do
+      BeforeTypeCastExamples = {
+        :string => [ "abc", 123 ],
+        :integer => [ 123, 55.123, "999", "12.123" ],
+        :float => [ 55.123, 123, "12.123" ],
+        :boolean => [ true, false, "true", "false", 1, 0, "1", "0", '' ],
+        :symbol => [ :some_symbol, "some_string" ],
+        :hash => [ { :foo => 'bar' } ],
+        :array => [ [123, 'abc', :foo, true] ],
+        :date => [ Date.civil(2009, 11, 15), Time.local(2008, 12, 3, 0, 0, 0, 0), "2009/3/4", "Sat Jan 01 20:15:01 UTC 2000" ],
+        :time => [ Time.local(2008, 5, 14, 1, 2, 3, 4), Date.civil(2009, 11, 15), "Sat Jan 01 20:15:01 UTC 2000", "2009/3/4" ]
+      }
+    
+      BeforeTypeCastExamples.each do |type, examples|
+        context "assigning to #{type} property" do
+          examples.each do |example|
+            it "should access pre-typecasted value of #{example.inspect}" do
+              subject[type] = example
+              subject.before_type_cast(type).should == example
+            end
+          end
+        end
+      end
+    end
+        
+    describe "#has?" do
+      TrueExamples = {
+        :string => [ 'abc', '1' ],
+        :integer => [ -1, 1, 100 ],
+        :float => [ 0.1, 44.123 ],
+        :boolean => [ true, 1, "true" ],
+        :symbol => [ :some_symbol ],
+        :hash => [ { :foo => 'bar' } ],
+        :array => [ [''], [123, 'abc', :foo, true] ],
+        :date => [ Date.civil(2009, 11, 15) ],
+        :time => [ Time.local(2008, 5, 14, 1, 2, 3, 4) ],
+        :custom => [ CustomClass.new('foobar'), 'baz' ]
+      }
+    
+      FalseExamples = {
+        :string => [ nil, '' ],
+        :integer => [ nil, 0 ],
+        :float => [ nil, 0.0 ],
+        :boolean => [ nil, false, 0, "false" ],
+        :symbol => [ nil, 0 ],
+        :hash => [ nil, {} ],
+        :array => [ [] ],
+        :date => [ nil, '' ],
+        :time => [ nil, '' ],
+        :custom => [ nil ]
+      }
+    
+      TrueExamples.each do |type, examples|
+        context "assigning to #{type} property" do
+          examples.each do |example|
+            it "should return true for #{example.inspect}" do
+              subject[type] = example
+              subject.has?(type).should == true
+            end
+          end
+        end
+      end
+    
+      FalseExamples.each do |type, examples|
+        context "assigning to #{type} property" do
+          examples.each do |example|
+            it "should return false for #{example.inspect}" do
+              subject[type] = example
+              subject.has?(type).should == false
+            end
+          end
+        end
+      end
+    end
+        
+    describe "serialization" do
+      it "should convert to mongo representation" do
+        subject[:string] = 'string'
+        subject[:integer] = 42
+        subject[:float] = 123.45
+        subject[:boolean] = false
+        subject[:symbol] = :symbol
+        subject[:hash] = { :foo => 'bar', :custom => CustomClass.new('custom in hash') }
+        subject[:array] = [ 123, 'abc', 45.67, true, :bar, CustomClass.new('custom in array') ]
+        subject[:date] = Date.civil(2009, 11, 15)
+        subject[:time] = Time.local(2008, 5, 14, 1, 2, 3, 4)
+        subject[:custom] = CustomClass.new('custom')
+        subject[:as] = "As property"
+        subject[:non_property] = "Hello World"
+        subject[:custom_non_property] = CustomClass.new('custom non property')
+      
+        subject.to_mongo.should include({
+          'string' => 'string',
+          'integer' => 42,
+          'float' => 123.45,
+          'boolean' => false,
+          'symbol' => :symbol,
+          'hash' => { :foo => 'bar', :custom => { :name => 'custom in hash' } },
+          'array' => [ 123, 'abc', 45.67, true, :bar, { :name => 'custom in array' } ],
+          'date' => "2009/11/15",
+          'time' => Time.local(2008, 5, 14, 1, 2, 3, 4),
+          'custom' => { :name => 'custom' },
+          '_custom_as' => "As property",
+          'non_property' => "Hello World",
+          'custom_non_property' => { :name => 'custom non property' },
+        })
+      end
+    
+      it "should load from mongo representation" do
+        subject.from_mongo!({
+          'string' => 'string',
+          'integer' => 42,
+          'float' => 123.45,
+          'boolean' => false,
+          'symbol' => :symbol,
+          'hash' => { :foo => 'bar' },
+          'array' => [ 123, 'abc', 45.67, true, :bar ],
+          'date' => Time.utc(2009, 11, 15),
+          'time' => Time.local(2008, 5, 14, 1, 2, 3, 4),
+          'custom' => { :name => 'custom' },
+          '_custom_as' => "As property",
+          'custom_non_property' => { :name => 'custom non property' }
+        })
+      
+        subject[:string].should == 'string'
+        subject[:integer].should == 42
+        subject[:float].should == 123.45
+        subject[:boolean].should == false
+        subject[:symbol].should == :symbol
+        subject[:hash].should == { :foo => 'bar' }.with_indifferent_access
+        subject[:array].should == [ 123, 'abc', 45.67, true, :bar ]
+        subject[:date].should == Date.civil(2009, 11, 15)
+        subject[:time].should == Time.local(2008, 5, 14, 1, 2, 3, 4)
+        subject[:custom].should == CustomClass.new('custom')
+        subject[:as].should == "As property"
+        subject[:custom_non_property].should == { :name => 'custom non property' }
+      end
+    end
+  end
+end