jmonteiro-mongo_mapper 0.1.0

data/lib/mongo_mapper/plugins/serialization.rb

@@ -0,0 +1,109 @@
+require 'active_support/json'
+
+module MongoMapper
+  module Plugins
+    module Serialization
+      class Serializer
+        attr_reader :options
+
+        def initialize(record, options={})
+          @record, @options = record, options.dup
+        end
+
+        def serializable_key_names
+          key_names = @record.attributes.keys
+
+          if options[:only]
+            options.delete(:except)
+            key_names = key_names & Array(options[:only]).collect { |n| n.to_s }
+          else
+            options[:except] = Array(options[:except])
+            key_names = key_names - options[:except].collect { |n| n.to_s }
+          end
+
+          key_names
+        end
+
+        def serializable_method_names
+          Array(options[:methods]).inject([]) do |method_attributes, name|
+            method_attributes << name if @record.respond_to?(name.to_s)
+            method_attributes
+          end
+        end
+
+        def serializable_names
+          serializable_key_names + serializable_method_names
+        end
+
+        def serializable_record
+          returning(serializable_record = {}) do
+            serializable_names.each { |name| serializable_record[name] = @record.send(name) }
+          end
+        end
+
+        def serialize
+          # overwrite to implement
+        end
+
+        def to_s(&block)
+          serialize(&block)
+        end
+      end
+      
+      module Json
+        def self.included(base)
+          base.cattr_accessor :include_root_in_json, :instance_writer => false
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def json_class_name
+            @json_class_name ||= name.demodulize.underscore.inspect
+          end
+        end
+
+        def to_json(options={})
+          apply_to_json_defaults(options)
+
+          if include_root_in_json
+            "{#{self.class.json_class_name}: #{JsonSerializer.new(self, options).to_s}}"
+          else
+            JsonSerializer.new(self, options).to_s
+          end
+        end
+
+        def from_json(json)
+          self.attributes = ActiveSupport::JSON.decode(json)
+          self
+        end
+
+        class JsonSerializer < Serializer
+          def serialize
+            serializable_record.to_json
+          end
+        end
+
+        private
+          def apply_to_json_defaults(options)
+            unless options[:only]
+              methods = [options.delete(:methods)].flatten.compact
+              methods << :id
+              options[:methods] = methods.uniq
+            end
+
+            except = [options.delete(:except)].flatten.compact
+            except << :_id
+            options[:except] = except
+          end
+      end
+      
+      module InstanceMethods
+        def self.included(model)
+          model.class_eval do
+            include Json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/validations.rb

@@ -0,0 +1,48 @@
+module MongoMapper
+  module Plugins
+    module Validations
+      module InstanceMethods
+        def self.included(model)
+          model.class_eval { include Validatable }
+        end
+      end
+      
+      module DocumentMacros
+        def validates_uniqueness_of(*args)
+          add_validations(args, MongoMapper::Plugins::Validations::ValidatesUniquenessOf)
+        end
+      end
+      
+      class ValidatesUniquenessOf < Validatable::ValidationBase
+        option :scope, :case_sensitive
+        default :case_sensitive => true
+
+        def valid?(instance)
+          value = instance[attribute]
+          return true if allow_blank && value.blank?
+          return true if allow_nil && value.nil?
+          base_conditions = case_sensitive ? {self.attribute => value} : {}
+          doc = instance.class.first(base_conditions.merge(scope_conditions(instance)).merge(where_conditions(instance)))
+          doc.nil? || instance._id == doc._id
+        end
+
+        def message(instance)
+          super || "has already been taken"
+        end
+
+        def scope_conditions(instance)
+          return {} unless scope
+          Array(scope).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+
+        def where_conditions(instance)
+          conditions = {}
+          conditions[attribute] = /#{instance[attribute].to_s}/i unless case_sensitive
+          conditions
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/support.rb

@@ -0,0 +1,213 @@
+class Array
+  def self.to_mongo(value)
+    value = value.respond_to?(:lines) ? value.lines : value
+    value.to_a
+  end
+  
+  def self.from_mongo(value)
+    value || []
+  end
+end
+
+class Binary
+  def self.to_mongo(value)
+    if value.is_a?(ByteBuffer)
+      value
+    else
+      value.nil? ? nil : ByteBuffer.new(value)
+    end
+  end
+
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class Boolean
+  BOOLEAN_MAPPING = {
+    true => true, 'true' => true, 'TRUE' => true, 'True' => true, 't' => true, 'T' => true, '1' => true, 1 => true, 1.0 => true,
+    false => false, 'false' => false, 'FALSE' => false, 'False' => false, 'f' => false, 'F' => false, '0' => false, 0 => false, 0.0 => false, nil => false
+  }
+  
+  def self.to_mongo(value)
+    if value.is_a?(Boolean)
+      value
+    else
+      v = BOOLEAN_MAPPING[value]
+      v = value.to_s.downcase == 'true' if v.nil? # Check all mixed case spellings for true
+      v
+    end
+  end
+
+  def self.from_mongo(value)
+    !!value
+  end
+end
+
+class Date
+  def self.to_mongo(value)
+    if value.nil? || value == ''
+      nil
+    else
+      date = value.is_a?(Date) || value.is_a?(Time) ? value : Date.parse(value.to_s)
+      Time.utc(date.year, date.month, date.day)
+    end
+  rescue
+    nil
+  end
+  
+  def self.from_mongo(value)
+    value.to_date if value.present?
+  end
+end
+
+class Float
+  def self.to_mongo(value)
+    value.to_f
+  end
+end
+
+class Hash
+  def self.from_mongo(value)
+    HashWithIndifferentAccess.new(value || {})
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+class Integer
+  def self.to_mongo(value)
+    value_to_i = value.to_i
+    if value_to_i == 0 && value != value_to_i
+      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
+    else
+      value_to_i
+    end
+  end
+end
+
+class NilClass
+  def to_mongo(value)
+    value
+  end
+  
+  def from_mongo(value)
+    value
+  end
+end
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self; self end
+  end
+
+  def meta_eval(&blk)
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end
+  
+  def self.to_mongo(value)
+    value
+  end
+  
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class ObjectId
+  def self.to_mongo(value)
+    if value.blank?
+      nil
+    elsif value.is_a?(Mongo::ObjectID)
+      value
+    else
+      Mongo::ObjectID.from_string(value.to_s)
+    end
+  end
+  
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class Set
+  def self.to_mongo(value)
+    value.to_a
+  end
+  
+  def self.from_mongo(value)
+    Set.new(value || [])
+  end
+end
+
+class String
+  def self.to_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+  
+  def self.from_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+end
+
+class SymbolOperator
+  def initialize(field, operator, options={})
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+  
+  def to_mm_criteria(value)
+    {MongoMapper::FinderOptions.normalized_field(@field) => {"$#{@operator}" => value}}
+  end
+  
+  def to_mm_order
+    [@field.to_s, MongoMapper::FinderOptions.normalized_order_direction(@operator)]
+  end
+end
+
+class Symbol
+  %w(gt lt gte lte ne in nin mod size where exists asc desc).each do |operator|
+    define_method(operator) do
+      SymbolOperator.new(self, operator)
+    end unless method_defined?(operator)
+  end
+end
+
+class Time
+  def self.to_mongo(value)
+    if value.nil? || value == ''
+      nil
+    else
+      time = value.is_a?(Time) ? value : MongoMapper.time_class.parse(value.to_s)
+      # Convert time to milliseconds since BSON stores dates with that accurracy, but Ruby uses microseconds
+      Time.at((time.to_f * 1000).round / 1000.0).utc if time
+    end
+  end
+  
+  def self.from_mongo(value)
+    if MongoMapper.use_time_zone? && value.present?
+      value.in_time_zone(Time.zone)
+    else
+      value
+    end
+  end
+end
+
+# TODO: Remove when patch accepted into driver
+class Mongo::ObjectID
+  def to_json(options = nil)
+    %Q("#{to_s}")
+  end
+end

data/performance/read_write.rb

@@ -0,0 +1,52 @@
+# The purpose of this is to check finding, initializing, 
+# and creating objects (typecasting times/dates and booleans).
+
+require 'pp'
+require 'benchmark'
+require 'rubygems'
+
+# to test with slow version just do this:
+# gem 'mongo_mapper', '0.6.10'
+# and comment out this:
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mongo_mapper'
+
+MongoMapper.database = 'testing'
+ 
+class Foo
+  include MongoMapper::Document
+  key :approved, Boolean
+  key :count, Integer
+  key :approved_at, Time
+  key :expire_on, Date
+  timestamps!
+end
+Foo.collection.remove
+
+Benchmark.bm(5) do |x|
+  ids = []
+  x.report("write") do
+    1000.times { |i| ids << Foo.create(:count => 0, :approved => true, :approved_at => Time.now, :expire_on => Date.today).id }
+  end
+
+  x.report("read ") do
+    ids.each { |id| Foo.first(:id => id) }
+  end
+end
+
+# I was get something like this on my puny macbook air:
+#            user     system      total        real
+# write  4.810000   0.090000   4.900000 (  5.039949)
+# read   2.730000   0.070000   2.800000 (  2.990749)
+#
+#
+# After these commits:
+#
+#   * http://github.com/jnunemaker/mongomapper/commit/e5091fa140d5fae2721017b53027092233694ee5
+#   * http://github.com/jnunemaker/mongomapper/commit/c22bbde4fa1cfbc310d79cb0e50203310ffb03d1
+#
+# I'm now getting something like this:
+#            user     system      total        real
+# write  1.660000   0.050000   1.710000 (  1.752676)
+# read   1.060000   0.050000   1.110000 (  1.263429)

data/specs.watchr

@@ -0,0 +1,51 @@
+def growl(title, msg, img)
+  %x{growlnotify -m #{ msg.inspect} -t #{title.inspect} --image ~/.watchr/#{img}.png}
+end
+
+def form_growl_message(str)
+  results = str.split("\n").last
+  if results =~ /[1-9]\s(failure|error)s?/
+    growl "Test Results", "#{results}", "fail"
+  elsif results != ""
+    growl "Test Results", "#{results}", "pass"
+  end
+end
+
+def run(cmd)
+  puts(cmd)
+  output = ""
+  IO.popen(cmd) do |com|
+    com.each_char do |c|
+      print c
+      output << c
+      $stdout.flush
+    end
+  end
+  form_growl_message output
+end
+
+def run_test_file(file)
+  run %Q(ruby -I"lib:test" -rubygems #{file})
+end
+
+def run_all_tests
+  run "rake test"
+end
+
+def related_test_files(path)
+  Dir['test/**/*.rb'].select { |file| file =~ /test_#{File.basename(path)}/ }
+end
+
+watch('test/test_helper\.rb') { system('clear'); run_all_tests }
+watch('test/.*/test_.*\.rb') { |m| system('clear'); run_test_file(m[0]) }
+watch('lib/.*') { |m| related_test_files(m[0]).each { |file| run_test_file(file) } }
+
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }
+