mongo_mapper_ign 0.7.4

data/lib/mongo_mapper/plugins/serialization/array.rb

@@ -0,0 +1,56 @@
+# Credit: http://github.com/tsxn26/array-xml_serialization
+
+# Extends the XML serialization support in activesupport to allow for 
+# arrays containing strings, symbols, and integers.
+
+# Forces elements in arrays to be output using to_xml on each element if the 
+# element responds to to_xml. If an element does not respond to to_xml then a 
+# nested XML tag is created with the element's to_s value and the singlarized name 
+# of the array as the tag name. 
+
+require 'rubygems'
+require 'activesupport'
+require 'builder'
+
+class Array
+  def to_xml(options = {})
+    #raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+    require 'builder' unless defined?(Builder)
+
+    options = options.dup
+    options[:root] ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+    options[:children] ||= options[:root].singularize
+    options[:indent] ||= 2
+    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+    root = options.delete(:root).to_s
+    children = options.delete(:children)
+
+    if !options.has_key?(:dasherize) || options[:dasherize]
+      root = root.dasherize
+    end
+
+    options[:builder].instruct! unless options.delete(:skip_instruct)
+
+    opts = options.merge({ :root => children })
+
+    root = root.pluralize
+    
+    xml = options[:builder]
+    if empty?
+      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
+    else
+      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) do
+        yield xml if block_given?
+        each do |e|
+          if e.respond_to? :to_xml
+            e.to_xml(opts.merge({ :skip_instruct => true }))
+          else
+            xml.tag!(root.singularize, e.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongo_mapper/plugins/serialization/xml_serializer.rb

@@ -0,0 +1,240 @@
+module MongoMapper
+  module Plugins
+    module Serialization
+
+        class XmlSerializer #:nodoc:
+          attr_reader :options
+
+          def initialize(record, options = {})
+            @record, @options = record, options.dup
+          end
+
+          def builder
+            @builder ||= begin
+              options[:indent] ||= 2
+              builder = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+              unless options[:skip_instruct]
+                builder.instruct!
+                options[:skip_instruct] = true
+              end
+
+              builder
+            end
+          end
+
+          def root
+            root = (options[:root] || @record.class.to_s.underscore).to_s
+            dasherize? ? root.dasherize : root
+          end
+
+          def dasherize?
+            !options.has_key?(:dasherize) || options[:dasherize]
+          end
+
+
+          # To replicate the behavior in ActiveRecord#attributes,
+          # :except takes precedence over :only. If :only is not set
+          # for a N level model but is set for the N+1 level models,
+          # then because :except is set to a default value, the second
+          # level model can have both :except and :only set. So if
+          # :only is set, always delete :except.
+          def serializable_attributes
+            #attribute_names = @record.attributes.keys # This includes all attributes including associations
+            attribute_names = @record.class.keys.keys # This includes just keys
+            idex = attribute_names.index("_id")
+            attribute_names[idex] = "id" if idex
+
+            if options[:only]
+              options.delete(:except)
+              attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
+            else
+              options[:except] = Array(options[:except]) 
+              attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
+            end
+
+            attribute_names.collect { |name| Attribute.new(name, @record) }
+          end
+
+          def serializable_method_attributes
+            Array(options[:methods]).collect { |name| MethodAttribute.new(name.to_s, @record) }
+          end
+
+          def add_attributes
+            (serializable_attributes + serializable_method_attributes).each do |attribute|
+              add_tag(attribute)
+            end
+          end
+
+          def add_includes
+            if include_associations = options.delete(:include)
+              root_only_or_except = { :except => options[:except],
+                                      :only => options[:only] }
+
+              include_has_options = include_associations.is_a?(Hash)
+
+              for association in include_has_options ? include_associations.keys : Array(include_associations)
+                association_options = include_has_options ? include_associations[association] : root_only_or_except
+
+                opts = options.merge(association_options)
+
+                case @record.class.associations[association].type
+                when :many, :has_and_belongs_to_many
+                  records = @record.send(association).to_a
+                  unless records.empty?
+                    tag = association.to_s
+                    tag = tag.dasherize if dasherize?
+
+                    builder.tag!(tag) do
+                      records.each { |r| r.to_xml(opts.merge(:root=>r.class.to_s.underscore)) }
+                    end
+                  end
+                when :has_one, :belongs_to
+                  if record = @record.send(association)
+                    record.to_xml(opts.merge(:root => association))
+                  end
+                end
+              end
+
+              options[:include] = include_associations
+            end
+          end
+
+          def add_procs
+            if procs = options.delete(:procs)
+              [ *procs ].each do |proc|
+                proc.call(options)
+              end
+            end
+          end
+
+
+          def add_tag(attribute)
+            if attribute.type == :array 
+              builder.tag!(
+                dasherize? ? attribute.name.dasherize.pluralize : attribute.name.pluralize,
+                attribute.decorations(!options[:skip_types])
+              ) do |x|
+                attribute.value.each do |val|
+                  if val.respond_to? :to_xml
+                    x << val.to_xml(:skip_instruct => true, :root => attribute.name.dasherize.singularize)
+                  else
+                    x.tag!(
+                      dasherize? ? attribute.name.dasherize.singularize : attribute.name.singularize,
+                      val.to_s
+                    )
+                  end
+                end
+              end
+            else
+              builder.tag!(
+                dasherize? ? attribute.name.dasherize : attribute.name,
+                attribute.value.to_s,
+                attribute.decorations(!options[:skip_types])
+              )
+            end
+          end
+
+          def serialize
+            args = [root]
+            if options[:namespace]
+              args << {:xmlns=>options[:namespace]}
+            end
+
+            builder.tag!(*args) do
+              add_attributes
+              add_includes
+              add_procs
+              yield builder if block_given?
+            end
+          end
+
+          alias_method :to_s, :serialize
+
+          class Attribute #:nodoc:
+            attr_reader :name, :value, :type
+
+            def initialize(name, record)
+              @name, @record = name, record
+
+              @type = compute_type
+              @value = compute_value
+            end
+
+            # There is a significant speed improvement if the value
+            # does not need to be escaped, as #tag! escapes all values
+            # to ensure that valid XML is generated. For known binary
+            # values, it is at least an order of magnitude faster to
+            # Base64 encode binary values and directly put them in the
+            # output XML than to pass the original value or the Base64
+            # encoded value to the #tag! method. It definitely makes
+            # no sense to Base64 encode the value and then give it to
+            # #tag!, since that just adds additional overhead.
+            def needs_encoding?
+              ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
+            end
+
+            def decorations(include_types = true)
+              decorations = {}
+
+              if type == :binary
+                decorations[:encoding] = 'base64'
+              end
+
+              if include_types && type != :string
+                decorations[:type] = type
+              end
+
+              decorations
+            end
+
+            protected
+              def compute_type
+                if name == "id"
+                  return :object_id
+                end
+
+                #type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type
+                v = @record.class.keys[name]
+                #puts "Value type is...........  #{v.type.to_s} #{v.type.to_s.blank?}"
+
+                #type = @record.send(name).class
+
+                type = v.nil? ? :yaml : (v.type.to_s.blank? ? :key : v.type.to_s.underscore.to_sym)
+
+                case type
+                  when :text
+                    :string
+                  when :time
+                    :datetime
+      #            when :array
+      #              :yaml
+                  else
+                    type
+                end
+              end
+
+              def compute_value
+                n = name == "id" ? "_id" : name
+
+                value = @record.send(n)
+
+                if formatter = Hash::XML_FORMATTING[type.to_s]
+                  value ? formatter.call(value) : nil
+                else
+                  value
+                end
+              end
+          end
+
+          class MethodAttribute < Attribute #:nodoc:
+            protected
+              def compute_type
+                Hash::XML_TYPE_NAMES[@record.send(name).class.name] || :string
+              end
+          end
+      end      
+
+    end
+  end
+end

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -0,0 +1,21 @@
+module MongoMapper
+  module Plugins
+    module Timestamps
+      module ClassMethods
+        def timestamps!
+          key :created_at, Time
+          key :updated_at, Time
+          class_eval { before_save :update_timestamps }
+        end
+      end
+      
+      module InstanceMethods
+        def update_timestamps
+          now = Time.now.utc
+          self[:created_at] = now if new? && !created_at?
+          self[:updated_at] = now
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -0,0 +1,14 @@
+module MongoMapper
+  module Plugins
+    module Userstamps
+      module ClassMethods
+        def userstamps!
+          key :creator_id, ObjectId
+          key :updater_id, ObjectId
+          belongs_to :creator, :class_name => 'User'
+          belongs_to :updater, :class_name => 'User'
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/validations.rb

@@ -0,0 +1,46 @@
+module MongoMapper
+  module Plugins
+    module Validations
+      def self.configure(model)
+        model.class_eval { include Validatable }
+      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] = /^#{Regexp.escape(instance[attribute].to_s)}$/i unless case_sensitive
+          conditions
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/query.rb

@@ -0,0 +1,143 @@
+module MongoMapper
+  # IMPORTANT
+  # This class is private to MongoMapper and should not be considered part of MongoMapper's public API.
+  #
+  class Query
+    OptionKeys = [:fields, :select, :skip, :offset, :limit, :sort, :order]
+
+    attr_reader :model
+
+    def initialize(model, options)
+      raise ArgumentError, "Options must be a hash" unless options.is_a?(Hash)
+      @model, @options, @conditions, @original_options = model, {}, {}, options
+      separate_options_and_conditions
+      add_sci_condition
+    end
+
+    def criteria
+      to_criteria(@conditions)
+    end
+
+    def options
+      fields = @options[:fields] || @options[:select]
+      skip   = @options[:skip]   || @options[:offset] || 0
+      limit  = @options[:limit]  || 0
+      sort   = @options[:sort]   || normalized_sort(@options[:order])
+
+      {:fields => to_fields(fields), :skip => skip.to_i, :limit => limit.to_i, :sort => sort}
+    end
+
+    def to_a
+      [criteria, options]
+    end
+
+    private
+      def separate_options_and_conditions
+        @original_options.each_pair do |key, value|
+          key = key.respond_to?(:to_sym) ? key.to_sym : key
+
+          if OptionKeys.include?(key)
+            @options[key] = value
+          elsif key == :conditions
+            @conditions.update(value)
+          else
+            @conditions[key] = value
+          end
+        end
+      end
+
+      # adds _type single collection inheritance scope for models that need it
+      def add_sci_condition
+        @conditions[:_type] = model.to_s if model.single_collection_inherited?
+      end
+
+      def modifier?(field)
+        field.to_s =~ /^\$/
+      end
+
+      def symbol_operator?(object)
+        object.respond_to?(:field, :operator)
+      end
+
+      def to_criteria(conditions, parent_key=nil)
+        criteria = {}
+
+        conditions.each_pair do |key, value|
+          key = normalized_key(key)
+
+          if model.object_id_key?(key)
+            case value
+              when String
+                value = ObjectId.to_mongo(value)
+              when Array
+                value.map! { |id| ObjectId.to_mongo(id) }
+            end
+          end
+
+          if symbol_operator?(key)
+            key, value = normalized_key(key.field), {"$#{key.operator}" => value}
+          end
+
+          criteria[key] = normalized_value(criteria, key, value)
+        end
+
+        criteria
+      end
+
+      def to_fields(keys)
+        return keys if keys.is_a?(Hash)
+        return nil  if keys.blank?
+
+        if keys.respond_to?(:flatten, :compact)
+          keys.flatten.compact
+        else
+          keys.split(',').map { |key| key.strip }
+        end
+      end
+
+      def to_order(key, direction=nil)
+        [normalized_key(key).to_s, normalized_direction(direction)]
+      end
+
+      def normalized_key(key)
+        key.to_s == 'id' ? :_id : key
+      end
+
+      # TODO: this is getting heavy enough to move to a class
+      def normalized_value(criteria, key, value)
+        case value
+          when Array, Set
+            modifier?(key) ? value.to_a : {'$in' => value.to_a}
+          when Hash
+            if criteria[key].kind_of?(Hash)
+              criteria[key].dup.merge(to_criteria(value, key))
+            else
+              to_criteria(value, key)
+            end
+          when Time
+            value.utc
+          else
+            value
+        end
+      end
+
+      def normalized_direction(direction)
+        direction ||= 'asc'
+        direction.downcase == 'asc' ? Mongo::ASCENDING : Mongo::DESCENDING
+      end
+
+      def normalized_sort(sort)
+        return if sort.blank?
+
+        if sort.respond_to?(:all?) && sort.all? { |s| symbol_operator?(s) }
+          sort.map { |s| to_order(s.field, s.operator) }
+        elsif symbol_operator?(sort)
+          [to_order(sort.field, sort.operator)]
+        else
+          sort.split(',').map do |str|
+            to_order(*str.strip.split(' '))
+          end
+        end
+      end
+  end
+end