mark_mapper 0.0.1

data/lib/mark_mapper/plugins/scopes.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Scopes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_scopes
+      end
+
+      module ClassMethods
+        def scope(name, scope_options={})
+          # Assign to _scopes instead of using []= to avoid mixing subclass scopes
+          self._scopes = scopes.merge(name => lambda do |*args|
+            result = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
+            result = self.query(result) if result.is_a?(Hash)
+            self.query.merge(result)
+          end)
+          singleton_class.send :define_method, name, &scopes[name]
+        end
+
+        def scopes
+          self._scopes ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/serialization.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+require 'active_model/serializers/json'
+require 'active_model/serializers/xml'
+
+module MarkMapper
+  module Plugins
+    module Serialization
+      extend ActiveSupport::Concern
+
+      included do
+        include ::ActiveModel::Serializers::JSON
+        include ::ActiveModel::Serializers::Xml
+        self.include_root_in_json = false
+      end
+
+      def serializable_attributes
+        attributes.keys.map { |k| k.to_s } + ['id'] - ['_id']
+      end
+
+      def serializable_hash(options = nil)
+        options ||= {}
+
+        options[:only]   = Array.wrap(options[:only]).map { |k| k.to_s }
+        options[:except] = Array.wrap(options[:except]).map { |k| k.to_s }
+
+        attribute_names = serializable_attributes
+
+        if options[:only].any?
+          attribute_names &= options[:only]
+        elsif options[:except].any?
+          attribute_names -= options[:except]
+        end
+
+        attribute_names += Array.wrap(options[:methods]).map { |m| m.to_s }.select do |method|
+          respond_to?(method)
+        end
+
+        hash = attribute_names.sort.inject({}) do |hash, name|
+          value = send(name)
+          hash[name] = if value.is_a?(Array)
+            value.map {|v| v.respond_to?(:serializable_hash) ? v.serializable_hash : v }
+          elsif value.respond_to?(:serializable_hash)
+            value.serializable_hash
+          else
+            value
+          end
+          hash
+        end
+
+        serializable_add_includes(options) do |association, records, opts|
+          hash[association.to_s] = records.is_a?(Array) ?
+            records.map { |r| r.serializable_hash(opts) } :
+            records.serializable_hash(opts)
+        end
+
+        hash
+      end
+
+      def to_xml(options = {}, &block)
+        XmlSerializer.new(self, options).serialize(&block)
+      end
+
+    private
+
+      def serializable_add_includes(options = {})
+        return unless include_associations = options.delete(:include)
+
+        base_only_or_except = { :except => options[:except],
+                                :only => options[:only] }
+
+        include_has_options = include_associations.is_a?(Hash)
+        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
+
+        associations.each do |association|
+          records = get_proxy(self.class.associations[association])
+          unless records.nil?
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+            opts = options.merge(association_options)
+            yield(association, records, opts)
+          end
+        end
+
+        options[:include] = include_associations
+      end
+
+      module ClassMethods
+        def from_json(json)
+          self.new.from_json(json)
+        end
+
+        def from_xml(xml)
+          self.new.from_xml(xml)
+        end
+      end
+    end
+
+    # Override default Serializer to use #serializable_hash
+    class XmlSerializer < ::ActiveModel::Serializers::Xml::Serializer
+      def attributes_hash
+        @serializable.serializable_hash(options)
+      end
+
+      def serializable_methods
+        # Methods are already included in #serializable_hash
+        []
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/timestamps.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Timestamps
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :record_timestamps
+        self.record_timestamps = true
+      end
+
+      module ClassMethods
+        def timestamps!
+          key :created_at, Time
+          key :updated_at, Time
+          class_eval { before_save :update_timestamps }
+        end
+      end
+
+      def update_timestamps
+        if self.record_timestamps
+          now = Time.now.utc
+          self[:created_at] = now if !persisted? && !created_at?
+          self[:updated_at] = now
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/touch.rb

@@ -0,0 +1,18 @@
+module MarkMapper
+  module Plugins
+    module Touch
+      extend ActiveSupport::Concern
+
+      def touch(key = :updated_at)
+        raise ArgumentError, "Invalid key named #{key}" unless self.key_names.include?(key.to_s)
+        if self.class.embeddable?
+          self.write_attribute(key, Time.now.utc)
+          self._parent_document.touch
+        else
+          self.set(key => Time.now.utc)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/userstamps.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Userstamps
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def userstamps!(options = {})
+          class_name = (options[:class_name] || options[:class] || 'User' ).to_s
+          key :creator_id, ObjectId
+          key :updater_id, ObjectId
+          belongs_to :creator, :class_name => class_name
+          belongs_to :updater, :class_name => class_name
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/validations.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Validations
+      extend ActiveSupport::Concern
+
+      include ::ActiveModel::Validations
+      include ::ActiveModel::Validations::Callbacks
+
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
+        end
+
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      def save(options = {})
+        options = options.reverse_merge(:validate => true)
+        !options[:validate] || valid? ? super : false
+      end
+
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
+      end
+
+      class UniquenessValidator < ::ActiveModel::EachValidator
+        def initialize(options)
+          @klass = options[:class] #only provided in ActiveModel 4.1 and higher
+          super(options.reverse_merge(:case_sensitive => true))
+        end
+
+        if ::ActiveModel::VERSION::MAJOR < 4 ||
+          (::ActiveModel::VERSION::MAJOR == 4 && ::ActiveModel::VERSION::MINOR == 0)
+
+          def setup(klass)
+            @klass = klass
+          end
+        end
+
+        def validate_each(record, attribute, value)
+          conditions = scope_conditions(record)
+
+          if options[:case_sensitive] == true
+            conditions[attribute] = value
+          else
+            conditions[attribute] = {
+              '$eq' => value.to_s.downcase,
+              options: {
+                case_sensitive: false
+              }
+            }
+          end
+
+          # Make sure we're not including the current document in the query
+          conditions[:_id.ne] = record._id if record._id
+
+          if @klass.exists?(conditions)
+            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+          end
+        end
+
+        def message(instance)
+          super || "has already been taken"
+        end
+
+        def scope_conditions(instance)
+          Array(options[:scope] || []).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+      end
+
+      class AssociatedValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if !Array.wrap(value).all? { |c| c.nil? || c.valid?(options[:context]) }
+            record.errors.add(attribute, :invalid, :message => options[:message], :value => value)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# Need to monkey patch ActiveModel for now since it uses the internal
+# _run_validation_callbacks, which is impossible to override due to the
+# way ActiveSupport::Callbacks is implemented.
+ActiveModel::Validations::Callbacks.class_eval do
+  def run_validations!
+    run_callbacks(:validation) { super }
+  end
+end

data/lib/mark_mapper/query.rb

@@ -0,0 +1,278 @@
+# encoding: UTF-8
+require 'set'
+require 'forwardable'
+
+module MarkMapper
+  class Query
+    include Enumerable
+    extend  Forwardable
+
+    # Private
+    OptionKeys = Set[
+      :select, :offset, :order,                         # MM
+      :fields, :skip, :limit, :sort, # :hint, :snapshot,  # Ruby Driver
+      :debug, :return_results, :return_query, # Ruby Driver
+      :format, :page, :per_page, :view, # Ruby Driver
+      :transformer # Ruby Driver
+    ]
+
+    attr_reader :criteria, :options, :collection
+
+    def_delegator  :@criteria, :simple?
+    def_delegator  :@options,  :fields?
+    # def_delegators :to_a, :include?
+
+    # Public
+    def initialize(collection, query_options = {})
+      @collection, @options, @criteria = collection, OptionsHash.new, CriteriaHash.new
+      query_options.each { |key, value| self[key] = value }
+    end
+
+    def initialize_copy(original)
+      super
+      @criteria = @criteria.dup
+      @options = @options.dup
+    end
+
+    # Public
+    def object_ids(*keys)
+      return @criteria.object_ids if keys.empty?
+      @criteria.object_ids = *keys
+      self
+    end
+
+    # finder DSL methods to delegate to your model if you're building an ODM
+    # e.g. MyModel.last needs to be equivalent to MyModel.query.last
+    module DSL
+      def per_page(limit=nil)
+        return @per_page || MarkLogic::Cursor::DEFAULT_PAGE_LENGTH if limit.nil?
+        @per_page = limit
+        self
+      end
+
+      def paginate(opts={})
+        page      = opts.delete(:page)
+        limit     = opts.delete(:per_page) || per_page
+        total_entries = opts.delete(:total_entries)
+        query     = clone.amend(opts)
+        paginator = Pagination::Paginator.new(total_entries || query.count, page, limit)
+        docs      = query.amend({
+          :limit => paginator.limit,
+          :skip  => paginator.skip,
+        }).all
+
+        Pagination::Collection.new(docs, paginator)
+      end
+
+      def find_each(opts={})
+        query = clone.amend(opts)
+
+        if block_given?
+          result = nil
+          query.cursor do |cursor|
+            result = cursor
+            cursor.each { |doc| yield doc }
+            cursor.rewind!
+          end
+          result
+        else
+          query.cursor
+        end
+      end
+
+      def find_one(opts={})
+        query = clone.amend(opts)
+        query.collection.find_one(query.criteria_hash, query.options_hash)
+      end
+
+      def find(*ids)
+        return nil if ids.empty?
+
+        single_id_find = ids.size == 1 && !ids[0].is_a?(Array)
+
+        if single_id_find
+          first(:_id => ids[0])
+        else
+          all(:_id => ids.flatten)
+        end
+      end
+
+      def all(opts={})
+        [].tap do |docs|
+          find_each(opts) {|doc| docs << doc }
+        end
+      end
+
+      def last(opts={})
+        clone.amend(opts).reverse.find_one
+      end
+
+      def remove(opts={})
+        query = clone.amend(opts)
+        query.collection.remove(query.criteria_hash, query.options_hash)
+      end
+
+      def count(opts={})
+        query = clone.amend(opts)
+        cursor = query.cursor
+        cursor.count
+      end
+
+      # def distinct(key, opts = {})
+      #   query = clone.amend(opts)
+      #   query.collection.distinct(key, query.criteria_hash)
+      # end
+
+      def fields(*args)
+        clone.tap { |query| query.options[:fields] = *args }
+      end
+
+      def ignore(*args)
+        set_field_inclusion(args, 0)
+      end
+
+      def only(*args)
+        set_field_inclusion(args, 1)
+      end
+
+      def limit(count=nil)
+        clone.tap { |query| query.options[:limit] = count }
+      end
+
+      def reverse
+        clone.tap do |query|
+          sort = query[:sort]
+          if sort.nil?
+            query.options[:sort] = [[:_id, -1]]
+          else
+            query.options[:sort] = sort.map { |s| [s[0], -s[1]] }
+          end
+        end
+      end
+
+      def skip(count=nil)
+        clone.tap { |query| query.options[:skip] = count }
+      end
+
+      def sort(*args)
+        clone.tap { |query| query.options[:sort] = *args }
+      end
+
+      def where(hash={})
+        clone.tap { |query| query.criteria.merge!(CriteriaHash.new(hash)) }
+      end
+
+      def empty?
+        count == 0
+      end
+
+      def exists?(query_options={})
+        !only(:_id).find_one(query_options).nil?
+      end
+
+      alias_method :each,   :find_each
+      alias_method :first,  :find_one
+      alias_method :size,   :count
+      alias_method :offset, :skip
+      alias_method :order,  :sort
+      alias_method :exist?, :exists?
+      alias_method :filter, :where
+      alias_method :to_a,   :all
+    end
+    include DSL
+
+    # def update(document, driver_opts={})
+    #   query = clone
+    #   query.collection.update(query.criteria_hash, document, driver_opts)
+    # end
+
+    def amend(opts={})
+      opts.each { |key, value| self[key] = value }
+      self
+    end
+
+    def [](key)
+      key = symbolized_key(key)
+      source = hash_for_key(key)
+      source[key]
+    end
+
+    def []=(key, value)
+      key = symbolized_key(key)
+      source = hash_for_key(key)
+      source[key] = value
+    end
+
+    def merge(other)
+      merged_criteria = @criteria.merge(other.criteria).to_hash
+      merged_options  = @options.merge(other.options).to_hash
+      clone.amend(merged_criteria).amend(merged_options)
+    end
+
+    def to_hash
+      criteria_hash.merge(options_hash)
+    end
+
+    def explain
+      @collection.find(query.criteria_hash, query.options_hash).explain
+    end
+
+    def inspect
+      as_nice_string = to_hash.collect do |key, value|
+        " #{key}: #{value.inspect}"
+      end.sort.join(",")
+      "#<#{self.class}#{as_nice_string}>"
+    end
+
+    def criteria_hash
+      @criteria.to_hash
+    end
+
+    def options_hash
+      @options.to_hash
+    end
+
+    def cursor(&block)
+      @collection.find(criteria_hash, options_hash, &block)
+    end
+
+    # def to_cursor_options
+    #   options_hash.merge({
+    #     :query => qb.from_criteria(criteria_hash.to_hash)
+    #   })
+    # end
+
+  private
+
+    # Private
+    def qb
+      @qb || MarkLogic::QueryBuilder.new(@collection)
+    end
+
+    # Private
+    def hash_for_key(key)
+      options_key?(key) ? @options : @criteria
+    end
+
+    # Private
+    def symbolized_key(key)
+      if key.respond_to?(:to_sym)
+        key.to_sym
+      else
+        key
+      end
+    end
+
+    # Private
+    def options_key?(key)
+      OptionKeys.include?(key)
+    end
+
+    # Private
+    def set_field_inclusion(fields, value)
+      fields_option = {}
+      fields.each { |field| fields_option[symbolized_key(field)] = value }
+      clone.tap { |query| query.options[:fields] = fields_option }
+    end
+  end
+end