ohm-contrib 0.0.19 → 0.0.20

data/VERSION

@@ -1 +1 @@
-0.0.19
+0.0.20

data/lib/ohm/contrib/typecast.rb

@@ -1,6 +1,8 @@
 require 'bigdecimal'
 require 'time'
 require 'date'
+require 'json'
+require 'forwardable'
 
 module Ohm
   # Provides all the primitive types. The following are included:
@@ -11,6 +13,8 @@ module Ohm
   # * Float
   # * Date
   # * Time
+  # * Hash
+  # * Array
   module Types
     def self.defined?(type)
       @constants ||= constants.map(&:to_s)
@@ -20,8 +24,35 @@ module Ohm
     def self.[](type)
       const_get(type.to_s.split('::').last)
     end
+  
+    class Base < BasicObject
+      class Exception < ::Exception; end
 
-    class Primitive < BasicObject
+      extend ::Forwardable
+
+      @@delegation_blacklist = [
+        :==, :to_s, :initialize, :inspect, :object_id, :__send__, :__id__
+      ]
+
+      def self.[](value)
+        return self::EMPTY if value.to_s.empty?
+    
+        new(value)
+      end
+
+      def self.delegate_to(klass, except = @@delegation_blacklist)
+        methods = klass.public_instance_methods.map(&:to_sym) - except
+        def_delegators :object, *methods          
+      end
+
+      def inspect
+        object.inspect
+      end
+    end
+
+    class Primitive < Base
+      EMPTY = nil
+      
       def initialize(value)
         @raw = value
       end
@@ -30,28 +61,23 @@ module Ohm
         @raw.to_s
       end
 
-      def inspect
-        object
-      end
-
       def ==(other)
         to_s == other.to_s
       end
-
+     
     protected
       def object
         @raw
       end
-
-      def method_missing(meth, *args, &blk)
-        object.send(meth, *args, &blk)
-      end
     end
 
     class String < Primitive
+      delegate_to ::String
     end
 
     class Decimal < Primitive
+      delegate_to ::BigDecimal
+
       def inspect
         object.to_s('F')
       end
@@ -63,6 +89,8 @@ module Ohm
     end
 
     class Integer < Primitive
+      delegate_to ::Fixnum
+
     protected
       def object
         ::Kernel::Integer(@raw)
@@ -70,6 +98,8 @@ module Ohm
     end
 
     class Float < Primitive
+      delegate_to ::Float
+
     protected
       def object
         ::Kernel::Float(@raw)
@@ -77,6 +107,8 @@ module Ohm
     end
 
     class Time < Primitive
+      delegate_to ::Time
+
     protected
       def object
         ::Time.parse(@raw)
@@ -84,11 +116,62 @@ module Ohm
     end
 
     class Date < Primitive
+      delegate_to ::Date
+
     protected
       def object
         ::Date.parse(@raw)
       end
     end
+    
+    class Serialized < Base
+      attr :object
+
+      def initialize(raw)
+        @object = case raw
+        when self.class::RAW then raw
+        when ::String        then ::JSON.parse(raw)
+        when self.class      then raw.object
+        else
+          ::Kernel.raise ::TypeError, 
+            "%s does not accept %s" % [self.class, raw.inspect]
+        end
+      end
+
+      def ==(other)
+        object == other        
+      end
+     
+      def to_s
+        object.to_json
+      end
+    end
+
+    class Hash < Serialized
+      EMPTY = {}
+      RAW   = ::Hash
+
+      delegate_to ::Hash
+
+      # @private since basic object doesn't include a #class we need
+      # to define this manually
+      def class
+        ::Ohm::Types::Hash
+      end
+    end
+
+    class Array < Serialized
+      EMPTY = []
+      RAW   = ::Array
+      
+      delegate_to ::Array
+      
+      # @private since basic object doesn't include a #class we need
+      # to define this manually
+      def class
+        ::Ohm::Types::Array
+      end
+    end
   end
 
   # Provides unobtrusive, non-explosive typecasting.Instead of exploding on set
@@ -184,12 +267,20 @@ module Ohm
       # @return [nil] if the attribute is already defined.
       def attribute(name, type = Ohm::Types::String, klass = Ohm::Types[type])
         define_method(name) do
-          value = read_local(name)
-          value && klass.new(value)
+          # Primitive types maintain a reference to the original object
+          # stored in @_attributes[att]. Hence mutation works for the
+          # Primitive case. For cases like Hash, Array where the value 
+          # is `JSON.parse`d, we need to set the actual Ohm::Types::Hash 
+          # (or similar) to @_attributes[att] for mutation to work.
+          if klass.superclass == Ohm::Types::Primitive
+            klass[read_local(name)]
+          else
+            write_local(name, klass[read_local(name)])
+          end
         end
 
         define_method(:"#{name}=") do |value|
-          write_local(name, value && value.to_s)
+          write_local(name, klass[value].to_s)
         end
 
         attributes << name unless attributes.include?(name)

data/lib/ohm/contrib/web_validations.rb

@@ -1,35 +1,51 @@
 module Ohm
   # All credit goes to gnrfan of github
   # Basically an extraction from http://github.com/gnrfan/ohm_extra_validations
+  #
+  # * 2010-05-29 Updated Email Regex, Extracted out regexs to constants
+  #
+  # This module provides the following:
+  # * assert_slug
+  # * assert_email
+  # * assert_url
+  # * assert_ipv4
   module WebValidations
+    # @see http://fightingforalostcause.net/misc/2006/compare-email-regex.php
+    EMAIL_REGEX = /^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i
+  
+    SLUG_REGEX  = /^[-\w]+$/
+   
+    URL_REGEX   = /^(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}|localhost)(:[0-9]{1,5})?(\/.*)?$/ix
+
+    IPV4_REGEX  = /^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$/
 
   protected
     def assert_slug(att, error = [att, :not_slug])
       if assert_present(att, error) and assert_unique(att)
-          assert_format(att, /^[-\w]+$/, error)
+        assert_format(att, SLUG_REGEX, error)
       end
     end
 
     def assert_email(att, error = [att, :not_email])
       if assert_present(att, error)
-        assert_format(att, /^([^@\s*]+)@((?:[-a-z0-9]+\.)+[a-z]{2,6})$/i, error)
+        assert_format(att, EMAIL_REGEX, error)
       end
     end
 
     def assert_url(att, error = [att, :not_url])
       if assert_present(att, error)
-        assert_format(att, /^(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}|localhost)(:[0-9]{1,5})?(\/.*)?$/ix, error)
+        assert_format(att, URL_REGEX, error)
       end
     end
 
     def assert_ipv4(att, error = [att, :not_ipv4])
       if assert_present(att, error)
-        assert_format(att, /^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$/, error)
+        assert_format(att, IPV4_REGEX, error)
       end
     end
 
     def assert_ipaddr(att, error = [att, :not_ipaddr])
-        assert_ipv4(att, error)
+      assert_ipv4(att, error)
     end
   end
-end
+end

data/lib/ohm/contrib.rb

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

data/ohm-contrib.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ohm-contrib}
-  s.version = "0.0.19"
+  s.version = "0.0.20"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Cyril David"]
-  s.date = %q{2010-05-28}
+  s.date = %q{2010-05-29}
   s.description = %q{Highly decoupled drop-in functionality for Ohm models}
   s.email = %q{cyx.ucron@gmail.com}
   s.extra_rdoc_files = [

data/test/test_ohm_typecast.rb

@@ -145,7 +145,7 @@ class TestOhmTypecast < Test::Unit::TestCase
 
     test "inspecting" do
       post = Post.new(:price => "50000")
-      assert_equal 50000, post.price.inspect
+      assert_equal '50000', post.price.inspect
     end
   end
 
@@ -191,7 +191,7 @@ class TestOhmTypecast < Test::Unit::TestCase
 
     test "inspecting" do
       post = Post.new(:price => "12345.67890")
-      assert_equal 12345.67890, post.price.inspect
+      assert_equal '12345.6789', post.price.inspect
     end
   end
 
@@ -318,4 +318,231 @@ class TestOhmTypecast < Test::Unit::TestCase
       assert_equal Date.today, Post.new.today
     end
   end
+
+  context "when using a Hash" do
+    class Post < Ohm::Model
+      include Ohm::Typecast
+
+      attribute :address, Hash
+
+      def hash
+        Hash.new
+      end
+
+      def top_level_hash
+        Hash
+      end
+    end
+    
+    test "importing" do
+      assert_equal Hash.new, Ohm::Types::Hash[nil]
+      assert_equal Hash.new, Ohm::Types::Hash[""]
+      assert_equal Hash.new, Ohm::Types::Hash[{}]
+
+      assert_equal Hash[:a => "b", :c => "d"], 
+        Ohm::Types::Hash[{ :a => "b", :c => "d" }]
+    end
+
+    test "exporting / dumping" do
+      assert_equal "{}", Ohm::Types::Hash[nil].to_s
+      assert_equal "{}", Ohm::Types::Hash[""].to_s
+      assert_equal "{}", Ohm::Types::Hash[{}].to_s
+
+      assert_equal %q{{"a":"b","c":"d"}},
+        Ohm::Types::Hash[{ :a => "b", :c => "d" }].to_s
+    end
+
+    test "still able to get top level methods" do
+      assert_equal({}, Post.new.hash)
+      assert_equal Hash, Post.new.top_level_hash
+    end
+
+    test "handles nil case correctly" do
+      post = Post.create(:address => nil)
+      assert_equal({}, post.address)
+      
+      post = Post[post.id]
+      assert_equal({}, post.address)
+    end
+
+    test "handles empty string case correctly" do
+      post = Post.create(:address => "")
+      assert_equal({}, post.address)
+      
+      post = Post[post.id]
+      assert_equal({}, post.address)
+    end
+
+    test "handles populated hashes" do
+      address = { "address1" => "#123", "city" => "Singapore", "country" => "SG"}
+      post = Post.create(:address => address)
+      assert_equal address, post.address
+      
+      post = Post[post.id]
+      assert_equal address, post.address
+    end
+
+    test "allows for hash operations" do
+      address = { "address1" => "#123", "city" => "Singapore", "country" => "SG"}
+      post = Post.create(:address => address)
+      
+      assert_equal ["address1", "city", "country"], post.address.keys
+      assert_equal ["#123", "Singapore", "SG"], post.address.values
+
+      post = Post[post.id]
+      assert_equal ["address1", "city", "country"], post.address.keys
+      assert_equal ["#123", "Singapore", "SG"], post.address.values
+    end
+
+    test "handles mutation" do
+      address = { "address1" => "#123", "city" => "Singapore", "country" => "SG"}
+      post = Post.create(:address => address)
+      
+      post.address["address1"] = "#456"
+      post.save
+
+      assert_equal ["address1", "city", "country"], post.address.keys
+      assert_equal ["#456", "Singapore", "SG"], post.address.values
+
+      post = Post[post.id]
+      assert_equal ["address1", "city", "country"], post.address.keys
+      assert_equal ["#456", "Singapore", "SG"], post.address.values
+    end
+  
+    Address = Class.new(Struct.new(:city, :country))
+
+    test "raises when trying to assign a non-hash" do
+      assert_raise TypeError do
+        Post.new(:address => [])
+      end
+
+      assert_raise TypeError do
+        Post.new(:address => Address.new)
+      end
+    end
+  end
+
+  context "when using an Array" do
+    class Post < Ohm::Model
+      include Ohm::Typecast
+
+      attribute :addresses, Array
+
+      def array
+        Array.new
+      end
+
+      def top_level_array
+        Array
+      end
+    end
+    
+    test "importing" do
+      assert_equal [], Ohm::Types::Array[nil]
+      assert_equal [], Ohm::Types::Array[""]
+      assert_equal [], Ohm::Types::Array[[]]
+
+      assert_equal ['a', 'b', 'c', 'd'],
+        Ohm::Types::Array[['a', 'b', 'c', 'd']]
+    end
+
+    test "exporting / dumping" do
+      assert_equal "[]", Ohm::Types::Array[nil].to_s
+      assert_equal "[]", Ohm::Types::Array[""].to_s
+      assert_equal "[]", Ohm::Types::Array[[]].to_s
+
+      assert_equal %q{["a","b","c","d"]},
+        Ohm::Types::Array[['a', 'b', 'c', 'd']].to_s
+    end
+
+    test "still able to get top level methods" do
+      assert_equal([], Post.new.array)
+      assert_equal Array, Post.new.top_level_array
+    end
+
+    test "handles nil case correctly" do
+      post = Post.create(:addresses => nil)
+      assert_equal([], post.addresses)
+      
+      post = Post[post.id]
+      assert_equal([], post.addresses)
+    end
+
+    test "handles empty string case correctly" do
+      post = Post.create(:addresses => "")
+      assert_equal([], post.addresses)
+      
+      post = Post[post.id]
+      assert_equal([], post.addresses)
+    end
+
+    test "handles populated arrays" do
+      addresses = [{"city" => "Singapore", "country" => "SG"},
+                   {"city" => "Manila", "country" => "PH"}]
+
+      post = Post.create(:addresses => addresses)
+      assert_equal addresses, post.addresses
+      
+      post = Post[post.id]
+      assert_equal addresses, post.addresses
+    end
+    
+    class Address < Struct.new(:city, :country)
+      def to_json
+        [city, country].to_json
+      end
+    end
+
+    test "handles an arbitrary class as an element of the array" do
+      addresses = [Address.new("Singapore", "SG"),
+                   Address.new("Philippines", "PH")]
+  
+      post = Post.create(:addresses => addresses)
+      assert_equal [['Singapore', 'SG'], ['Philippines', 'PH']], post.addresses
+      
+      post = Post[post.id]
+      assert_equal [['Singapore', 'SG'], ['Philippines', 'PH']], post.addresses
+    end
+
+    test "allows for array operations" do
+      addresses = [{"city" => "Singapore", "country" => "SG"},
+                   {"city" => "Manila", "country" => "PH"}]
+
+
+      post = Post.create(:addresses => addresses)
+      assert_equal 2, post.addresses.size
+      assert_equal addresses + [{"city" => "Hong Kong", "country" => "ZN"}],
+        post.addresses.push({"city" => "Hong Kong", "country" => "ZN"})
+
+      post = Post[post.id]
+      assert_equal 2, post.addresses.size
+      assert_equal addresses + [{"city" => "Hong Kong", "country" => "ZN"}],
+        post.addresses.push({"city" => "Hong Kong", "country" => "ZN"})
+    end
+
+    test "handles mutation" do
+      post = Post.create(:addresses => [1, 2, 3])
+      
+      post.addresses.push(4, 5, 6)
+      post.save
+
+      assert_equal 6, post.addresses.size
+      assert_equal [1, 2, 3, 4, 5, 6], post.addresses
+
+      post = Post[post.id]
+      assert_equal 6, post.addresses.size
+      assert_equal [1, 2, 3, 4, 5, 6], post.addresses
+    end
+  
+
+    test "raises when trying to assign a non-array" do
+      assert_raise TypeError do
+        Post.new(:addresses => {})
+      end
+
+      assert_raise TypeError do
+        Post.new(:addresses => Address.new)
+      end
+    end
+  end
 end

data/test/test_ohm_web_validations.rb

@@ -29,6 +29,7 @@ class TestOhmWebValidations < Test::Unit::TestCase
 
   context "The slug should be valid" do
     def setup
+      Ohm.flush
       @blog_post_01 = BlogPost.new
       @blog_post_02 = BlogPost.new
     end
@@ -41,11 +42,11 @@ class TestOhmWebValidations < Test::Unit::TestCase
       assert_equal [[:slug, :not_slug]], @blog_post_01.errors
     end
 
-    #should "succeed if the slug is valid" do
-    #  @blog_post_02.slug = "this-is-a-valid-slug"
-    #  @blog_post_02.create
-    #  assert_not_nil @blog_post_02.id
-    #end
+    should "succeed if the slug is valid" do
+      @blog_post_02.slug = "this-is-a-valid-slug"
+      @blog_post_02.create
+      assert_not_nil @blog_post_02.id
+    end
 
     should "fail if the slug is not unique" do
 
@@ -110,4 +111,4 @@ class TestOhmWebValidations < Test::Unit::TestCase
     end
 
   end
-end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 19
-  version: 0.0.19
+  - 20
+  version: 0.0.20
 platform: ruby
 authors: 
 - Cyril David
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-28 00:00:00 +08:00
+date: 2010-05-29 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency