mark_mapper 0.0.1

data/lib/mark_mapper/plugins/protected.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+require 'set'
+
+module MarkMapper
+  module Plugins
+    module Protected
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :protected_attributes
+      end
+
+      module ClassMethods
+        def attr_protected(*attrs)
+          raise AccessibleOrProtected.new(name) if try(:accessible_attributes?)
+          self.protected_attributes = Set.new(attrs) + (protected_attributes || [])
+        end
+
+        def key(*args)
+          key = super
+          attr_protected key.name.to_sym if key.options[:protected]
+          key
+        end
+      end
+
+      def attributes=(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
+
+      def update_attributes(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
+
+      def update_attributes!(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
+
+      protected
+        def filter_protected_attrs(attrs)
+          return attrs if protected_attributes.blank? || attrs.blank?
+          attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
+        end
+    end
+  end
+end

data/lib/mark_mapper/plugins/querying.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+require 'mark_mapper/plugins/querying/decorated_markmapper_query'
+
+module MarkMapper
+  module Plugins
+    module Querying
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        extend Forwardable
+
+        def_delegators :query, *Querying::Methods
+
+        def find_by_id(id)
+          find_one(:_id => id)
+        end
+
+        def first_or_create(args)
+          first(args) || create(args.reject { |key, value| !key?(key) })
+        end
+
+        def first_or_new(args)
+          first(args) || new(args.reject { |key, value| !key?(key) })
+        end
+
+        def create(*docs)
+          initialize_each(*docs) do |doc|
+            yield doc if block_given?
+            doc.save
+          end
+        end
+
+        def create!(*docs)
+          initialize_each(*docs) do |doc|
+            yield doc if block_given?
+            doc.save!
+          end
+        end
+
+        def update(*args)
+          if args.length == 1
+            update_multiple(args[0])
+          else
+            id, attributes = args
+            update_single(id, attributes)
+          end
+        end
+
+        # @api private for now
+        def query(options={})
+          query = MarkMapper::Plugins::Querying::DecoratedMarkMapperQuery.new(collection, :transformer => transformer)
+          query.object_ids(object_id_keys)
+          query.amend(options)
+          query.model(self)
+          query
+        end
+        alias_method :scoped, :query
+
+        # @api private for now
+        def criteria_hash(criteria={})
+          MarkMapper::CriteriaHash.new(criteria, :object_ids => object_id_keys)
+        end
+
+        private
+          def transformer
+            @transformer ||= lambda { |doc| load(doc) }
+          end
+
+          def initialize_each(*docs)
+            instances = []
+            docs = [{}] if docs.blank?
+            docs.flatten.each do |attrs|
+              doc = new(attrs)
+              yield(doc)
+              instances << doc
+            end
+            instances.size == 1 ? instances[0] : instances
+          end
+
+          def update_single(id, attrs)
+            if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+              raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+            end
+
+            find(id).tap do |doc|
+              doc.update_attributes(attrs)
+            end
+          end
+
+          def update_multiple(docs)
+            unless docs.is_a?(Hash)
+              raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+            end
+
+            instances = []
+            docs.each_pair { |id, attrs| instances << update(id, attrs) }
+            instances
+          end
+      end
+
+      def save(options={})
+        options.assert_valid_keys(:validate)
+        create_or_update(options)
+      end
+
+      def save!(options={})
+        save(options) || raise(DocumentNotValid.new(self))
+      end
+
+      def destroy
+        delete
+      end
+
+      def delete
+        self.class.delete(id).tap { @_destroyed = true } if persisted?
+      end
+
+      private
+        def create_or_update(options={})
+          result = persisted? ? update(options) : create(options)
+          result != false
+        end
+
+        def create(options={})
+          save_to_collection(options.merge(:persistence_method => :insert))
+        end
+
+        def update(options={})
+          save_to_collection(options.reverse_merge(:persistence_method => :save))
+        end
+
+        def save_to_collection(options={})
+          @_new = false
+          method = options.delete(:persistence_method) || :save
+          update = to_marklogic
+
+          case method
+          when :insert
+            collection.insert(update)
+          when :save
+            collection.save(update)
+          when :update
+            update.stringify_keys!
+
+            id = update.delete("_id")
+
+            set_values = update
+            unset_values = {}
+
+            if fields_for_set = options.delete(:set_fields)
+              set_values = set_values.slice(*fields_for_set)
+            end
+
+            if fields_for_unset = options.delete(:unset_fields)
+              fields_for_unset.each do |field|
+                unset_values[field] = true
+              end
+            end
+
+            find_query = { :_id => id }
+
+            update_query = {}
+            update_query["$set"] = set_values if set_values.any?
+            update_query["$unset"] = unset_values if unset_values.any?
+
+            if update_query.any?
+              collection.update(find_query, update_query)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/mark_mapper/plugins/querying/decorated_markmapper_query.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Querying
+      Methods = MarkMapper::Methods + [:delete, :delete_all, :destroy, :destroy_all, :find!]
+
+      class DecoratedMarkMapperQuery < ::MarkMapper::Query
+        include DynamicQuerying::ClassMethods
+
+        def delete(*ids)
+          where(:_id => ids.flatten).remove
+        end
+
+        def delete_all(options = {})
+          where(options).remove
+        end
+
+        def destroy(*ids)
+          [find!(*ids.flatten.compact.uniq)].flatten.each { |doc| doc.destroy }
+        end
+
+        def destroy_all(options={})
+          find_each(options) { |document| document.destroy }
+        end
+
+        def model(model=nil)
+          return @model if model.nil?
+          @model = model
+          self
+        end
+
+        def criteria_hash
+          @model.dealias_keys super
+        end
+
+        def options_hash
+          super.tap do |options|
+            case options[:fields]
+            when Hash
+              options[:fields] = @model.dealias options[:fields]
+            when Array
+              options[:fields] = options[:fields].map do |field|
+                key = keys[field.to_s]
+                key && key.abbr || field
+              end
+            end
+          end
+        end
+
+        def find!(*ids)
+          ids = Array(ids).flatten.uniq
+          raise DocumentNotFound, "Couldn't find without an ID" if ids.size == 0
+
+          find(*ids).tap do |result|
+            if result.nil? || ids.size != Array(result).size
+              raise DocumentNotFound, "Couldn't find all of the ids (#{ids.join(',')}). Found #{Array(result).size}, but was expecting #{ids.size}"
+            end
+          end
+        end
+
+        protected
+
+          def method_missing(method, *args, &block)
+            return super unless model.respond_to?(method)
+            result = model.send(method, *args, &block)
+            if result.is_a?(MarkMapper::Query)
+              merge(result)
+            else
+              result
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/rails.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Rails
+      autoload :ActiveRecordAssociationAdapter, "mark_mapper/plugins/rails/active_record_association_adapter"
+      extend ActiveSupport::Concern
+
+      def to_param
+        id.to_s if persisted?
+      end
+
+      def to_model
+        self
+      end
+
+      def to_key
+        [id] if persisted?
+      end
+
+      def new_record?
+        new?
+      end
+
+      def read_attribute(name)
+        self[name]
+      end
+
+      def read_attribute_before_type_cast(name)
+        @__mm_pre_cast ||= {}
+        name = unalias_key name
+        if !@__mm_pre_cast.key?(name)
+          @__mm_pre_cast[name] = read_attribute(name)
+        end
+        @__mm_pre_cast[name]
+      end
+
+      def write_attribute(name, value)
+        self[name] = value
+        self[name]
+      end
+
+      def write_key(name, value)
+        name = unalias_key name
+        @__mm_pre_cast ||= {}
+        @__mm_pre_cast[name.to_s] = value
+        super
+      end
+
+      module ClassMethods
+        def has_one(*args)
+          one(*args)
+        end
+
+        def has_many(*args, &extension)
+          many(*args, &extension)
+        end
+
+        def column_names
+          unaliased_keys.keys
+        end
+
+        # Returns returns an ActiveRecordAssociationAdapter for an association. This adapter has an API that is a
+        # subset of ActiveRecord::Reflection::AssociationReflection. This allows MarkMapper to be used with the
+        # association helpers in gems like simple_form and formtastic.
+        def reflect_on_association(name)
+          ActiveRecordAssociationAdapter.for_association(associations[name]) if associations[name]
+        end
+
+        def create_accessors_for(key)
+          super do
+            define_method "#{key.name}_before_type_cast" do
+              read_attribute_before_type_cast key.name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/rails/active_record_association_adapter.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Rails
+      class ActiveRecordAssociationAdapter
+        attr_reader :klass, :macro, :name, :options
+
+        def self.for_association(association)
+          macro = case association
+          when MarkMapper::Plugins::Associations::BelongsToAssociation
+            :belongs_to
+          when MarkMapper::Plugins::Associations::ManyAssociation
+            :has_many
+          when MarkMapper::Plugins::Associations::OneAssociation
+            :has_one
+          else
+            raise "no #{name} for association of type #{association.class}"
+          end
+
+          new(association, macro)
+        end
+
+        def initialize(association, macro)
+          @klass, @name = association.klass, association.name
+          # only include compatible options
+          @options = association.options.slice(:conditions, :order)
+
+          @macro = macro
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/sci.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Sci
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveSupport::DescendantsTracker
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          super
+          if @collection_name == subclass.instance_variable_get("@collection_name")
+            key :_type, String unless key?(:_type)
+            subclass.single_collection_parent = self
+            subclass.instance_variable_set("@single_collection_inherited", true)
+          else
+            remove_key :_type
+          end
+        end
+
+        def single_collection_root
+          parent = single_collection_parent || self
+          root = parent
+
+          while parent
+            parent = parent.single_collection_parent
+            root = parent unless parent.nil?
+          end
+
+          root
+        end
+
+        def criteria_hash(criteria={})
+          if single_collection_inherited?
+            super criteria.merge(:_type => name)
+          else
+            super
+          end
+        end
+
+        def set_collection_name(name)
+          if single_collection_inherited?
+            single_collection_parent.remove_key :_type
+            single_collection_parent = nil
+            @single_collection_inherited = false
+          end
+          @collection_defined = true
+          super
+        end
+
+        def explicit_collection_defined?
+          @collection_defined == true
+        end
+
+        def single_collection_parent
+          @single_collection_parent
+        end
+
+        def single_collection_parent=(parent)
+          @single_collection_parent = parent
+        end
+
+        def single_collection_inherited?
+          !!(@single_collection_inherited ||= false)
+        end
+
+        def query(options={})
+          super.tap do |query|
+            query[:_type] = {'$eq' => [name] + descendants.map(&:name)} if single_collection_inherited?
+          end
+        end
+      end
+
+      def initialize(*args)
+        super
+        write_key :_type, self.class.name if self.class.key?(:_type)
+      end
+    end
+  end
+end