mark_mapper 0.0.1

data/lib/mark_mapper/extensions/object_id.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MarkMapper
+  module Extensions
+    module ObjectId
+      def to_marklogic(value)
+        MarkMapper.to_object_id(value)
+      end
+
+      def from_marklogic(value)
+        value
+      end
+    end
+  end
+end
+
+class ObjectId
+  extend MarkMapper::Extensions::ObjectId
+end

data/lib/mark_mapper/extensions/set.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+require 'set'
+
+module MarkMapper
+  module Extensions
+    module Set
+      def to_marklogic(value)
+        value.to_a
+      end
+
+      def from_marklogic(value)
+        (value || []).to_set
+      end
+    end
+  end
+end
+
+class Set
+  extend MarkMapper::Extensions::Set
+end

data/lib/mark_mapper/extensions/string.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+module MarkMapper
+  module Extensions
+    module String
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def to_marklogic(value)
+          value && value.to_s
+        end
+
+        def from_marklogic(value)
+          value && value.to_s
+        end
+
+        def xs_type
+          "string"
+        end
+
+      end
+
+      def _mark_mapper_deep_copy_
+        self.dup
+      end
+    end
+  end
+end
+
+class String
+  include MarkMapper::Extensions::String
+end

data/lib/mark_mapper/extensions/symbol.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+module MarkMapper
+  module Extensions
+    module SymbolClassMethods
+      def to_marklogic(value)
+        value && value.to_s.to_sym
+      end
+
+      def from_marklogic(value)
+        value && value.to_s.to_sym
+      end
+    end
+
+    module SymbolnstanceMethods
+      def gt
+        SymbolOperator.new(self, 'gt')
+      end
+
+      def lt
+        SymbolOperator.new(self, 'lt')
+      end
+
+      def ge
+        SymbolOperator.new(self, 'ge')
+      end
+
+      def le
+        SymbolOperator.new(self, 'le')
+      end
+
+      def eq
+        SymbolOperator.new(self, 'eq')
+      end
+
+      def ne
+        SymbolOperator.new(self, 'ne')
+      end
+
+      def asc
+        SymbolOperator.new(self, 'asc')
+      end
+
+      def desc
+        SymbolOperator.new(self, 'desc')
+      end
+    end
+  end
+end
+
+class SymbolOperator
+  include Comparable
+
+  attr_reader :field, :operator
+
+  def initialize(field, operator)
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+
+  def <=>(other)
+    if field == other.field
+      operator <=> other.operator
+    else
+      field.to_s <=> other.field.to_s
+    end
+  end
+
+  def hash
+    field.hash + operator.hash
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def ==(other)
+    other.class == self.class && field == other.field && operator == other.operator
+  end
+
+  # def to_sym
+  #   field
+  # end
+end
+
+class Symbol
+  extend MarkMapper::Extensions::SymbolClassMethods
+  include MarkMapper::Extensions::SymbolnstanceMethods
+end

data/lib/mark_mapper/extensions/time.rb

@@ -0,0 +1,29 @@
+require 'active_support/core_ext/time/zones'
+
+# encoding: UTF-8
+module MarkMapper
+  module Extensions
+    module Time
+      def to_marklogic(value)
+        if !value || '' == value
+          nil
+        else
+          time_class = ::Time.zone || ::Time
+          time = value.is_a?(::Time) ? value : time_class.parse(value.to_s, time_class.now)
+        end
+      end
+
+      def from_marklogic(value)
+        to_marklogic(value)
+      end
+
+      def xs_type
+        "dateTime"
+      end
+    end
+  end
+end
+
+class Time
+  extend MarkMapper::Extensions::Time
+end

data/lib/mark_mapper/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  mark_mapper:
+    errors:
+      messages:
+        taken: "has already been taken"

data/lib/mark_mapper/middleware/identity_map.rb

@@ -0,0 +1,41 @@
+module MarkMapper
+  module Middleware
+    # Usage:
+    #
+    #   config.middleware.insert_after \
+    #     ActionDispatch::Callbacks,
+    #     MarkMapper::Middleware::IdentityMap
+    #
+    # You have to insert after callbacks so the entire request is wrapped.
+    class IdentityMap
+      class Body
+        extend Forwardable
+        def_delegator :@target, :each
+
+        def initialize(target, original)
+          @target   = target
+          @original = original
+        end
+
+        def close
+          @target.close if @target.respond_to?(:close)
+        ensure
+          MarkMapper::Plugins::IdentityMap.enabled = @original
+          MarkMapper::Plugins::IdentityMap.clear
+        end
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        MarkMapper::Plugins::IdentityMap.clear
+        enabled = MarkMapper::Plugins::IdentityMap.enabled
+        MarkMapper::Plugins::IdentityMap.enabled = true
+        status, headers, body = @app.call(env)
+        [status, headers, Body.new(body, enabled)]
+      end
+    end
+  end
+end

data/lib/mark_mapper/normalizers/criteria_hash_key.rb

@@ -0,0 +1,17 @@
+module MarkMapper
+  module Normalizers
+    class CriteriaHashKey
+      # Public: Returns key normalized for MarkLogic
+      #
+      # key - The key to normalize
+      #
+      # Returns key as Symbol if possible, else key with no changes
+      def call(key)
+        key = key.to_sym       if key.respond_to?(:to_sym)
+        return call(key.field) if key.respond_to?(:field)
+        return :_id            if key == :id
+        key
+      end
+    end
+  end
+end

data/lib/mark_mapper/normalizers/criteria_hash_value.rb

@@ -0,0 +1,66 @@
+module MarkMapper
+  module Normalizers
+    class CriteriaHashValue
+
+      # Internal: Used by normalized_value to determine if we need to run the
+      # value through another criteria hash to normalize it.
+      NestingOperators = [:$or, :$and, :$nor]
+
+      def initialize(criteria_hash)
+        @criteria_hash = criteria_hash
+      end
+
+      # Public: Returns value normalized for MarkLogic
+      #
+      # parent_key - The parent key if nested, otherwise same as key
+      # key - The key we are currently normalizing
+      # value - The value that should be normalized
+      #
+      # Returns value normalized for MarkLogic
+      def call(parent_key, key, value)
+        case value
+          when Array, Set
+            if nesting_operator?(key)
+              value.map  { |v| criteria_hash_class.new(v, options).to_hash }
+            elsif parent_key == key && !modifier?(key) && !value.empty?
+              # we're not nested and not the value for a symbol operator
+              {:$eq => value.to_a}
+            else
+              # we are a value for a symbol operator or nested hash
+              value.to_a
+            end
+          when Time
+            value.utc
+          when String
+            value
+          when Hash
+            value.each { |k, v| value[k] = call(key, k, v) }
+            value
+          when Regexp
+            Regexp.new(value)
+          else
+            value
+        end
+      end
+
+      # Private: Returns class of provided criteria hash
+      def criteria_hash_class
+        @criteria_hash.class
+      end
+
+      # Private: Returns options of provided criteria hash
+      def options
+        @criteria_hash.options
+      end
+
+      # Private: Returns true or false if key is a nesting operator
+      def nesting_operator?(key)
+        NestingOperators.include?(key)
+      end
+
+      def modifier?(key)
+        MarkMapper.modifier?(key)
+      end
+    end
+  end
+end

data/lib/mark_mapper/normalizers/fields_value.rb

@@ -0,0 +1,26 @@
+module MarkMapper
+  module Normalizers
+    class FieldsValue
+
+      # Public: Given a value returns it normalized for MarkLogic's fields option
+      def call(value)
+        return nil if value.respond_to?(:empty?) && value.empty?
+
+        case value
+          when Array
+            if value.size == 1 && value.first.is_a?(Hash)
+              value.first
+            else
+              value.flatten
+            end
+          when Symbol
+            [value]
+          when String
+            value.split(',').map { |v| v.strip }
+          else
+            value
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/normalizers/hash_key.rb

@@ -0,0 +1,19 @@
+module MarkMapper
+  module Normalizers
+    class HashKey
+
+      def initialize(keys)
+        @keys = keys
+      end
+
+      # Public: Normalizes an options hash key
+      #
+      # key - The key to normalize
+      #
+      # Returns a Symbol.
+      def call(key)
+        @keys.fetch key.to_sym, key
+      end
+    end
+  end
+end

data/lib/mark_mapper/normalizers/integer.rb

@@ -0,0 +1,19 @@
+module MarkMapper
+  module Normalizers
+    class Integer
+
+      # Public: Returns value coerced to integer or nil
+      #
+      # value - The value to normalize to an integer
+      #
+      # Returns an Integer or nil
+      def call(value)
+        if value.nil?
+          nil
+        else
+          value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/normalizers/options_hash_value.rb

@@ -0,0 +1,83 @@
+require 'mark_mapper/normalizers/integer'
+require 'mark_mapper/normalizers/fields_value'
+require 'mark_mapper/normalizers/sort_value'
+
+module MarkMapper
+  module Normalizers
+    class OptionsHashValue
+
+      # Public: Initialize an OptionsHashValue.
+      #
+      # args - The hash of arguments (default: {})
+      #        :key_normalizer - The key normalizer to use, must respond to call
+      #        :value_normalizers - Hash where key is name of options hash key
+      #                             to normalize and value is what should be used
+      #                             to normalize the value accordingly (must respond
+      #                             to call). Allows adding normalizers for new keys
+      #                             and overriding existing default normalizers.
+      #
+      #
+      # Examples
+      #
+      #   MarkMapper::Normalizers::OptionsHashValue.new({
+      #     :key_normalizer => lambda { |key| key}, # key normalizer must responds to call
+      #     :value_normalizers => {
+      #       :new_key => lambda { |key| key.to_s.upcase }, # add normalizer for :new_key
+      #       :fields  => lambda { |key| key }, # override normalizer for fields to one that does nothing
+      #     }
+      #   })
+      #
+      # Returns the duplicated String.
+      def initialize(args = {})
+        @key_normalizer = args.fetch(:key_normalizer) {
+          raise ArgumentError, "Missing required key :key_normalizer"
+        }
+
+        @value_normalizers = {
+          :fields => default_fields_value_normalizer,
+          :sort   => default_sort_value_normalizer,
+          :limit  => default_limit_value_normalizer,
+          :skip   => default_skip_value_normalizer,
+        }
+
+        if (value_normalizers = args[:value_normalizers])
+          @value_normalizers.update(value_normalizers)
+        end
+      end
+
+      # Public: Returns value normalized for MarkLogic
+      #
+      # key - The name of the key whose value is being normalized
+      # value - The value to normalize
+      #
+      # Returns value normalized for MarkLogic.
+      def call(key, value)
+        if (value_normalizer = @value_normalizers[key])
+          value_normalizer.call(value)
+        else
+          value
+        end
+      end
+
+      # Private
+      def default_fields_value_normalizer
+        Normalizers::FieldsValue.new
+      end
+
+      # Private
+      def default_sort_value_normalizer
+        Normalizers::SortValue.new(:key_normalizer => Normalizers::HashKey.new({:id => :_id}))
+      end
+
+      # Private
+      def default_limit_value_normalizer
+        Normalizers::Integer.new
+      end
+
+      # Private
+      def default_skip_value_normalizer
+        Normalizers::Integer.new
+      end
+    end
+  end
+end