jnunemaker-mongomapper 0.1.0

data/lib/mongomapper/key.rb

@@ -0,0 +1,81 @@
+class Boolean; end
+
+module MongoMapper
+  class Key
+    # DateTime and Date are currently not supported by mongo's bson so just use Time
+    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash]
+    
+    attr_accessor :name, :type, :options, :default_value
+    
+    def initialize(name, type, options={})
+      @name, @type = name.to_s, type
+      self.options = options.symbolize_keys
+      self.default_value = options.delete(:default)
+    end
+    
+    def ==(other)
+      @name == other.name && @type == other.type
+    end
+    
+    def set(value)
+      typecast(value)
+    end
+    
+    def native?
+      @native ||= NativeTypes.include?(type)
+    end
+    
+    def embedded_document?
+      type.ancestors.include?(EmbeddedDocument) && !type.ancestors.include?(Document)
+    end
+    
+    def get(value)
+      return default_value if value.nil? && !default_value.nil?
+      if type == Array
+        value || []
+      elsif type == Hash
+        HashWithIndifferentAccess.new(value || {})
+      else
+        value
+      end
+    end
+    
+    private
+      def typecast(value)
+        return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
+        return value if value.kind_of?(type) || value.nil?
+        begin
+          if    type == String    then value.to_s
+          elsif type == Float     then value.to_f
+          elsif type == Array     then value.to_a
+          elsif type == Time      then Time.parse(value.to_s)
+          #elsif type == Date      then Date.parse(value.to_s)
+          elsif type == Boolean   then ['true', 't', '1'].include?(value.to_s.downcase)
+          elsif type == Integer
+            # ganked from datamapper
+            value_to_i = value.to_i
+            if value_to_i == 0 && value != '0'
+              value_to_s = value.to_s
+              begin
+                Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value_to_i
+            end
+          elsif embedded_document?
+            typecast_embedded_document(value)
+          else
+            value
+          end
+        rescue
+          value
+        end
+      end
+      
+      def typecast_embedded_document(value)
+        value.is_a?(type) ? value : type.new(value)
+      end
+  end
+end

data/lib/mongomapper/rails_compatibility.rb

@@ -0,0 +1,20 @@
+module MongoMapper
+  module RailsCompatibility
+    def self.included(model)
+      model.class_eval do
+        alias_method :new_record?, :new?
+        extend ClassMethods
+      end
+    end
+    
+    module ClassMethods
+      def column_names
+        keys.keys
+      end
+    end
+    
+    def to_param
+      id
+    end
+  end
+end

data/lib/mongomapper/save_with_validation.rb

@@ -0,0 +1,27 @@
+module MongoMapper
+  module SaveWithValidation
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :valid?, :callbacks
+        alias_method_chain :save, :validation
+      end
+    end
+    
+    def save!
+      save_with_validation || raise(DocumentNotValid.new(self))
+    end
+    
+    private
+      def save_with_validation
+        new? ? run_callbacks(:before_validation_on_create) : 
+               run_callbacks(:before_validation_on_update)
+      
+        valid? ? save_without_validation : false
+      end
+    
+      def valid_with_callbacks?
+        run_callbacks(:before_validation)
+        run_callbacks(:after_validation) if valid_without_callbacks?
+      end
+  end  
+end

data/lib/mongomapper/serialization.rb

@@ -0,0 +1,55 @@
+require 'active_support/json'
+
+module MongoMapper #:nodoc:
+  module Serialization
+    class Serializer #:nodoc:
+      attr_reader :options
+
+      def initialize(record, options = {})
+        @record, @options = record, options.dup
+      end
+
+      def serializable_key_names
+        key_names = @record.send :defined_key_names
+
+        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
+  end
+end
+
+dir = Pathname(__FILE__).dirname.expand_path + 'serializers'
+require dir + 'json_serializer'

data/lib/mongomapper/serializers/json_serializer.rb

@@ -0,0 +1,77 @@
+module MongoMapper #:nodoc:
+  module Serialization
+    def self.included(base)
+      base.cattr_accessor :include_root_in_json, :instance_writer => false
+      base.extend ClassMethods
+    end
+
+    # Returns a JSON string representing the model. Some configuration is
+    # available through +options+.
+    #
+    # The option <tt>include_root_in_json</tt> controls the top-level behavior of
+    # to_json. When it is <tt>true</tt>, to_json will emit a single root node named
+    # after the object's type. For example:
+    #
+    #   konata = User.find(1)
+    #   User.include_root_in_json = true
+    #   konata.to_json
+    #   # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
+    #                   "created_at": "2006/08/01", "awesome": true} }
+    #
+    #   User.include_root_in_json = false
+    #   konata.to_json
+    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+    #         "created_at": "2006/08/01", "awesome": true}
+    #
+    # The remainder of the examples in this section assume include_root_in_json is set to
+    # <tt>false</tt>.
+    #
+    # Without any +options+, the returned JSON string will include all
+    # the model's attributes. For example:
+    #
+    #   konata = User.find(1)
+    #   konata.to_json
+    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+    #         "created_at": "2006/08/01", "awesome": true}
+    #
+    # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
+    # included, and work similar to the +attributes+ method. For example:
+    #
+    #   konata.to_json(:only => [ :id, :name ])
+    #   # => {"id": 1, "name": "Konata Izumi"}
+    #
+    #   konata.to_json(:except => [ :id, :created_at, :age ])
+    #   # => {"name": "Konata Izumi", "awesome": true}
+    #
+    # To include any methods on the model, use <tt>:methods</tt>.
+    #
+    #   konata.to_json(:methods => :permalink)
+    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+    #         "created_at": "2006/08/01", "awesome": true,
+    #         "permalink": "1-konata-izumi"}
+    def to_json(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 < MongoMapper::Serialization::Serializer #:nodoc:
+      def serialize
+        serializable_record.to_json
+      end
+    end
+
+    module ClassMethods
+      def json_class_name
+        @json_class_name ||= name.demodulize.underscore.inspect
+      end
+    end
+  end
+end

data/lib/mongomapper.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+require 'rubygems'
+
+gem 'activesupport'
+gem 'mongodb-mongo'
+gem 'jnunemaker-validatable'
+
+require 'activesupport'
+require 'mongo'
+require 'validatable'
+
+dir = Pathname(__FILE__).dirname.expand_path + 'mongomapper'
+
+require dir + 'key'
+require dir + 'finder_options'
+require dir + 'rails_compatibility'
+require dir + 'save_with_validation'
+require dir + 'serialization'
+require dir + 'embedded_document'
+require dir + 'document'
+
+module MongoMapper
+  class DocumentNotFound < StandardError; end
+  class DocumentNotValid < StandardError
+    def initialize(document)
+      @document = document
+      super("Validation failed: #{@document.errors.full_messages.join(", ")}")
+    end
+  end
+  
+  def self.connection
+    @@connection ||= XGen::Mongo::Driver::Mongo.new
+  end
+  
+  def self.connection=(new_connection)
+    @@connection = new_connection
+  end
+  
+  def self.database=(name)
+    @@database = MongoMapper.connection.db(name)
+  end
+  
+  def self.database
+    @@database
+  end
+end

data/test/serializers/test_json_serializer.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class JsonSerializationTest < Test::Unit::TestCase
+  class Contact
+    include MongoMapper::EmbeddedDocument
+    key :name, String
+    key :age, Integer
+    key :created_at, Time
+    key :awesome, Boolean
+    key :preferences, Hash
+  end
+  
+  def setup
+    Contact.include_root_in_json = false
+    @contact = Contact.new(
+      :name        => 'Konata Izumi',
+      :age         => 16,
+      :created_at  => Time.utc(2006, 8, 1),
+      :awesome     => true,
+      :preferences => { :shows => 'anime' }
+    )
+  end
+  
+  should "include demodulized root" do
+    Contact.include_root_in_json = true
+    assert_match %r{^\{"contact": \{}, @contact.to_json
+  end
+  
+  should "encode all encodable attributes" do
+    json = @contact.to_json
+
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome": true}, json
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+  
+  should "allow attribute filtering with only" do
+    json = @contact.to_json(:only => [:name, :age])
+
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert_no_match %r{"awesome"}, json
+    assert_no_match %r{"created_at"}, json
+    assert_no_match %r{"preferences"}, json
+  end
+  
+  should "allow attribute filtering with except" do
+    json = @contact.to_json(:except => [:name, :age])
+
+    assert_no_match %r{"name"}, json
+    assert_no_match %r{"age"}, json
+    assert_match %r{"awesome"}, json
+    assert_match %r{"created_at"}, json
+    assert_match %r{"preferences"}, json
+  end
+  
+  context "including methods" do
+    setup do
+      def @contact.label; "Has cheezburger"; end
+      def @contact.favorite_quote; "Constraints are liberating"; end
+    end
+    
+    should "include single method" do
+      # Single method.
+      assert_match %r{"label": "Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+    end
+    
+    should "include multiple methods" do
+      json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+      assert_match %r{"label": "Has cheezburger"}, json
+      assert_match %r{"favorite_quote": "Constraints are liberating"}, json
+    end
+  end
+  
+  context "array of records" do
+    setup do
+      @contacts = [
+        Contact.new(:name => 'David', :age => 39),
+        Contact.new(:name => 'Mary', :age => 14)
+      ]
+    end
+
+    should "allow attribute filtering with only" do
+      assert_equal %([{"name": "David"}, {"name": "Mary"}]), @contacts.to_json(:only => :name)
+    end
+    
+    should "allow attribute filtering with except" do
+      json = @contacts.to_json(:except => [:name, :preferences, :awesome, :created_at])
+      assert_equal %([{"age": 39}, {"age": 14}]), json
+    end
+  end
+  
+  should "allow options for hash of records" do
+    contacts = {
+      1 => Contact.new(:name => 'David', :age => 39),
+      2 => Contact.new(:name => 'Mary', :age => 14)
+    }
+
+    assert_equal %({"1": {"name": "David"}}), contacts.to_json(:only => [1, :name])
+  end
+  
+end

data/test/test_associations.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class Address
+  include MongoMapper::EmbeddedDocument
+  
+  key :address, String
+  key :city,    String
+  key :state,   String
+  key :zip,     Integer
+end
+
+class AssociationsTest < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::Document
+    end
+  end
+  
+  context "Many embedded documents" do
+    setup do
+      @document.class_eval do
+        many :addresses
+      end
+    end
+
+    should "default reader to empty array" do
+      instance = @document.new
+      instance.addresses.should == []
+    end
+  
+    should "allow adding to association like it was an array" do
+      instance = @document.new
+      instance.addresses << Address.new
+      instance.addresses.push Address.new
+      instance.addresses.size.should == 2
+    end
+  
+    should "be embedded in document on save" do
+      sb = Address.new(:city => 'South Bend', :state => 'IN')
+      chi = Address.new(:city => 'Chicago', :state => 'IL')
+      instance = @document.new
+      instance.addresses << sb
+      instance.addresses << chi
+      instance.save
+    
+      from_db = @document.find(instance.id)
+      from_db.addresses.size.should == 2
+      from_db.addresses[0].should == sb
+      from_db.addresses[1].should == chi
+    end    
+  end
+end

data/test/test_callbacks.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+include ActiveSupport::Callbacks
+
+class CallbacksTest < Test::Unit::TestCase
+  context "Defining and running callbacks" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        
+        key :name, String
+        
+        [ :before_validation_on_create, :before_validation_on_update,
+          :before_validation, :after_validation,
+          :before_create,     :after_create, 
+          :before_update,     :after_update,
+          :before_save,       :after_save,
+          :before_destroy,    :after_destroy].each do |callback|
+          callback_method = "#{callback}_callback"
+          send(callback, callback_method)
+          define_method(callback_method) do
+            history << callback.to_sym
+          end
+        end
+        
+        def history
+          @history ||= []
+        end
+        
+        def clear_history
+          @history = nil
+        end
+      end
+      @document.collection.clear
+    end
+    
+    should "get the order right for creating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should == [:before_validation_on_create, :before_validation, :after_validation, :before_save, :before_create, :after_create, :after_save]
+    end
+    
+    should "get the order right for updating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.clear_history
+      doc.name = 'John'
+      doc.save
+      doc.history.should == [:before_validation_on_update, :before_validation, :after_validation, :before_save, :before_update, :after_update, :after_save]
+    end
+    
+    should "work for before and after validation" do
+      doc = @document.new(:name => 'John Nunemaker')
+      doc.valid?
+      doc.history.should include(:before_validation)
+      doc.history.should include(:after_validation)
+    end
+    
+    should "work for before and after create" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should include(:before_create)
+      doc.history.should include(:after_create)
+    end
+    
+    should "work for before and after update" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_update)
+      doc.history.should include(:after_update)
+    end
+    
+    should "work for before and after save" do
+      doc = @document.new
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_save)
+      doc.history.should include(:after_save)
+    end
+    
+    should "work for before and after destroy" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.destroy
+      doc.history.should include(:before_destroy)
+      doc.history.should include(:after_destroy)
+    end
+  end
+end