mongomatic 0.6.3 → 0.6.4

data/lib/mongomatic/base.rb

@@ -3,6 +3,7 @@ module Mongomatic
     include Mongomatic::Modifiers
     include Mongomatic::Util
     include Mongomatic::ActiveModelCompliancy
+    include Mongomatic::TypedFields
     
     class << self
       # Returns this models own db attribute if set, otherwise will return Mongomatic.db
@@ -108,6 +109,7 @@ module Mongomatic
     end
     
     def valid?
+      check_typed_fields!
       self.errors = Mongomatic::Errors.new
       do_callback(:before_validate)
       validate
@@ -136,6 +138,11 @@ module Mongomatic
       hash.has_key?(field)
     end
     
+    def set_value_for_key(key, value)
+      field, hash = hash_for_field(key.to_s)
+      hash[field] = value
+    end
+    
     def value_for_key(key)
       field, hash = hash_for_field(key.to_s, true)
       hash[field]

data/lib/mongomatic/m_hash.rb

@@ -1,4 +1,151 @@
+require 'active_support/core_ext/hash/keys'
+
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
 module Mongomatic
-  class MHash < HashWithIndifferentAccess
+  class MHash < Hash
+    def extractable_options?
+      true
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      Mongomatic::MHash.new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = MHash.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = MHash.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = MHash.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = MHash.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = MHash.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      MHash.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    undef :symbolize_keys!
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          self.class.new_from_hash_copying_default(value)
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
+        else
+          value
+        end
+      end
   end
-end
+end
+
+MHash = Mongomatic::MHash

data/lib/mongomatic/modifiers.rb

@@ -150,7 +150,7 @@ module Mongomatic
     #  user.set("name", "Ben")
     def set(field, val, update_opts={}, safe=false)
       mongo_field = field.to_s
-      field, hash = hash_for_field(field.to_s)
+      #field, hash = hash_for_field(field.to_s)
       
       op  = { "$set" => { mongo_field => val } }
       res = true
@@ -158,7 +158,8 @@ module Mongomatic
       safe == true ? res = update!(update_opts, op) : update(update_opts, op)
       
       if res
-        hash[field] = val
+        set_value_for_key(field.to_s, val)
+        #hash[field] = val
         true
       end
     end

data/lib/mongomatic/type_converters.rb

@@ -0,0 +1,146 @@
+module Mongomatic
+  module TypeConverters
+    class CannotCastValue < RuntimeError; end
+    
+    def self.for_type(type)
+      eval "Mongomatic::TypeConverters::#{type.to_s.camelize}"
+    end
+    
+    class Base
+      def initialize(orig_val)
+        @orig_val = orig_val
+      end
+      
+      def type_match?
+        raise "abstract"
+      end
+      
+      def cast
+        if type_match?
+          @orig_val
+        else
+          convert_orig_val || raise(CannotCastValue)
+        end
+      end
+      
+      def convert_orig_val
+        raise "abstract"
+      end
+    end
+    
+    class String < Base
+      def type_match?
+        @orig_val.class.to_s == "String"
+      end
+      
+      def convert_orig_val
+        @orig_val.respond_to?(:to_s) ? @orig_val.to_s : nil
+      end
+    end
+    
+    class Float < Base
+      def type_match?
+        @orig_val.class.to_s == "Float"
+      end
+      
+      def convert_orig_val
+        @orig_val.respond_to?(:to_f) ? @orig_val.to_f : nil
+      end
+    end
+    
+    class Fixnum < Base
+      def type_match?
+        @orig_val.class.to_s == "Fixnum"
+      end
+      
+      def convert_orig_val
+        @orig_val.respond_to?(:to_i) ? @orig_val.to_i : nil
+      end
+    end
+    
+    class Array < Base
+      def type_match?
+        @orig_val.class.to_s == "Array"
+      end
+      
+      def convert_orig_val
+        @orig_val.respond_to?(:to_a) ? @orig_val.to_a : nil
+      end
+    end
+
+    class Hash < Base
+      def type_match?
+        @orig_val.class.to_s == "Hash"
+      end
+      
+      def convert_orig_val
+        [:to_h, :to_hash].each do |meth|
+          res = (@orig_val.respond_to?(meth) ? @orig_val.send(meth) : nil)
+          return res if !res.nil?
+        end; nil
+      end
+    end
+
+    class Bool < Base
+      def type_match?
+        @orig_val == true || @orig_val == false
+      end
+      
+      def convert_orig_val
+        s_val = @orig_val.to_s.downcase
+        if %w(1 t true y yes).include?(s_val)
+          true
+        elsif %w(0 f false n no).include?(s_val)
+          false
+        else
+          nil
+        end
+      end
+    end
+        
+    class Time < Base
+      def type_match?
+        @orig_val.class.to_s == "Time"
+      end
+
+      def convert_orig_val
+        Time.parse(@orig_val.to_s)
+      rescue ArgumentError => e
+        nil
+      end
+    end
+    
+    class Regex < Base
+      def type_match?
+        @orig_val.class.to_s == "Regexp"
+      end
+      
+      def convert_orig_val
+        Regexp.new(@orig_val.to_s)
+      end
+    end
+    
+    class Symbol < Base
+      def type_match?
+        @orig_val.class.to_s == "Symbol"
+      end
+      
+      def convert_orig_val
+        @orig_val.respond_to?(:to_sym) ? @orig_val.to_sym : nil
+      end
+    end
+    
+    class ObjectId < Base
+      def type_match?
+        @orig_val.class.to_s == "BSON::ObjectId"
+      end
+      
+      def convert_orig_val
+        BSON::ObjectId(@orig_val.to_s)
+      rescue BSON::InvalidObjectId => e
+        nil
+      end
+    end
+    
+  end
+end

data/lib/mongomatic/typed_fields.rb

@@ -0,0 +1,58 @@
+module Mongomatic
+  # = Typed Fields
+  # Explicitly specify the field types in your document. This is completely optional.
+  # You can also set whether or not we should try to automatically cast a type to the
+  # desired type.
+  # = Examples
+  #   typed_field "age",                :type => :fixnum,  :cast => true
+  #   typed_field "manufacturer.name",  :type => :string,  :cast => false
+  module TypedFields
+    class InvalidType < RuntimeError; end
+    
+    KNOWN_TYPES = [:string, :float, :fixnum, :array, :hash, :bool,
+                   :time, :regex, :symbol, :object_id]
+    
+    def self.included(base)
+      base.send(:extend,  ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      def typed_field(name, opts)
+        unless Mongomatic::TypedFields::KNOWN_TYPES.include?(opts[:type])
+          raise Mongomatic::TypedFields::Invalidtype, "#{opts[:type]}"
+        end
+        
+        opts = {:cast => true}.merge(opts)
+
+        @typed_fields ||= {}
+        @typed_fields[name] = opts
+      end
+      
+      def typed_fields
+        @typed_fields || {}
+      end
+    end # ClassMethods
+    
+    module InstanceMethods
+
+      def check_typed_fields!
+        self.class.typed_fields.each do |name, opts|
+          cast_or_raise_typed_field(name, opts)
+        end
+      end
+      
+      def cast_or_raise_typed_field(name, opts)
+        val      = value_for_key(name.to_s); return if val.nil?
+        type     = opts[:type].to_sym
+        try_cast = opts[:cast]
+        
+        converter = Mongomatic::TypeConverters.for_type(type).new(val)
+        return true if converter.type_match?
+        raise(InvalidType, "#{name} should be a :#{type}") unless try_cast
+        set_value_for_key(name, converter.cast)
+      end
+      
+    end # InstanceMethods
+  end # TypedFields
+end # Mongomatic

data/lib/mongomatic.rb

@@ -37,4 +37,6 @@ require "#{File.dirname(__FILE__)}/mongomatic/modifiers"
 require "#{File.dirname(__FILE__)}/mongomatic/errors"
 require "#{File.dirname(__FILE__)}/mongomatic/expectations"
 require "#{File.dirname(__FILE__)}/mongomatic/active_model_compliancy"
+require "#{File.dirname(__FILE__)}/mongomatic/type_converters"
+require "#{File.dirname(__FILE__)}/mongomatic/typed_fields"
 require "#{File.dirname(__FILE__)}/mongomatic/base"

data/test/helper.rb

@@ -2,9 +2,10 @@ require 'rubygems'
 gem 'minitest', "~> 2.0"
 require 'pp'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'mongomatic'
+# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# $LOAD_PATH.unshift(File.dirname(__FILE__))
+require "#{File.dirname(__FILE__)}/../lib/mongomatic"
+#require 'mongomatic'
 
 Mongomatic.db = Mongo::Connection.new.db("mongomatic_test")
 
@@ -103,3 +104,15 @@ class Foobar < Mongomatic::Base
     errors << "missing style" if self["style"].blank?
   end
 end
+
+class Rig < Mongomatic::Base
+  # :cast => true, :raise => false is the default
+  typed_field "age",                :type => :fixnum,  :cast => true
+  typed_field "manufacturer.name",  :type => :string,  :cast => true
+  typed_field "manufacturer.phone", :type => :string,  :cast => false
+  typed_field "waist_measurement",  :type => :float,   :cast => true
+  typed_field "friends_rig_id",     :type => :object_id, :cast => true
+end
+
+
+

data/test/test_typed_fields.rb

@@ -0,0 +1,53 @@
+require 'helper'
+require 'minitest/autorun'
+
+class TestTypedFields < MiniTest::Unit::TestCase
+  def setup
+    Rig.collection.drop
+  end
+
+  def test_raising_error_on_invalid_type
+    r = Rig.new
+    assert r["manufacturer"].blank?
+    r["manufacturer"] = { "phone" => 123 }
+    assert_raises(Mongomatic::TypedFields::InvalidType) { r.valid? }
+    r["manufacturer"] = {}
+    r["manufacturer"]["phone"] = "(800) 123 456 789"
+    assert_equal true, r.valid?
+    assert_equal "(800) 123 456 789", r["manufacturer"]["phone"]
+  end
+  
+  def test_cast_string
+    r = Rig.new
+    r["manufacturer"] = {}
+    r["manufacturer"]["name"] = ["Wings","Parachuting","Company"]
+    assert_equal ["Wings","Parachuting","Company"], r["manufacturer"]["name"]
+    assert r.valid?
+    assert_equal ["Wings","Parachuting","Company"].to_s, r["manufacturer"]["name"]
+  end
+  
+  def test_cast_number
+    r = Rig.new
+    r["age"] = "4"
+    assert_equal "4", r["age"]
+    assert r.valid?
+    assert_equal 4, r["age"]
+  end
+  
+  def test_cast_float
+    r = Rig.new
+    r["waist_measurement"] = "34.3"
+    assert_equal "34.3", r["waist_measurement"]
+    assert r.valid?
+    assert_equal 34.3, r["waist_measurement"]
+  end
+  
+  def test_cast_object_id
+    r = Rig.new
+    assert r.insert
+    r2 = Rig.new
+    r2["friends_rig_id"] = r["_id"].to_s
+    r2.insert
+    assert_equal "BSON::ObjectId", r2["friends_rig_id"].class.to_s
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 6
-  - 3
-  version: 0.6.3
+  - 4
+  version: 0.6.4
 platform: ruby
 authors: 
 - Ben Myles
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-12 00:00:00 -06:00
+date: 2010-11-16 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -99,6 +99,8 @@ files:
 - lib/mongomatic/expectations/present.rb
 - lib/mongomatic/m_hash.rb
 - lib/mongomatic/modifiers.rb
+- lib/mongomatic/type_converters.rb
+- lib/mongomatic/typed_fields.rb
 - lib/mongomatic/util.rb
 - LICENSE
 - README.rdoc
@@ -108,6 +110,7 @@ files:
 - test/test_misc.rb
 - test/test_modifiers.rb
 - test/test_persistence.rb
+- test/test_typed_fields.rb
 - test/test_validations.rb
 has_rdoc: true
 homepage: http://mongomatic.com/
@@ -148,4 +151,5 @@ test_files:
 - test/test_misc.rb
 - test/test_modifiers.rb
 - test/test_persistence.rb
+- test/test_typed_fields.rb
 - test/test_validations.rb