mark_mapper 0.0.1

data/examples/validating/embedded_docs.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require_relative '../sample_app'
+require 'pp'
+
+MarkMapper.application.create
+
+class Field
+  include MarkMapper::EmbeddedDocument
+  key :name
+  validates_presence_of :name
+end
+
+class Template
+  include MarkMapper::Document
+  key :name
+  many :fields
+
+  # This tells the template to validate all
+  # fields when validating the template.
+  validates_associated :fields
+end
+
+# Name is missing on embedded field
+template = Template.new(:fields => [Field.new])
+puts template.valid? # false
+
+# Name is present on embedded field
+template = Template.new(:fields => [Field.new(:name => 'Yay')])
+puts template.valid? # true
+
+MarkMapper.application.drop

data/lib/mark_mapper.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+require 'marklogic'
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_model'
+require "mark_mapper/railtie" if defined?(Rails)
+require 'set'
+require 'mark_mapper/criteria_hash'
+require 'mark_mapper/options_hash'
+require 'mark_mapper/query'
+require 'mark_mapper/pagination'
+
+I18n.load_path << File.expand_path('../mark_mapper/locale/en.yml', __FILE__)
+
+module MarkMapper
+  autoload :Connection,             'mark_mapper/connection'
+
+  autoload :Error,                  'mark_mapper/exceptions'
+  autoload :DocumentNotFound,       'mark_mapper/exceptions'
+  autoload :InvalidScheme,          'mark_mapper/exceptions'
+  autoload :DocumentNotValid,       'mark_mapper/exceptions'
+  autoload :AccessibleOrProtected,  'mark_mapper/exceptions'
+  autoload :InvalidKey,             'mark_mapper/exceptions'
+  autoload :NotSupported,           'mark_mapper/exceptions'
+
+  autoload :Document,               'mark_mapper/document'
+  autoload :EmbeddedDocument,       'mark_mapper/embedded_document'
+  autoload :Plugins,                'mark_mapper/plugins'
+  autoload :Translation,            'mark_mapper/translation'
+  autoload :Version,                'mark_mapper/version'
+
+  module Middleware
+    autoload :IdentityMap, 'mark_mapper/middleware/identity_map'
+  end
+
+  module Plugins
+    autoload :ActiveModel,        'mark_mapper/plugins/active_model'
+    autoload :Associations,       'mark_mapper/plugins/associations'
+    autoload :Accessible,         'mark_mapper/plugins/accessible'
+    autoload :Callbacks,          'mark_mapper/plugins/callbacks'
+    autoload :Caching,            'mark_mapper/plugins/caching'
+    autoload :Clone,              'mark_mapper/plugins/clone'
+    autoload :CounterCache,       'mark_mapper/plugins/counter_cache'
+    autoload :Dirty,              'mark_mapper/plugins/dirty'
+    autoload :Document,           'mark_mapper/plugins/document'
+    autoload :DynamicQuerying,    'mark_mapper/plugins/dynamic_querying'
+    autoload :Dumpable,           'mark_mapper/plugins/dumpable'
+    autoload :EmbeddedCallbacks,  'mark_mapper/plugins/embedded_callbacks'
+    autoload :EmbeddedDocument,   'mark_mapper/plugins/embedded_document'
+    autoload :Equality,           'mark_mapper/plugins/equality'
+    autoload :IdentityMap,        'mark_mapper/plugins/identity_map'
+    autoload :Inspect,            'mark_mapper/plugins/inspect'
+    autoload :Indexable,         'mark_mapper/plugins/indexable'
+    autoload :Keys,               'mark_mapper/plugins/keys'
+    autoload :Logger,             'mark_mapper/plugins/logger'
+    autoload :Modifiers,          'mark_mapper/plugins/modifiers'
+    autoload :Pagination,         'mark_mapper/plugins/pagination'
+    autoload :PartialUpdates,     'mark_mapper/plugins/partial_updates'
+    autoload :Persistence,        'mark_mapper/plugins/persistence'
+    autoload :Protected,          'mark_mapper/plugins/protected'
+    autoload :Querying,           'mark_mapper/plugins/querying'
+    autoload :Rails,              'mark_mapper/plugins/rails'
+    autoload :Sci,                'mark_mapper/plugins/sci'
+    autoload :Scopes,             'mark_mapper/plugins/scopes'
+    autoload :Serialization,      'mark_mapper/plugins/serialization'
+    autoload :Timestamps,         'mark_mapper/plugins/timestamps'
+    autoload :Userstamps,         'mark_mapper/plugins/userstamps'
+    autoload :Validations,        'mark_mapper/plugins/validations'
+    autoload :Touch,              'mark_mapper/plugins/touch'
+
+    module Associations
+      autoload :Base,                         'mark_mapper/plugins/associations/base'
+      autoload :Collection,                   'mark_mapper/plugins/associations/collection'
+      autoload :EmbeddedCollection,           'mark_mapper/plugins/associations/embedded_collection'
+      autoload :ManyAssociation,              'mark_mapper/plugins/associations/many_association'
+      autoload :SingleAssociation,            'mark_mapper/plugins/associations/single_association'
+      autoload :BelongsToAssociation,         'mark_mapper/plugins/associations/belongs_to_association'
+      autoload :OneAssociation,               'mark_mapper/plugins/associations/one_association'
+      autoload :ManyDocumentsProxy,           'mark_mapper/plugins/associations/many_documents_proxy'
+      autoload :BelongsToProxy,               'mark_mapper/plugins/associations/belongs_to_proxy'
+      autoload :BelongsToPolymorphicProxy,    'mark_mapper/plugins/associations/belongs_to_polymorphic_proxy'
+      autoload :ManyPolymorphicProxy,         'mark_mapper/plugins/associations/many_polymorphic_proxy'
+      autoload :ManyEmbeddedProxy,            'mark_mapper/plugins/associations/many_embedded_proxy'
+      autoload :ManyEmbeddedPolymorphicProxy, 'mark_mapper/plugins/associations/many_embedded_polymorphic_proxy'
+      autoload :ManyDocumentsAsProxy,         'mark_mapper/plugins/associations/many_documents_as_proxy'
+      autoload :OneProxy,                     'mark_mapper/plugins/associations/one_proxy'
+      autoload :OneAsProxy,                   'mark_mapper/plugins/associations/one_as_proxy'
+      autoload :OneEmbeddedProxy,             'mark_mapper/plugins/associations/one_embedded_proxy'
+      autoload :OneEmbeddedPolymorphicProxy,  'mark_mapper/plugins/associations/one_embedded_polymorphic_proxy'
+      autoload :InArrayProxy,                 'mark_mapper/plugins/associations/in_array_proxy'
+    end
+  end
+
+  extend Connection
+
+  Methods = MarkMapper::Query::DSL.instance_methods.sort.map(&:to_sym)
+
+  def self.to_object_id(value)
+    return value if value.is_a?(MarkLogic::ObjectId)
+    return nil   if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+    if MarkLogic::ObjectId.legal?(value.to_s)
+      MarkLogic::ObjectId.from_string(value.to_s)
+    else
+      value
+    end
+  end
+
+  # Private
+  ModifierString = '$'
+
+  # Internal
+  def self.modifier?(key)
+    key.to_s[0, 1] == ModifierString
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'mark_mapper', 'extensions', '*.rb')].each do |extension|
+  require extension
+end
+
+# FIXME: autoload with proxy is failing, need to investigate
+require 'mark_mapper/plugins/associations/proxy'
+
+ActiveSupport.run_load_hooks(:mark_mapper, MarkMapper)

data/lib/mark_mapper/config.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+
+module MarkMapper
+
+  # This module defines all the configuration options for MarkMapper, including the
+  # database connections.
+  module Config
+    extend self
+
+    def indexes
+      @indexes ||= []
+    end
+
+    def settings
+      @settings ||= {
+        :host => 'localhost',
+        :port => 8003,
+        :manage_port => 8002,
+        :admin_port => 8001,
+        :app_name => defined?(Rails) ? Rails::Application.subclasses.first.parent.to_s.underscore : nil,
+        :username => nil,
+        :password => nil
+      }
+    end
+
+    def application
+      @application ||=
+        begin
+          MarkLogic::Application.new(app_name,
+            :port => port,
+            :connection => MarkLogic::Connection.new(host, port))
+        end
+      yield(@application) if block_given?
+      @application
+    end
+
+    # Load the settings from a compliant mark_mapper.yml file. This can be used for
+    # easy setup with frameworks other than Rails.
+    #
+    # @example Configure MarkMapper.
+    #  MarkMapper.load!("/path/to/mark_mapper.yml")
+    #
+    # @param [ String ] path The path to the file.
+    # @param [ String, Symbol ] environment The environment to load.
+    #
+    # @since 0.0.1
+    def load!(path, environment = nil)
+      options = load_yaml(path, environment)
+      load_configuration(options) if options.present?
+    end
+
+    # From a hash of options, load all the configuration.
+    #
+    # @example Load the configuration.
+    #  config.load_configuration(options)
+    #
+    # @param [ Hash ] options The configuration options.
+    #
+    # @since 0.0.1
+    def load_configuration(options)
+      options.each_pair do |key, value|
+        if settings.has_key? key.to_sym
+          settings[key.to_sym] = value
+        else
+          raise InvalidConfigurationOption, "Invalid configuration item: #{key}"
+        end
+      end
+    end
+
+    def env_name
+      return Rails.env if defined?(Rails)
+      ENV["RACK_ENV"] || ENV["MARKMAPPER_ENV"] || raise(Errors::NoEnvironment.new)
+    end
+
+    def load_yaml(path, environment = nil)
+      env = environment ? environment.to_s : env_name
+      YAML.load(ERB.new(File.new(path).read).result)[env]
+    end
+
+    def method_missing(name, *args)
+      attr = name.to_s
+      sym = attr.delete("=").to_sym
+      if attr.include?("=")
+        settings[sym] = args.first
+      else
+        settings[sym]
+      end
+    end
+  end
+end

data/lib/mark_mapper/connection.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+require 'uri'
+
+module MarkMapper
+  module Connection
+    @@connection    = nil
+    @@database      = nil
+    @@database_name = nil
+    @@config        = nil
+
+    # @api public
+    def connection
+      @@connection ||= application.connection
+    end
+
+    def connection?
+      !!connection
+    end
+
+    # @api public
+    def connection=(new_connection)
+      @@connection = new_connection
+    end
+
+    # @api public
+    def logger
+      MarkLogic.logger
+    end
+
+    def application=(new_app)
+      @@application = new_app
+    end
+
+    def application
+      @@application
+    end
+
+    # @api public
+    def database=(name)
+      @@database = nil
+      @@database_name = name
+    end
+
+    # @api public
+    def database
+      return nil if @@database_name.blank?
+
+      @@database ||= MarkLogic::Database.new(@@database_name, connection)
+    end
+
+    def config=(hash)
+      @@config = hash
+    end
+
+    def config
+      raise 'Set config before connecting. MarkMapper.config = {...}' unless defined?(@@config)
+      @@config
+    end
+  end
+end

data/lib/mark_mapper/criteria_hash.rb

@@ -0,0 +1,194 @@
+# encoding: UTF-8
+require 'set'
+require 'mark_mapper/normalizers/criteria_hash_value'
+require 'mark_mapper/normalizers/criteria_hash_key'
+
+module MarkMapper
+  class CriteriaHash
+    # Private: The Hash that stores query criteria
+    attr_reader :source
+
+    # Private: The Hash that stores options
+    attr_reader :options
+
+    # Internal: Used to determine if criteria keys match simple id lookup.
+    SimpleIdQueryKeys = [:_id].to_set
+
+    # Internal: Used to determine if criteria keys match simple id and type
+    # lookup (for single collection inheritance).
+    SimpleIdAndTypeQueryKeys = [:_id, :_type].to_set
+
+    # Internal: Used to quickly check if it is possible that the
+    # criteria hash is simple.
+    SimpleQueryMaxSize = [SimpleIdQueryKeys.size, SimpleIdAndTypeQueryKeys.size].max
+
+    # Public
+    def initialize(hash={}, options={})
+      @source, @options = {}, options
+      hash.each { |key, value| self[key] = value }
+    end
+
+    def initialize_copy(original)
+      super
+      @options = @options.dup
+      @source  = @source.dup
+      @source.each do |key, value|
+        self[key] = value.clone if value.duplicable?
+      end
+    end
+
+    # Public
+    def [](key)
+      @source[key]
+    end
+
+    # Public
+    # The contents of this make me sad...need to clean it up
+    def []=(key, value)
+      normalized_key = normalized_key(key)
+
+      if key.is_a?(SymbolOperator)
+        operator = :"$#{key.operator}"
+        normalized_value = normalized_value(normalized_key, operator, value)
+        @source[normalized_key] ||= {}
+        @source[normalized_key][operator] = normalized_value
+      else
+        if key == :conditions
+          value.each { |k, v| self[k] = v }
+        else
+          normalized_value = normalized_value(normalized_key, normalized_key, value)
+          @source[normalized_key] = normalized_value
+        end
+      end
+    end
+
+    # Public
+    def keys
+      @source.keys
+    end
+
+    # Public
+    def ==(other)
+      @source == other.source
+    end
+
+    # Public
+    def to_hash
+      @source
+    end
+
+    # Public
+    def merge(other)
+      self.class.new hash_merge(@source, other.source)
+    end
+
+    # Public
+    def merge!(other)
+      merge(other).to_hash.each do |key, value|
+        self[key] = value
+      end
+      self
+    end
+
+    # Public: The definition of simple is querying by only _id or _id and _type.
+    # If this is the case, you can use IdentityMap in library to not perform
+    # query and instead just return from map.
+    #
+    # Returns true or false
+    def simple?
+      return false if keys.size > SimpleQueryMaxSize
+      key_set = keys.to_set
+      key_set == SimpleIdQueryKeys || key_set == SimpleIdAndTypeQueryKeys
+    end
+
+    def object_id?(key)
+      object_ids.include?(key.to_sym)
+    end
+
+    # Private
+    def object_ids
+      @options[:object_ids] ||= []
+    end
+
+    # Private
+    def object_ids=(value)
+      raise ArgumentError unless value.is_a?(Array)
+      @options[:object_ids] = value.flatten
+    end
+
+    private
+
+    # Private
+    def hash_merge(oldhash, newhash)
+      merge_compound_or_clauses!(oldhash, newhash)
+      oldhash.merge(newhash) do |key, oldval, newval|
+        old_is_hash = oldval.instance_of? Hash
+        new_is_hash = newval.instance_of? Hash
+
+        if old_is_hash && new_is_hash
+          hash_merge(oldval, newval)
+        elsif old_is_hash
+          modifier_merge(oldval, newval)
+        elsif new_is_hash
+          modifier_merge(newval, oldval)
+        else
+          merge_values_into_array(oldval, newval)
+        end
+      end
+    end
+
+    def merge_compound_or_clauses!(oldhash, newhash)
+      old_or = oldhash[:$or]
+      new_or = newhash[:$or]
+      if old_or && new_or
+        oldhash[:$and] ||= []
+        oldhash[:$and] << {:$or => oldhash.delete(:$or)}
+        oldhash[:$and] << {:$or => newhash.delete(:$or)}
+      elsif new_or && oldhash[:$and]
+        if oldhash[:$and].any? {|v| v.key? :$or }
+          oldhash[:$and] << {:$or => newhash.delete(:$or)}
+        end
+      elsif old_or && newhash[:$and]
+        if newhash[:$and].any? {|v| v.key? :$or }
+          newhash[:$and] << {:$or => oldhash.delete(:$or)}
+        end
+      end
+    end
+
+    # Private
+    def modifier_merge(hash, value)
+      if modifier_key = hash.keys.detect { |k| MarkMapper.modifier?(k) }
+        hash[modifier_key].concat( Array(value) ).uniq
+      end
+    end
+
+    # Private
+    def merge_values_into_array(value, other_value)
+      Array(value).concat(Array(other_value)).uniq
+    end
+
+    # Private
+    def normalized_key(key)
+      key_normalizer.call(key)
+    end
+
+    # Private
+    def key_normalizer
+      @key_normalizer ||= @options.fetch(:key_normalizer) {
+        Normalizers::CriteriaHashKey.new
+      }
+    end
+
+    # Private
+    def normalized_value(parent_key, key, value)
+      value_normalizer.call(parent_key, key, value)
+    end
+
+    # Private
+    def value_normalizer
+      @value_normalizer ||= @options.fetch(:value_normalizer) {
+        Normalizers::CriteriaHashValue.new(self)
+      }
+    end
+  end
+end