ssherman-mongo_mapper 0.8.6

data/lib/mongo_mapper/extensions/float.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Float
+      def to_mongo(value)
+        value.nil? ? nil : value.to_f
+      end
+    end
+  end
+end
+
+class Float
+  extend MongoMapper::Extensions::Float
+end

data/lib/mongo_mapper/extensions/hash.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Hash
+      def from_mongo(value)
+        HashWithIndifferentAccess.new(value || {})
+      end
+    end
+  end
+end
+
+class Hash
+  extend MongoMapper::Extensions::Hash
+end

data/lib/mongo_mapper/extensions/integer.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Integer
+      def 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
+  end
+end
+
+class Integer
+  extend MongoMapper::Extensions::Integer
+end

data/lib/mongo_mapper/extensions/kernel.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+module Kernel
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      self
+    end
+  end unless respond_to?(:singleton_class) # exists in 1.9.2
+end

data/lib/mongo_mapper/extensions/nil_class.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module NilClass
+      def to_mongo(value)
+        value
+      end
+
+      def from_mongo(value)
+        value
+      end
+    end
+  end
+end
+
+class NilClass
+  include MongoMapper::Extensions::NilClass
+end

data/lib/mongo_mapper/extensions/object.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Object
+      module ClassMethods
+        def to_mongo(value)
+          value
+        end
+
+        def from_mongo(value)
+          value
+        end
+      end
+
+      module InstanceMethods
+        def to_mongo
+          self.class.to_mongo(self)
+        end
+      end
+    end
+  end
+end
+
+class Object
+  extend MongoMapper::Extensions::Object::ClassMethods
+  include MongoMapper::Extensions::Object::InstanceMethods
+end

data/lib/mongo_mapper/extensions/object_id.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module ObjectId
+      def to_mongo(value)
+        Plucky.to_object_id(value)
+      end
+
+      def from_mongo(value)
+        value
+      end
+    end
+  end
+end
+
+class ObjectId
+  extend MongoMapper::Extensions::ObjectId
+end
+
+class BSON::ObjectId
+  alias_method :original_to_json, :to_json
+
+  def as_json(options=nil)
+    to_s
+  end
+
+  def to_json(options = nil)
+    as_json.to_json
+  end
+end

data/lib/mongo_mapper/extensions/set.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+require 'set'
+
+module MongoMapper
+  module Extensions
+    module Set
+      def to_mongo(value)
+        value.to_a
+      end
+
+      def from_mongo(value)
+        (value || []).to_set
+      end
+    end
+  end
+end
+
+class Set
+  extend MongoMapper::Extensions::Set
+end

data/lib/mongo_mapper/extensions/string.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module String
+      def to_mongo(value)
+        value.nil? ? nil : value.to_s
+      end
+
+      def from_mongo(value)
+        value.nil? ? nil : value.to_s
+      end
+    end
+  end
+end
+
+class String
+  extend MongoMapper::Extensions::String
+end

data/lib/mongo_mapper/extensions/time.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+module MongoMapper
+  module Extensions
+    module Time
+      def to_mongo(value)
+        if value.nil? || value == ''
+          nil
+        else
+          time_class = ::Time.try(:zone).present? ? ::Time.zone : ::Time
+          time = value.is_a?(::Time) ? value : time_class.parse(value.to_s)
+          # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
+          at(time.to_i).utc if time
+        end
+      end
+
+      def from_mongo(value)
+        if ::Time.try(:zone).present? && value.present?
+          value.in_time_zone(::Time.zone)
+        else
+          value
+        end
+      end
+    end
+  end
+end
+
+class Time
+  extend MongoMapper::Extensions::Time
+end

data/lib/mongo_mapper/plugins.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      extend mod::ClassMethods     if mod.constants.include?(:ClassMethods)
+      include mod::InstanceMethods if mod.constants.include?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
+      plugins << mod
+    end
+  end
+end

data/lib/mongo_mapper/plugins.rb~

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
+      plugins << mod
+    end
+  end
+end

data/lib/mongo_mapper/plugins/accessible.rb

@@ -0,0 +1,44 @@
+module MongoMapper
+  module Plugins
+    module Accessible
+      module ClassMethods
+        def attr_accessible(*attrs)
+          raise AccessibleOrProtected.new(name) if try(:protected_attributes?)
+          self.write_inheritable_attribute(:attr_accessible, Set.new(attrs) + (accessible_attributes || []))
+        end
+
+        def accessible_attributes?
+          !accessible_attributes.nil?
+        end
+
+        def accessible_attributes
+          self.read_inheritable_attribute(:attr_accessible)
+        end
+      end
+
+      module InstanceMethods
+        def assign(attrs={})
+          super(filter_inaccessible_attrs(attrs))
+        end
+
+        def update_attributes(attrs={})
+          super(filter_inaccessible_attrs(attrs))
+        end
+
+        def update_attributes!(attrs={})
+          super(filter_inaccessible_attrs(attrs))
+        end
+
+        def accessible_attributes
+          self.class.accessible_attributes
+        end
+
+        protected
+          def filter_inaccessible_attrs(attrs)
+            return attrs if accessible_attributes.blank? || attrs.blank?
+            attrs.dup.delete_if { |key, val| !accessible_attributes.include?(key.to_sym) }
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      module ClassMethods
+        def inherited(subclass)
+          subclass.associations = associations.dup
+          super
+        end
+
+        def belongs_to(association_id, options={}, &extension)
+          create_association(:belongs_to, association_id, options, &extension)
+        end
+
+        def many(association_id, options={}, &extension)
+          create_association(:many, association_id, options, &extension)
+        end
+
+        def one(association_id, options={}, &extension)
+          create_association(:one, association_id, options, &extension)
+        end
+
+        def associations
+          @associations ||= HashWithIndifferentAccess.new
+        end
+
+        def associations=(hash)
+          @associations = hash
+        end
+
+        private
+          def create_association(type, name, options, &extension)
+            association = Associations::Base.new(type, name, options, &extension)
+            associations[association.name] = association
+
+            define_method(association.name) do
+              get_proxy(association)
+            end
+
+            define_method("#{association.name}=") do |value|
+              get_proxy(association).replace(value)
+              value
+            end
+
+            if association.one? || association.belongs_to?
+              define_method("#{association.name}?") do
+                get_proxy(association).present?
+              end
+            end
+
+            if association.options[:dependent] && association.many? && !association.embeddable?
+              after_destroy do |doc|
+                case association.options[:dependent]
+                  when :destroy
+                    doc.get_proxy(association).destroy_all
+                  when :delete_all
+                    doc.get_proxy(association).delete_all
+                  when :nullify
+                    doc.get_proxy(association).nullify
+                end
+              end
+            end
+          end
+      end
+
+      module InstanceMethods
+        def associations
+          self.class.associations
+        end
+
+        def embedded_associations
+          associations.select do |name, association|
+            association.embeddable?
+          end.map do |name, association|
+            association
+          end
+        end
+
+        def get_proxy(association)
+          unless proxy = self.instance_variable_get(association.ivar)
+            proxy = association.proxy_class.new(self, association)
+            self.instance_variable_set(association.ivar, proxy)
+          end
+          proxy
+        end
+
+        def save_to_collection(options={})
+          super
+          associations.each do |association_name, association|
+            proxy = get_proxy(association)
+            proxy.save_to_collection(options) if proxy.proxy_respond_to?(:save_to_collection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations/base.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class Base
+        attr_reader :type, :name, :options, :query_options
+
+        # Options that should not be considered MongoDB query options/criteria
+        AssociationOptions = [:as, :class, :class_name, :dependent, :extend, :foreign_key, :in, :polymorphic]
+
+        def initialize(type, name, options={}, &extension)
+          @type, @name, @options, @query_options, @original_options = type, name, {}, {}, options
+          options.symbolize_keys!
+          options[:extend] = modularized_extensions(extension, options[:extend])
+          separate_options_and_conditions
+        end
+
+        def class_name
+          return @class_name if defined?(@class_name)
+
+          @class_name =
+            if cn = options[:class_name]
+              cn
+            elsif many?
+              name.to_s.singularize.camelize
+            else
+              name.to_s.camelize
+            end
+        end
+
+        def klass
+          @klass ||= options[:class] || class_name.constantize
+        end
+
+        def many?
+          @type == :many
+        end
+
+        def belongs_to?
+          @type == :belongs_to
+        end
+
+        def one?
+          @type == :one
+        end
+
+        def polymorphic?
+          !!@options[:polymorphic]
+        end
+
+        def as?
+          !!@options[:as]
+        end
+
+        def in_array?
+          !!@options[:in]
+        end
+
+        def embeddable?
+          (one? || many?) && klass.embeddable?
+        end
+
+        def type_key_name
+          many? ? '_type' : "#{as}_type"
+        end
+
+        def as
+          @options[:as] || self.name
+        end
+
+        def foreign_key
+          @options[:foreign_key] || "#{name}_id"
+        end
+
+        def ivar
+          @ivar ||= "@_#{name}"
+        end
+
+        # hate this, need to revisit
+        def proxy_class
+          return @proxy_class if defined?(@proxy_class)
+
+          @proxy_class =
+            if many?
+              if klass.embeddable?
+                polymorphic? ? ManyEmbeddedPolymorphicProxy : ManyEmbeddedProxy
+              else
+                if polymorphic?
+                  ManyPolymorphicProxy
+                elsif as?
+                  ManyDocumentsAsProxy
+                elsif in_array?
+                  InArrayProxy
+                else
+                  ManyDocumentsProxy
+                end
+              end
+            elsif one?
+              klass.embeddable? ? OneEmbeddedProxy : OneProxy
+            else
+              polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
+            end
+        end
+
+        private
+          def separate_options_and_conditions
+            @original_options.each_pair do |key, value|
+              if AssociationOptions.include?(key)
+                @options[key] = value
+              else
+                @query_options[key] = value
+              end
+            end
+          end
+
+          def modularized_extensions(*extensions)
+            extensions.flatten.compact.map do |extension|
+              Proc === extension ? Module.new(&extension) : extension
+            end
+          end
+      end
+    end
+  end
+end