ohm-contrib 0.0.8 → 0.0.9

data/Rakefile

@@ -14,6 +14,7 @@ begin
     gem.add_development_dependency "redis", ">= 0"
     gem.add_development_dependency "ohm", ">= 0"
     gem.add_development_dependency "timecop", ">= 0"
+    gem.add_development_dependency "mocha", ">= 0"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -52,4 +53,4 @@ Rake::RDocTask.new do |rdoc|
   rdoc.title = "ohm-contrib #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
-end
+end

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/ohm/contrib.rb

@@ -1,6 +1,6 @@
 module Ohm
   module Contrib
-    VERSION = '0.0.8'
+    VERSION = '0.0.9'
   end
 
   autoload :Boundaries,        "ohm/contrib/boundaries"

data/lib/ohm/contrib/typecast.rb

@@ -1,163 +1,91 @@
 require 'bigdecimal'
 require 'time'
 require 'date'
+require 'forwardable'
 
 module Ohm
   module Types
-    class String < ::String
-      def self.[](value)
-        new(value)
+    class Primitive < BasicObject
+      def initialize(value)
+        @raw = value
       end
-    end
-
-    class Time < ::Time
-      ASSERTION = :assert_type_time
-
-      def self.[](value)
-        return value if value.to_s.empty?
 
-        ret = parse(value)
-        ret.to_s == value ? ret : value
+      def to_s
+        @raw
       end
-    end
-
-    class Date < ::Date
-      ASSERTION = :assert_type_date
-
-      def self.[](value)
-        return value if value.to_s.empty?
 
-        parse(value)
-      rescue ArgumentError
-        value
+      def inspect
+        "#<Primitive raw=#{@raw}>"
       end
-    end
-
-    class Decimal < BigDecimal
-      ASSERTION = :assert_type_decimal
-      CANONICAL = /^(\d+)?(\.\d+)?(E[+\-]\d+)?$/
-
-      def self.[](value)
-        return value if value.to_s.empty?
 
-        if value.to_s =~ CANONICAL
-          new(value)
-        else
-          value
-        end
+    protected
+      def object
+        @raw
       end
-    end
 
-    class Float < ::Float
-      ASSERTION = :assert_type_float
-
-      def self.[](value)
-        return value if value.to_s.empty?
-
-        Float(value)
-      rescue ArgumentError
-        value
+      def method_missing(meth, *args, &blk)
+        object.send(meth, *args, &blk)
       end
     end
 
-    class Integer < ::Integer
-      ASSERTION = :assert_type_integer
-
-      def self.[](value)
-        return value if value.to_s.empty?
-
-        Integer(value)
-      rescue ArgumentError
-        value
-      end
+    class String < Primitive
     end
-  end
-  
-  module TypeAssertions
 
-  protected
-    def assert_type_decimal(att, error = [att, :not_decimal])
-      assert send(att).is_a?(Ohm::Types::Decimal), error
+    class Decimal < Primitive
+    protected
+      def object
+        ::Kernel::BigDecimal(@raw)
+      end
     end
 
-    def assert_type_time(att, error = [att, :not_time])
-      assert send(att).is_a?(Ohm::Types::Time), error 
+    class Integer < Primitive
+    protected
+      def object
+        ::Kernel::Integer(@raw)
+      end
     end
 
-    def assert_type_date(att, error = [att, :not_date])
-      assert send(att).is_a?(Ohm::Types::Date), error 
+    class Float < Primitive
+    protected
+      def object
+        ::Kernel::Float(@raw)
+      end
     end
 
-    def assert_type_integer(att, error = [att, :not_integer])
-      assert send(att).is_a?(Ohm::Types::Integer), error
+    class Time < Primitive
+    protected
+      def object
+        ::Time.parse(@raw)
+      end
     end
 
-    def assert_type_float(att, error = [att, :not_float])
-      assert send(att).is_a?(Ohm::Types::Float), error
+    class Date < Primitive
+    protected
+      def object
+        ::Date.parse(@raw)
+      end
     end
   end
-
+  
   module Typecast
-    class MissingValidation < StandardError
-      MESSAGE = "%s :%s is required in your #validate method"
-
-      attr :field
-      attr :assertion
-
-      def initialize(field, assertion)
-        @field, @assertion = field, assertion
-      end
-
-      def message
-        MESSAGE % [assertion, field]
-      end
-    end
-
     include Types
-    include TypeAssertions
-    
+
     def self.included(base)
       base.extend ClassMethods
     end
 
     module ClassMethods
-      def attribute(name, type = Ohm::Types::String, assertion = defined?(type::ASSERTION) ? type::ASSERTION : nil)
+      def attribute(name, type = Ohm::Types::String)
         define_method(name) do
-          type[read_local(name)]
+          value = read_local(name)
+          value && type.new(value)
         end
 
         define_method(:"#{name}=") do |value|
-          if type.respond_to?(:dump)
-            write_local(name, type.dump(value))
-          else
-            write_local(name, value && value.to_s)
-          end
+          write_local(name, value && value.to_s)
         end
 
         attributes << name unless attributes.include?(name)
-        types[name] = [type, assertion] unless types.has_key?(name)
-      end
-      
-      def types
-        @types ||= {}
-      end
-    end
-
-    def valid?
-      return unless super
-
-      self.class.types.each do |field, (type, assertion)|
-        value = send(field)
-        
-        unless value.kind_of?(type)
-          raise MissingValidation.new(field, assertion)
-        end
-      end
-    end
-
-    def validate
-      self.class.types.each do |field, (type, assertion)|
-        send assertion, field  if assertion
       end
     end
   end

data/ohm-contrib.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ohm-contrib}
-  s.version = "0.0.8"
+  s.version = "0.0.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Cyril David"]
@@ -65,17 +65,20 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<redis>, [">= 0"])
       s.add_development_dependency(%q<ohm>, [">= 0"])
       s.add_development_dependency(%q<timecop>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
       s.add_dependency(%q<contest>, [">= 0"])
       s.add_dependency(%q<redis>, [">= 0"])
       s.add_dependency(%q<ohm>, [">= 0"])
       s.add_dependency(%q<timecop>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
     s.add_dependency(%q<contest>, [">= 0"])
     s.add_dependency(%q<redis>, [">= 0"])
     s.add_dependency(%q<ohm>, [">= 0"])
     s.add_dependency(%q<timecop>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end
 

data/test/helper.rb

@@ -4,6 +4,7 @@ require 'contest'
 require 'redis'
 require 'ohm'
 require 'timecop'
+require 'mocha'
 
 Ohm.connect :host => "localhost", :port => "6380"
 
@@ -12,4 +13,4 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'ohm/contrib'
 
 class Test::Unit::TestCase
-end
+end

data/test/test_ohm_typecast.rb

@@ -1,383 +1,238 @@
 require "helper"
 
 class TestOhmTypecast < Test::Unit::TestCase
-  context "decimal typecasting" do
-    class Product < Ohm::Model
+  context "the default case of just an attribute" do
+    class Post < Ohm::Model
       include Ohm::Typecast
-
-      attribute :price, Decimal
-
-      # override validate and purposely forget super
-      def validate
-      end
+      
+      attribute :content
     end
 
-    should "properly preserve the right precision" do
-      product = Product.create(:price => 0.0001)
-      product = Product[product.id]
-      sum = 0
-      1_000.times { sum += product.price }
+    test "handles nil case correctly" do
+      post = Post.create(:content => nil)
+      post = Post[post.id]
 
-      assert_equal 0.1, sum
+      assert_nil post.content
     end
 
-    context "given a non-decimal value FooBar" do
-      should "preseve the value FooBar" do
-        product = Product.new(:price => "FooBar")
-        assert_equal "FooBar", product.price
-      end
-
-      should "raise a MissingValidation error during validation" do
-        product = Product.new(:price => "FooBar")
+    test "still responds to string methods properly" do
+      post = Post.create(:content => "FooBar")
+      post = Post[post.id]
 
-        begin
-          product.valid?
-        rescue Ohm::Typecast::MissingValidation => ex
-          assert_match(/assert_type_decimal :price is required in your #validate method/, ex.message)
-        else
-          flunk "Should have raised MissingValidation"
-        end
-      end
-    end
-
-    context "given a non-decimal value FooBar but with assert_type_decimal" do
-      class Post < Ohm::Model
-        include Ohm::Typecast
-
-        attribute :price, Decimal
-      end
-
-      should "be invalid and have an error on the field" do
-        post = Post.new(:price => "FooBar")
-
-        assert ! post.valid?
-        assert_equal [[:price, :not_decimal]], post.errors
-      end
+      assert_equal "foobar", post.content.downcase
     end
   end
 
-  context "time typecasting" do
-    class Product < Ohm::Model
+  context "when using a decimal" do
+    class Post < Ohm::Model
       include Ohm::Typecast
-
-      attribute :start_of_sale, Time
-  
-      # we override validate and purposely forget to call super
-      def validate
-      end
+      
+      attribute :price, Decimal
     end
 
-    test "read / write" do
-      @time = Time.now.utc
-      product = Product.create(:start_of_sale => @time)
-      product = Product[product.id]
+    test "handles nil case correctly" do
+      post = Post.create(:price => nil)
+      post = Post[post.id]
 
-      assert_equal @time.to_s, product.start_of_sale.to_s
+      assert_nil post.price
     end
 
-    test "the retrieved value is a Time object" do
-      @time = Time.now.utc
-      product = Product.create(:start_of_sale => @time)
-      product = Product[product.id]
-
-      assert_kind_of Time, product.start_of_sale
+    test "handles empty string case correctly" do
+      post = Post.create(:price => "")
+      post = Post[post.id]
+      
+      assert_equal "", post.price.to_s
     end
 
-    test "an invalid string" do
-      begin
-        Product.create(:start_of_sale => "invalid time")
-      rescue Ohm::Typecast::MissingValidation => ex
-        assert_match(/assert_type_time :start_of_sale is required in your #validate method/, ex.message)
-      else
-        flunk "Should have raised MissingValidation"
-      end
-    end
+    test "allows for real arithmetic" do
+      post = Post.create(:price => "0.01")
+      post = Post[post.id]
 
-    test "when nil" do
-      product = Product.new(:start_of_sale => nil)
-      assert_nil product.start_of_sale
+      assert_equal 0.02,   post.price + post.price
+      assert_equal 0.0,    post.price - post.price
+      assert_equal 0.0001, post.price * post.price
+      assert_equal 1.0,    post.price / post.price
     end
 
-    test "when empty string" do
-      product = Product.new(:start_of_sale => "")
-      assert_equal "", product.start_of_sale
+    test "is accurate accdg to the decimal spec" do
+      post = Post.create(:price => "0.0001")
+      post = Post[post.id]
+      
+      sum = 0
+      1_000.times { sum += post.price }
+      assert_equal 0.1, sum
     end
   end
 
-  context "time typecasting with assert_type_time" do
+  context "when using an integer" do
     class Post < Ohm::Model
       include Ohm::Typecast
-
-      attribute :start_of_sale, Time
-    end
-
-    should "be valid given invalid time value" do
-      post = Post.new(:start_of_sale => "FooBar")
-      assert ! post.valid?
-      assert_equal [[:start_of_sale, :not_time]], post.errors
+      
+      attribute :price, Integer
     end
-  end
 
-  context "date typecasting" do
-    class Product < Ohm::Model
-      include Ohm::Typecast
-
-      attribute :date_bought, Date
+    test "handles nil case correctly" do
+      post = Post.create(:price => nil)
+      post = Post[post.id]
 
-      # override validate and purposely forget super
-      def validate
-      end
+      assert_nil post.price
     end
 
-    test "read / write" do
-      @date = Date.today
-      product = Product.create(:date_bought => @date)
-      product = Product[product.id]
-
-      assert_equal @date, product.date_bought
+    test "handles empty string case correctly" do
+      post = Post.create(:price => "")
+      post = Post[post.id]
+      
+      assert_equal "", post.price.to_s
     end
 
-    test "the retrieved value is a Date object" do
-      @date = Date.today
-      product = Product.create(:date_bought => @date)
-      product = Product[product.id]
+    test "allows for real arithmetic" do
+      post = Post.create(:price => "3")
+      post = Post[post.id]
 
-      assert_kind_of Date, product.date_bought
+      assert_equal 6,      post.price + post.price
+      assert_equal 0,      post.price - post.price
+      assert_equal 9,      post.price * post.price
+      assert_equal 1,      post.price / post.price
     end
 
-    test "assigning a string which is not a valid date" do
-      begin
-        Product.create(:date_bought => "Bla Bla")
-      rescue Ohm::Typecast::MissingValidation => ex
-        assert_match(/assert_type_date :date_bought is required in your #validate method/, ex.message)
-      else
-        flunk "Should have raised MissingValidation"
+    test "raises when trying to do arithmetic ops on a non-int" do
+      post = Post.create(:price => "FooBar")
+      post = Post[post.id]
+      
+      assert_raise ArgumentError do
+        post.price * post.price
       end
     end
-
-    test "when nil" do
-      assert_nil Product.new.date_bought
-    end
-
-    test "empty string" do
-      assert_equal "", Product.new(:date_bought => "").date_bought
-    end
   end
 
-  context "date typecasting with assert_type_date" do
+  context "when using an float" do
     class Post < Ohm::Model
       include Ohm::Typecast
-
-      attribute :created, Date
-
-      def validate
-        assert_type_date :created
-      end
-    end
-
-    should "have an invalid created field on save" do
-      post = Post.new(:created => "FooBar")
-      assert ! post.valid?
-      assert_equal [[:created, :not_date]], post.errors
-      assert_equal "FooBar", post.created
-    end
-  end
-
-  context "integer typecasting" do
-    class Product < Ohm::Model
-      include Ohm::Typecast
-
-      attribute :stock_count, Integer
+      
+      attribute :price, Float
     end
 
-    test "when nil" do
-      assert_nil Product.new(:stock_count => nil).stock_count
-    end
+    test "handles nil case correctly" do
+      post = Post.create(:price => nil)
+      post = Post[post.id]
 
-    test "when empty string" do
-      assert_equal "", Product.new(:stock_count => "").stock_count
+      assert_nil post.price
     end
 
-    test "when unparseable" do
-      assert_equal "FooBar", Product.new(:stock_count => "FooBar").stock_count
+    test "handles empty string case correctly" do
+      post = Post.create(:price => "")
+      post = Post[post.id]
+      
+      assert_equal "", post.price.to_s
     end
 
-    test "when a float" do
-      assert_equal '1.0', Product.new(:stock_count => "1.0").stock_count
-    end
+    test "allows for real arithmetic" do
+      post = Post.create(:price => "3")
+      post = Post[post.id]
 
-    test "when a real int" do
-      assert_equal 1, Product.new(:stock_count => '1').stock_count
+      assert_equal 6.0, post.price + post.price
+      assert_equal 0.0, post.price - post.price
+      assert_equal 9.0, post.price * post.price
+      assert_equal 1.0, post.price / post.price
     end
-  end
-
-  context "integer typecasting with assert_type_integer validation" do
-    class Post < Ohm::Model
-      include Ohm::Typecast
 
-      attribute :counter, Integer
-
-      def validate
-        assert_type_integer :counter
+    test "raises when trying to do arithmetic ops on a non-float" do
+      post = Post.create(:price => "FooBar")
+      post = Post[post.id]
+      
+      assert_raise ArgumentError do
+        post.price * post.price
       end
     end
-
-    should "have an error on counter given a non-integer value" do
-      post = Post.new(:counter => "FooBar")
-      assert ! post.valid?
-      assert_equal [[:counter, :not_integer]], post.errors
-      assert_equal "FooBar", post.counter
-    end
   end
 
-  context "float typecasting" do
-    class Product < Ohm::Model
+  context "when using a time" do
+    class Post < Ohm::Model
       include Ohm::Typecast
-
-      attribute :vat, Float
-    end
-
-    test "when nil" do
-      assert_nil Product.new(:vat => nil).vat
+      
+      attribute :created_at, Time
     end
 
-    test "when empty string" do
-      assert_equal "", Product.new(:vat => "").vat
-    end
+    test "handles nil case correctly" do
+      post = Post.create(:created_at => nil)
+      post = Post[post.id]
 
-    test "when unparseable" do
-      assert_equal "FooBar", Product.new(:vat => "FooBar").vat
+      assert_nil post.created_at
     end
 
-    test "when a float" do
-      assert_equal 1.0, Product.new(:vat => "1.0").vat
+    test "handles empty string case correctly" do
+      post = Post.create(:created_at => "")
+      post = Post[post.id]
+      
+      assert_equal "", post.created_at.to_s
     end
 
-    test "when an int" do
-      assert_equal 1.0, Product.new(:vat => '1').vat
+    test "allows for real time operations" do
+      post = Post.create(:created_at => "2010-05-10")
+      post = Post[post.id]
+      
+      assert_respond_to post.created_at, :strftime
+      assert_equal "2010-05-10", post.created_at.strftime('%Y-%m-%d')
     end
 
-    test "when a .12 value" do
-      assert_equal 0.12, Product.new(:vat => ".12").vat
-    end
-  end
-
-  context "float typecasting with assert_type_float validation" do
-    class Post < Ohm::Model
-      include Ohm::Typecast
-
-      attribute :quotient, Float
+    test "raises when trying to do non-time operations" do
+      post = Post.create(:created_at => "FooBar")
+      post = Post[post.id]
+      
+      assert ! post.created_at.respond_to?(:slice)
 
-      def validate
-        assert_type_float :quotient
+      assert_raise NoMethodError do
+        post.created_at.slice
       end
     end
-
-    should "have an error on quotient given a non-float value" do
-      post = Post.new(:quotient => "FooBar")
-      assert ! post.valid?
-      assert_equal [[:quotient, :not_float]], post.errors
-      assert_equal "FooBar", post.quotient
-    end
   end
 
-
-  context "trying to validate numericality of a decimal" do
-    class Item < Ohm::Model
+  context "when using a date" do
+    class Post < Ohm::Model
       include Ohm::Typecast
+      
+      attribute :created_on, Date
 
-      attribute :price, Decimal
-
-      def validate
-        assert_numeric :price
-      end
-    end
-
-    setup do
-      @item = Item.new(:price => "FooBar")
-    end
-
-    test "invalidation of price" do
-      assert ! @item.valid?
-      assert_equal [[:price, :not_numeric]], @item.errors
-    end
-  end
-
-  context "specifying a custom DataType without a #dump method" do
-    class ::FooBar < Struct.new(:value)
-      def self.[](str)
-        new(str)
+      def today
+        ::Date.today
       end
     end
-    
-    class Item < Ohm::Model
-      include Ohm::Typecast
 
-      attribute :foo, FooBar
-    end
+    test "handles nil case correctly" do
+      post = Post.create(:created_on => nil)
+      post = Post[post.id]
 
-    should "use it as expected" do
-      item = Item.new(:foo => "bar")
-      assert_equal FooBar.new("bar"), item.foo
-    end
-  end
-
-  context "specifying a customer DataType but with a #dump method" do
-    class ::CSV < Array
-      def self.dump(arr)
-        arr.join(',')
-      end
-
-      def self.[](str)
-        new(str.split(','))
-      end
-
-      def to_s
-        join(',')
-      end
+      assert_nil post.created_on
     end
 
-    class Item < Ohm::Model
-      include Ohm::Typecast
-
-      attribute :csv, CSV
+    test "handles empty string case correctly" do
+      post = Post.create(:created_on => "")
+      post = Post[post.id]
+      
+      assert_equal "", post.created_on.to_s
     end
 
-
-    should "dump the appropriate value" do
-      item = Item.new(:csv => [ 'first', 'second', 'third'])
+    test "allows for real time operations" do
+      post = Post.create(:created_on => "2010-05-10")
+      post = Post[post.id]
       
-      assert_equal 'first,second,third', item.send(:read_local, :csv)
+      assert_respond_to post.created_on, :strftime
+      assert_equal "2010-05-10", post.created_on.strftime('%Y-%m-%d')
     end
 
-    should "be able to retrieve it back properly" do
-      item = Item.create(:csv => [ 'first', 'second', 'third'])
-      item = Item[item.id]
-
-      assert_equal ['first', 'second', 'third'], item.csv
+    test "raises when trying to do date operations on a non-date" do
+      post = Post.create(:created_on => "FooBar")
+      post = Post[post.id]
+      
+      assert_raise ArgumentError do
+        post.created_on.strftime("%Y")
+      end
     end
 
-    should "also be able to read/write with raw CSV" do
-      item = Item.create(:csv => CSV.new(['first', 'second', 'third']))
-      item = Item[item.id]
-
-      assert_equal ['first', 'second', 'third'], item.csv
+    test "still able to access Date" do
+      assert_equal Date.today, Post.new.today
     end
   end
 
-  context "defaut Strings" do
-    class Post < Ohm::Model
-      include Ohm::Typecast
-      
-      attribute :field1
-      attribute :field2
-      attribute :field3
-    end
 
-    should "not throw a validation missing exception during save" do
-      assert_nothing_raised Ohm::Typecast::MissingValidation do
-        Post.create :field1 => "field1", :field2 => "field2", :field3 => "fld3"
-      end
-    end
-  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - Cyril David
@@ -65,6 +65,18 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
 description: Highly decoupled drop-in functionality for Ohm models
 email: cyx.ucron@gmail.com
 executables: []