mongo_mapper 0.6.10 → 0.7.0

data/lib/mongo_mapper/rails_compatibility/document.rb

@@ -1,15 +0,0 @@
-module MongoMapper
-  module RailsCompatibility
-    module Document
-      def self.included(model)
-        model.class_eval do
-          alias_method :new_record?, :new?
-          
-          def human_name
-            self.name.demodulize.titleize
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongo_mapper/rails_compatibility/embedded_document.rb

@@ -1,28 +0,0 @@
-module MongoMapper
-  module RailsCompatibility
-    module EmbeddedDocument
-      def self.included(model)
-        model.class_eval do
-          extend ClassMethods
-          
-          alias_method :new_record?, :new?
-        end
-
-        class << model
-          alias has_many many
-          alias has_one one
-        end
-      end
-
-      module ClassMethods
-        def column_names
-          keys.keys
-        end
-        
-        def human_name
-          self.name.demodulize.titleize
-        end
-      end
-    end
-  end
-end

data/lib/mongo_mapper/serialization.rb

@@ -1,54 +0,0 @@
-require 'active_support/json'
-
-module MongoMapper
-  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
-  end
-end
-
-require 'mongo_mapper/serializers/json_serializer'

data/lib/mongo_mapper/serializers/json_serializer.rb

@@ -1,48 +0,0 @@
-module MongoMapper
-  module Serialization
-    def self.included(base)
-      base.cattr_accessor :include_root_in_json, :instance_writer => false
-      base.extend ClassMethods
-    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 < MongoMapper::Serialization::Serializer
-      def serialize
-        serializable_record.to_json
-      end
-    end
-
-    module ClassMethods
-      def json_class_name
-        @json_class_name ||= name.demodulize.underscore.inspect
-      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
-end

data/lib/mongo_mapper/validations.rb

@@ -1,39 +0,0 @@
-module MongoMapper
-  module Validations    
-    module Macros
-      def validates_uniqueness_of(*args)
-        add_validations(args, MongoMapper::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?
-        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

data/test/functional/test_rails_compatibility.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-class TestRailsCompatibility < Test::Unit::TestCase
-  class Item
-    include MongoMapper::EmbeddedDocument
-    key :for_all, String
-  end
-  
-  class Order
-    include MongoMapper::Document
-    many :items, :class_name => 'TestRailsCompatibility::Item'
-    key :order_only, String
-  end
-  
-  context "Document" do
-    setup do
-      Order.collection.remove
-    end
-
-    should "alias new to new_record?" do
-      instance = Order.new
-      instance.new_record?.should == instance.new?
-    end
-  end
-end