mongo_mapper-unstable 2010.1.6 → 2010.1.12

data/lib/mongo_mapper/dirty.rb

@@ -1,117 +0,0 @@
-module MongoMapper
-  module Dirty
-    DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
-    
-    def method_missing(method, *args, &block)
-      if method.to_s =~ /(_changed\?|_change|_will_change!|_was)$/
-        method_suffix = $1
-        key = method.to_s.gsub(method_suffix, '')
-        
-        if key_names.include?(key)
-          case method_suffix
-            when '_changed?'
-              key_changed?(key)
-            when '_change'
-              key_change(key)
-            when '_will_change!'
-              key_will_change!(key)
-            when '_was'
-              key_was(key)
-          end
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-    
-    def changed?
-      !changed_keys.empty?
-    end
-
-    def changed
-      changed_keys.keys
-    end
-
-    def changes
-      changed.inject({}) { |h, attribute| h[attribute] = key_change(attribute); h }
-    end
-    
-    def initialize(attrs={})
-      super(attrs)
-      changed_keys.clear unless new?
-    end
-
-    def save(*args)
-      if status = super
-        changed_keys.clear
-      end
-      status
-    end
-
-    def save!(*args)
-      status = super
-      changed_keys.clear
-      status
-    end
-
-    def reload(*args)
-      record = super
-      changed_keys.clear
-      record
-    end
-
-    private
-      def clone_key_value(attribute_name)
-        value = send(:read_attribute, attribute_name)
-        value.duplicable? ? value.clone : value
-      rescue TypeError, NoMethodError
-        value
-      end
-      
-      def changed_keys
-        @changed_keys ||= {}
-      end
-
-      def key_changed?(attribute)
-        changed_keys.include?(attribute)
-      end
-
-      def key_change(attribute)
-        [changed_keys[attribute], __send__(attribute)] if key_changed?(attribute)
-      end
-
-      def key_was(attribute)
-        key_changed?(attribute) ? changed_keys[attribute] : __send__(attribute)
-      end
-
-      def key_will_change!(attribute)
-        changed_keys[attribute] = clone_key_value(attribute)
-      end
-
-      def write_attribute(attribute, value)
-        attribute = attribute.to_s
-
-        if changed_keys.include?(attribute)
-          old = changed_keys[attribute]
-          changed_keys.delete(attribute) unless value_changed?(attribute, old, value)
-        else
-          old = clone_key_value(attribute)
-          changed_keys[attribute] = old if value_changed?(attribute, old, value)
-        end
-
-        super(attribute, value)
-      end
-      
-      def value_changed?(key_name, old, value)
-        key = _keys[key_name]
-        
-        if key.number? && value.blank?
-          value = nil
-        end
-        
-        old != value
-      end
-  end
-end

data/lib/mongo_mapper/key.rb

@@ -1,36 +0,0 @@
-module MongoMapper
-  class Key
-    attr_accessor :name, :type, :options, :default_value
-    
-    def initialize(*args)
-      options = args.extract_options!
-      @name, @type = args.shift.to_s, args.shift
-      self.options = (options || {}).symbolize_keys
-      self.default_value = self.options.delete(:default)
-    end
-
-    def ==(other)
-      @name == other.name && @type == other.type
-    end
-
-    def set(value)
-      type.to_mongo(value)
-    end
-
-    def embeddable?
-      type.respond_to?(:embeddable?) && type.embeddable? ? true : false
-    end
-    
-    def number?
-      [Integer, Float].include?(type)
-    end
-
-    def get(value)
-      if value.nil? && !default_value.nil?
-        return default_value
-      end
-      
-      type.from_mongo(value)
-    end
-  end
-end

data/lib/mongo_mapper/mongo_mapper.rb

@@ -1,125 +0,0 @@
-# if Gem is defined i'll assume you are using rubygems and lock specific versions
-# call me crazy but a plain old require will just get the latest version you have installed
-# so i want to make sure that if you are using gems you do in fact have the correct versions
-# if there is a better way to do this, please enlighten me!
-if self.class.const_defined?(:Gem)
-  gem 'activesupport', '>= 2.3'
-  gem 'mongo', '0.18.2'
-  gem 'jnunemaker-validatable', '1.8.1'
-end
-
-require 'active_support'
-require 'mongo'
-require 'validatable'
-
-module MongoMapper
-  # generic MM error
-  class MongoMapperError < StandardError; end
-  
-  # raised when key expected to exist but not found
-  class KeyNotFound < MongoMapperError; end
-  
-  # raised when document expected but not found
-  class DocumentNotFound < MongoMapperError; end
-  
-  # raised when document not valid and using !
-  class DocumentNotValid < MongoMapperError
-    def initialize(document)
-      super("Validation failed: #{document.errors.full_messages.join(", ")}")
-    end
-  end
-  
-  # @api public
-  def self.connection
-    @@connection ||= Mongo::Connection.new
-  end
-  
-  # @api public
-  def self.connection=(new_connection)
-    @@connection = new_connection
-  end
-  
-  # @api public
-  def self.logger
-    connection.logger
-  end
-  
-  # @api public
-  def self.database=(name)
-    @@database = nil
-    @@database_name = name
-  end
-  
-  # @api public
-  def self.database
-    if @@database_name.blank?
-      raise 'You forgot to set the default database name: MongoMapper.database = "foobar"'
-    end
-    
-    @@database ||= MongoMapper.connection.db(@@database_name)
-  end
-  
-  # @api private
-  def self.ensured_indexes
-    @@ensured_indexes ||= []
-  end
-  
-  # @api private
-  def self.ensured_indexes=(value)
-    @@ensured_indexes = value
-  end
-  
-  # @api private
-  def self.ensure_index(klass, keys, options={})
-    ensured_indexes << {:klass => klass, :keys => keys, :options => options}
-  end
-  
-  # @api public
-  def self.ensure_indexes!
-    ensured_indexes.each do |index|
-      unique = index[:options].delete(:unique)
-      index[:klass].collection.create_index(index[:keys], unique)
-    end
-  end
-  
-  # @api private
-  def self.use_time_zone?
-    Time.respond_to?(:zone) && Time.zone ? true : false
-  end
-  
-  # @api private
-  def self.time_class
-    use_time_zone? ? Time.zone : Time
-  end
-  
-  # @api private
-  def self.normalize_object_id(value)
-    value.is_a?(String) ? Mongo::ObjectID.from_string(value) : value
-  end
-end
-
-require 'mongo_mapper/support'
-require 'mongo_mapper/callbacks'
-require 'mongo_mapper/finder_options'
-require 'mongo_mapper/dirty'
-require 'mongo_mapper/dynamic_finder'
-require 'mongo_mapper/key'
-require 'mongo_mapper/pagination'
-require 'mongo_mapper/serialization'
-require 'mongo_mapper/validations'
-require 'mongo_mapper/rails_compatibility/document'
-require 'mongo_mapper/rails_compatibility/embedded_document'
-require 'mongo_mapper/embedded_document'
-require 'mongo_mapper/document'
-require 'mongo_mapper/associations'
-require 'mongo_mapper/associations/base'
-require 'mongo_mapper/associations/proxy'
-require 'mongo_mapper/associations/collection'
-require 'mongo_mapper/associations/many_documents_proxy'
-require 'mongo_mapper/associations/belongs_to_proxy'
-require 'mongo_mapper/associations/belongs_to_polymorphic_proxy'
-require 'mongo_mapper/associations/many_polymorphic_proxy'
-require 'mongo_mapper/associations/many_embedded_proxy'
-require 'mongo_mapper/associations/many_embedded_polymorphic_proxy'
-require 'mongo_mapper/associations/many_documents_as_proxy'
-require 'mongo_mapper/associations/one_proxy'

data/lib/mongo_mapper/pagination.rb

@@ -1,66 +0,0 @@
-module MongoMapper
-  module Pagination
-    class PaginationProxy
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
-      
-      attr_accessor :subject
-      attr_reader :total_entries, :per_page, :current_page
-      alias limit per_page
-      
-      def initialize(total_entries, current_page, per_page=nil)
-        @total_entries    = total_entries.to_i
-        self.per_page     = per_page
-        self.current_page = current_page
-      end
-      
-      def total_pages
-        (total_entries / per_page.to_f).ceil
-      end
-      
-      def out_of_bounds?
-        current_page > total_pages
-      end
-      
-      def previous_page
-        current_page > 1 ? (current_page - 1) : nil
-      end
-      
-      def next_page
-        current_page < total_pages ? (current_page + 1) : nil
-      end
-      
-      def skip
-        (current_page - 1) * per_page
-      end
-      alias offset skip # for will paginate support
-
-      def send(method, *args, &block)
-        if respond_to?(method)
-          super
-        else
-          subject.send(method, *args, &block)
-        end
-      end
-      
-      def ===(other)
-        other === subject
-      end
-      
-      def method_missing(name, *args, &block)
-        @subject.send(name, *args, &block)
-      end
-      
-      private
-        def per_page=(value)
-          value = 25 if value.blank?
-          @per_page = value.to_i
-        end
-        
-        def current_page=(value)
-          value = value.to_i
-          value = 1 if value < 1
-          @current_page = value
-        end
-    end
-  end
-end

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