mark_mapper 0.0.1

data/lib/mark_mapper/plugins/keys/key.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Keys
+      class Key
+        attr_accessor :name, :type, :options, :default, :ivar, :abbr, :accessors
+
+        ID_STR = '_id'
+
+        def initialize(*args)
+          options_from_args = args.extract_options!
+          @name, @type = args.shift.to_s, args.shift
+          self.options = (options_from_args || {}).symbolize_keys
+          @dynamic     = !!options[:__dynamic]
+          @embeddable  = type.respond_to?(:embeddable?) ? type.embeddable? : false
+          @is_id       = @name == ID_STR
+          @typecast    = @options[:typecast]
+          @accessors   = Array(@options[:accessors]).compact.map &:to_s
+          @has_default  = !!options.key?(:default)
+          self.default = self.options[:default] if default?
+
+          if abbr = @options[:abbr] || @options[:alias] || @options[:field_name]
+            @abbr = abbr.to_s
+          elsif @name.match(/^[A-Z]/) and !dynamic?
+            @abbr = @name
+            @name = @name.gsub(/^([A-Z])/) {|m| m.downcase }
+            Kernel.warn "Key names may not start with uppercase letters. If your field starts " +
+                 "with an uppercase letter, use :field_name to specify the real field name. " +
+                 "Accessors called `#{@name}` have been created instead."
+          end
+          @ivar = :"@#{name}" if valid_ruby_name?
+          validate_key_name! unless dynamic? or !any_accessor?
+        end
+
+        def persisted_name
+          @abbr || @name
+        end
+
+        def ==(other)
+          @name == other.name && @type == other.type && @abbr == other.abbr
+        end
+
+        def embeddable?
+          @embeddable
+        end
+
+        def number?
+          type == Integer || type == Float
+        end
+
+        def default?
+          @has_default
+        end
+
+        def dynamic?
+          @dynamic
+        end
+
+        def get(value)
+          # Special Case: Generate default _id on access
+          value = default_value if @is_id and !value
+
+          if @typecast
+            klass = typecast_class  # Don't make this lookup on every call
+            type.from_marklogic(value).map { |v| klass.from_marklogic(v) }
+          else
+            type.from_marklogic(value)
+          end
+        end
+
+        def set(value)
+          # Avoid tap here so we don't have to create a block binding.
+          values = type.to_marklogic(value)
+          if @typecast
+            values.map { |v| typecast_class.to_marklogic(v) }
+          else
+            values
+          end
+        end
+
+        def default_value
+          return unless default?
+          if default.instance_of? Proc
+            type.to_marklogic default.call
+          else
+            # Using Marshal is easiest way to get a copy of mutable objects
+            # without getting an error on immutable objects
+            type.to_marklogic Marshal.load(Marshal.dump(default))
+          end
+        end
+
+        def valid_ruby_name?
+          !!@name.match(/\A[a-z_][a-z0-9_]*\z/i)
+        end
+
+        RESERVED_KEYS = %w( id class object_id )
+        def reserved_name?
+          RESERVED_KEYS.include?(@name)
+        end
+
+        def read_accessor?
+          any_accessor? ["read"]
+        end
+
+        def write_accessor?
+          any_accessor? ["write"]
+        end
+
+        def predicate_accessor?
+          any_accessor? ["present", "predicate", "boolean"]
+        end
+
+        def any_accessor?(arr_opt = [])
+          return true if @accessors.empty?
+          return false unless (@accessors & ["skip", "none"]).empty?
+          return !(@accessors & arr_opt).empty?
+        end
+
+        private
+          def typecast_class
+            @typecast_class ||= options[:typecast].constantize
+          end
+
+          def validate_key_name!
+            if reserved_name?
+              raise MarkMapper::InvalidKey.new("`#{@name}` is a reserved key name (did you mean to use _id?)")
+            elsif !valid_ruby_name?
+              raise MarkMapper::InvalidKey.new("`#{@name}` is not a valid key name. Keys must match [a-z][a-z0-9_]*")
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/keys/static.rb

@@ -0,0 +1,45 @@
+module MarkMapper
+  module Plugins
+    module Keys
+      module Static
+        class MissingKeyError < StandardError; end
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          attr_writer :static_keys
+
+          def static_keys
+            @static_keys || false
+          end
+        end
+
+        def read_key(name)
+          if !self.class.static_keys || self.class.key?(name)
+            super
+          else
+            raise MissingKeyError, "Tried to read the key #{name.inspect}, but no key was defined. Either define key :#{name} or set self.static_keys = false"
+          end
+        end
+
+      private
+
+        def write_key(name, value)
+          if !self.class.static_keys || self.class.key?(name)
+            super
+          else
+            raise MissingKeyError, "Tried to write the key #{name.inspect}, but no key was defined. Either define key :#{name} or set self.static_keys = false"
+          end
+        end
+
+        def load_from_database(attrs, with_cast = false)
+          return super if !self.class.static_keys || !attrs.respond_to?(:each)
+
+          attrs = attrs.select { |key, _| self.class.key?(key) }
+
+          super(attrs, with_cast)
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/logger.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Logger
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def logger
+          MarkMapper.logger
+        end
+      end
+
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/modifiers.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Modifiers
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def increment(*args)
+          modifier_update('$inc', args)
+        end
+
+        def decrement(*args)
+          criteria, keys, options = criteria_and_keys_from_args(args)
+          values, to_decrement = keys.values, {}
+          keys.keys.each_with_index { |k, i| to_decrement[k] = -values[i].abs }
+          collection.update(criteria, {'$inc' => to_decrement})
+        end
+
+        def set(*args)
+          criteria, updates, options = criteria_and_keys_from_args(args)
+          updates.each do |key, value|
+            updates[key] = keys[key.to_s].set(value) if key?(key)
+          end
+          modifier_update('$set', [criteria, updates, options])
+        end
+
+        def unset(*args)
+          if args[0].is_a?(Hash)
+            criteria, keys = args.shift, args
+            options = keys.last.is_a?(Hash) ? keys.pop : {}
+          else
+            keys, ids = args.partition { |arg| arg.is_a?(Symbol) }
+            options = ids.last.is_a?(Hash) ? ids.pop : {}
+            criteria = {:id => ids}
+          end
+
+          criteria = criteria_hash(criteria).to_hash
+          updates = keys.inject({}) { |hash, key| hash[key] = 1; hash }
+          modifier_update('$unset', [criteria, updates, options])
+        end
+
+        def push(*args)
+          modifier_update('$push', args)
+        end
+
+        def push_all(*args)
+          modifier_update('$pushAll', args)
+        end
+
+        def add_to_set(*args)
+          modifier_update('$addToSet', args)
+        end
+        alias push_uniq add_to_set
+
+        def pull(*args)
+          modifier_update('$pull', args)
+        end
+
+        def pull_all(*args)
+          modifier_update('$pullAll', args)
+        end
+
+        def pop(*args)
+          modifier_update('$pop', args)
+        end
+
+        def find_and_modify(args)
+          args[:query]  = dealias_keys(args[:query])  if args.key? :query
+          args[:update] = dealias_keys(args[:update]) if args.key? :update
+          collection.find_and_modify(args)
+        end
+
+        private
+          def modifier_update(modifier, args)
+            criteria, updates, options = criteria_and_keys_from_args(args)
+            if options
+              collection.update(criteria, {modifier => updates}, options)
+            else
+              collection.update(criteria, {modifier => updates})
+            end
+          end
+
+          def criteria_and_keys_from_args(args)
+            if args[0].is_a?(Hash)
+              criteria = args[0]
+              updates  = args[1]
+              options  = args[2]
+            else
+              criteria, (updates, options) = args.partition { |a| !a.is_a?(Hash) }
+              criteria = { :id => criteria }
+            end
+            updates = dealias_keys updates
+
+            [criteria_hash(criteria).to_hash, updates, options]
+          end
+      end
+
+      def unset(*args)
+        self.class.unset({:_id => id}, *args)
+      end
+
+      def increment(hash, options=nil)
+        self.class.increment({:_id => id}, hash, options)
+      end
+
+      def decrement(hash, options=nil)
+        self.class.decrement({:_id => id}, hash, options)
+      end
+
+      def set(hash, options=nil)
+        self.class.set({:_id => id}, hash, options)
+      end
+
+      def push(hash, options=nil)
+        self.class.push({:_id => id}, hash, options)
+      end
+
+      def push_all(hash, options=nil)
+        self.class.push_all({:_id => id}, hash, options)
+      end
+
+      def pull(hash, options=nil)
+        self.class.pull({:_id => id}, hash, options)
+      end
+
+      def pull_all(hash, options=nil)
+        self.class.pull_all({:_id => id}, hash, options)
+      end
+
+      def add_to_set(hash, options=nil)
+        self.class.push_uniq({:_id => id}, hash, options)
+      end
+      alias push_uniq add_to_set
+
+      def pop(hash, options=nil)
+        self.class.pop({:_id => id}, hash, options)
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/pagination.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Pagination
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def per_page; 25 end
+
+        def paginate(opts={})
+          query.paginate({:per_page => per_page}.merge(opts))
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/partial_updates.rb

@@ -0,0 +1,77 @@
+module MarkMapper
+  module Plugins
+    module PartialUpdates
+      extend ActiveSupport::Concern
+
+      class PartialUpdatesDisabledError < StandardError; end
+
+      included do
+        class_attribute :partial_updates
+        self.partial_updates = false
+
+        self.after_find :_reset_partial_updates_callback
+        self.after_save :_reset_partial_updates_callback
+      end
+
+      def initialize(*)
+        _reset_partial_updates_callback
+        super
+      end
+
+      def fields_for_partial_update
+        raise PartialUpdatesDisabledError if !partial_updates
+
+        Hash.new.tap do |hash|
+          attrs = _dealiased_attributes
+
+          hash[:set_fields] = Array.new.tap do |array|
+            attrs.each do |key, value|
+              if !@_last_saved_attributes.include?(key) ||
+                  @_last_saved_attributes[key] != value
+                array << key
+              end
+            end
+          end
+
+          hash[:unset_fields] = @_last_saved_attributes.keys - attrs.keys
+        end
+      end
+
+    private
+
+      def _reset_partial_updates_callback
+        _reset_attributes_for_partial_update if partial_updates
+        true
+      end
+
+      def update(options={})
+        if partial_updates
+          updates = fields_for_partial_update
+
+          set_fields = updates[:set_fields]
+          unset_fields = updates[:unset_fields]
+
+          if set_fields.any? || unset_fields.any?
+            set_fields.push("_id") if !set_fields.include?("_id")
+          end
+
+          super(options.merge({
+            :persistence_method => :update,
+            :set_fields => set_fields,
+            :unset_fields => unset_fields
+          }))
+        else
+          super
+        end
+      end
+
+      def _dealiased_attributes
+        self.class.dealias_keys(attributes)
+      end
+
+      def _reset_attributes_for_partial_update
+        @_last_saved_attributes = _dealiased_attributes._mark_mapper_deep_copy_
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/persistence.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def inherited(subclass)
+          unless subclass.embeddable?
+            subclass.connection(connection)
+            subclass.database = database
+            subclass.set_collection_name(collection_name) unless subclass.explicit_collection_defined?
+          end
+          super
+        end
+
+        def connection(marklogic_connection=nil)
+          assert_supported
+          if marklogic_connection.nil? && MarkMapper.connection?
+            @connection ||= MarkMapper.connection
+          else
+            @connection = marklogic_connection
+          end
+          @connection
+        end
+
+        def database_name
+          assert_supported
+          @database.database_name
+        end
+
+        def database=(database)
+          assert_supported
+          @database = database
+        end
+
+        def database
+          assert_supported
+          @database ||= MarkMapper.application.content_databases[0]
+        end
+
+        def set_collection_name(name)
+          assert_supported
+          @collection_name = name
+        end
+
+        def collection_name
+          assert_supported
+          @collection_name ||= begin
+            name = self.to_s.tableize.gsub(/\//, '.')
+            name = self.class.to_s.downcase if name[0] == '#'
+            name
+          end
+        end
+
+        def collection
+          assert_supported
+          database.collection(collection_name)
+        end
+
+        private
+          def assert_supported
+            @embeddable ||= embeddable?
+            if @embeddable
+              raise MarkMapper::NotSupported.new('This is not supported for embeddable documents at this time.')
+            end
+          end
+      end
+
+      def collection
+        _root_document.class.collection
+      end
+
+      def database
+        _root_document.class.database
+      end
+    end
+  end
+end