mark_mapper 0.0.1

data/lib/mark_mapper/normalizers/sort_value.rb

@@ -0,0 +1,55 @@
+module MarkMapper
+  module Normalizers
+    class SortValue
+
+      # Public: Initializes a MarkMapper::Normalizers::SortValue
+      #
+      # args - The hash of arguments
+      #        :key_normalizer - What to use to normalize keys, must
+      #                          respond to call.
+      #
+      def initialize(args = {})
+        @key_normalizer = args.fetch(:key_normalizer) {
+          raise ArgumentError, "Missing required key :key_normalizer"
+        }
+      end
+
+      # Public: Given a value returns it normalized for MarkLogic's sort option
+      def call(value)
+        case value
+          when Array
+            if value.size == 1 && value[0].is_a?(String)
+              normalized_sort_piece(value[0])
+            else
+              value.compact.map { |v| normalized_sort_piece(v).flatten }
+            end
+          else
+            normalized_sort_piece(value)
+        end
+      end
+
+      # Private
+      def normalized_sort_piece(value)
+        case value
+          when SymbolOperator
+            [normalized_direction(value.field, value.operator)]
+          when String
+            value.split(',').map do |piece|
+              normalized_direction(*piece.split(' '))
+            end
+          when Symbol
+            [normalized_direction(value)]
+          else
+            value
+        end
+      end
+
+      # Private
+      def normalized_direction(field, direction=nil)
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [@key_normalizer.call(field).to_s, direction]
+      end
+    end
+  end
+end

data/lib/mark_mapper/options_hash.rb

@@ -0,0 +1,103 @@
+# encoding: UTF-8
+
+require 'mark_mapper/normalizers/hash_key'
+require 'mark_mapper/normalizers/options_hash_value'
+
+module MarkMapper
+  class OptionsHash
+
+    # Private: The Hash that stores the query options
+    attr_reader :source
+
+    # Private: The Hash that stores instance options
+    attr_reader :options
+
+    # Public
+    def initialize(hash={}, options={})
+      @source = {}
+      @options = options
+      hash.each { |key, value| self[key] = value }
+    end
+
+    def initialize_copy(original)
+      super
+      @source = @source.dup
+      @source.each do |key, value|
+        self[key] = value.clone if value.duplicable?
+      end
+    end
+
+    # Public
+    def [](key)
+      @source[key]
+    end
+
+    # Public
+    def []=(key, value)
+      key = normalized_key(key)
+      @source[key] = normalized_value(key, value)
+    end
+
+    # Public
+    def keys
+      @source.keys
+    end
+
+    # Public
+    def ==(other)
+      @source == other.source
+    end
+
+    # Public
+    def to_hash
+      @source
+    end
+
+    # Public
+    def fields?
+      !self[:fields].nil?
+    end
+
+    # Public
+    def merge(other)
+      self.class.new(to_hash.merge(other.to_hash))
+    end
+
+    # Public
+    def merge!(other)
+      other.to_hash.each { |key, value| self[key] = value }
+      self
+    end
+
+    # Private
+    def normalized_key(key)
+      key_normalizer.call(key)
+    end
+
+    # Private
+    def normalized_value(key, value)
+      value_normalizer.call(key, value)
+    end
+
+    # Private
+    def key_normalizer
+      @key_normalizer ||= @options.fetch(:key_normalizer) {
+        Normalizers::HashKey.new({
+          :order  => :sort,
+          :select => :fields,
+          :offset => :skip,
+          :id     => :_id,
+        })
+      }
+    end
+
+    # Private
+    def value_normalizer
+      @value_normalizer ||= @options.fetch(:value_normalizer) {
+        Normalizers::OptionsHashValue.new({
+          :key_normalizer => key_normalizer,
+        })
+      }
+    end
+  end
+end

data/lib/mark_mapper/pagination.rb

@@ -0,0 +1,6 @@
+require 'mark_mapper/pagination/collection'
+require 'mark_mapper/pagination/paginator'
+
+module MarkMapper
+  module Pagination; end
+end

data/lib/mark_mapper/pagination/collection.rb

@@ -0,0 +1,32 @@
+require 'forwardable'
+
+module MarkMapper
+  module Pagination
+    class Collection < Array
+      extend Forwardable
+
+      def_delegators  :@paginator,
+                      :total_entries, :total_pages,
+                      :current_page,  :per_page,
+                      :previous_page, :next_page,
+                      :skip,          :limit,
+                      :offset,        :out_of_bounds?
+
+      def initialize(records, paginator)
+        replace records
+        @paginator = paginator
+      end
+
+      def method_missing(method, *args)
+        @query.send method, *args
+      end
+
+      # Public
+      def paginator(p=nil)
+        return @paginator if p.nil?
+        @paginator = p
+        self
+      end
+    end
+  end
+end

data/lib/mark_mapper/pagination/paginator.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+module MarkMapper
+  module Pagination
+    class Paginator
+      attr_reader :total_entries, :current_page, :per_page
+
+      # Public
+      def initialize(total, page, per_page=nil)
+        @total_entries = total.to_i
+        @current_page  = [page.to_i, 1].max
+        @per_page      = (per_page || 25).to_i
+      end
+
+      # Public
+      def total_pages
+        (@total_entries / @per_page.to_f).ceil
+      end
+
+      # Public
+      def out_of_bounds?
+        @current_page > total_pages
+      end
+
+      # Public
+      def previous_page
+        @current_page > 1 ? (@current_page - 1) : nil
+      end
+
+      # Public
+      def next_page
+        @current_page < total_pages ? (@current_page + 1) : nil
+      end
+
+      # Public
+      def skip
+        (@current_page - 1) * @per_page
+      end
+
+      # Public
+      alias :limit :per_page
+
+      # Public
+      alias :offset :skip
+    end
+  end
+end

data/lib/mark_mapper/plugins.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    include ActiveSupport::DescendantsTracker
+
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      raise ArgumentError,  "Plugins must extend ActiveSupport::Concern" unless ActiveSupport::Concern === mod
+      include mod
+      direct_descendants.each {|model| model.send(:include, mod) }
+      plugins << mod
+    end
+
+    def included(base = nil)
+      direct_descendants << base if base
+      super
+    end
+  end
+end

data/lib/mark_mapper/plugins/accessible.rb

@@ -0,0 +1,61 @@
+module MarkMapper
+  module Plugins
+    module Accessible
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_accessible_attributes
+      end
+
+      module ClassMethods
+        def attr_accessible(*attrs)
+          raise AccessibleOrProtected.new(name) if try(:protected_attributes?)
+          self._accessible_attributes = Set.new(attrs) + (_accessible_attributes || [])
+        end
+
+        def accessible_attributes(*)
+          _accessible_attributes
+        end
+
+        def accessible_attributes?
+          _accessible_attributes?
+        end
+      end
+
+      def attributes=(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(*args)
+        self.class.accessible_attributes(*args)
+      end
+
+      def accessible_attributes?
+        self.class.accessible_attributes?
+      end
+
+      protected
+        def filter_inaccessible_attrs(attrs)
+          return attrs if !accessible_attributes? || attrs.blank?
+          attrs.dup.delete_if { |key, val| attribute_inaccessible?(key.to_sym) }
+        end
+
+        def attribute_inaccessible?(attribute)
+          unless accessible_attributes.include?(attribute)
+            message = "Can't mass-assign protected attribute: #{attribute}"
+            MarkMapper.logger ? MarkMapper.logger.warn(message) : puts(message)
+
+            return true
+          end
+        end
+    end
+  end
+end

data/lib/mark_mapper/plugins/active_model.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      include ::ActiveModel::Conversion
+      include ::ActiveModel::Serialization
+      include ::ActiveModel::Serializers::Xml
+      include ::ActiveModel::Serializers::JSON
+
+      included do
+        extend ::ActiveModel::Naming
+        extend ::ActiveModel::Translation
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/associations.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Associations
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def inherited(subclass)
+          subclass.associations = associations.dup
+          super
+        end
+
+        def belongs_to(association_id, options={}, &extension)
+          create_association(BelongsToAssociation.new(association_id, options, &extension))
+        end
+
+        def many(association_id, options={}, &extension)
+          create_association(ManyAssociation.new(association_id, options, &extension))
+        end
+
+        def one(association_id, options={}, &extension)
+          create_association(OneAssociation.new(association_id, options, &extension))
+        end
+
+        def associations
+          @associations ||= {}
+        end
+
+        def associations=(hash)
+          @embedded_associations = nil
+          @associations = hash
+        end
+
+        def embedded_associations
+          @embedded_associations ||= associations.values.select { |assoc| assoc.embeddable? }
+        end
+
+        def associations_module_defined?
+          # :nocov:
+          if method(:const_defined?).arity == 1 # Ruby 1.9 compat check
+            const_defined?('MarkMapperAssociations')
+          else
+            const_defined?('MarkMapperAssociations', false)
+          end
+          # :nocov:
+        end
+
+        def associations_module
+          if associations_module_defined?
+            const_get 'MarkMapperAssociations'
+          else
+            Module.new.tap do |m|
+              const_set 'MarkMapperAssociations', m
+              include m
+            end
+          end
+        end
+
+        private
+          def create_association(association)
+            @embedded_associations = nil
+            associations[association.name] = association
+            association.setup(self)
+          end
+      end
+
+      def associations
+        self.class.associations
+      end
+
+      def embedded_associations
+        self.class.embedded_associations
+      end
+
+      def build_proxy(association)
+        proxy = association.proxy_class.new(self, association)
+        self.instance_variable_set(association.ivar, proxy)
+
+        proxy
+      end
+
+      def get_proxy(association)
+        proxy = self.instance_variable_get(association.ivar) if instance_variable_defined?(association.ivar)
+        proxy ||= build_proxy(association)
+      end
+
+      def save_to_collection(options={})
+        super if defined?(super)
+        associations.each do |association_name, association|
+          proxy = get_proxy(association)
+          proxy.save_to_collection(options) if proxy.proxy_respond_to?(:save_to_collection) && association.autosave?
+        end
+      end
+    end
+  end
+end