perpetuity-mongodb 1.0.0.beta

data/lib/perpetuity/mongodb/query_expression.rb

@@ -0,0 +1,94 @@
+require 'perpetuity/mongodb/query_union'
+require 'perpetuity/mongodb/query_intersection'
+
+module Perpetuity
+  class MongoDB
+    class QueryExpression
+      attr_accessor :attribute, :comparator, :negated, :value
+
+      def initialize attribute, comparator, value
+        @attribute = attribute
+        @comparator = comparator
+        @value = value
+        @negated = false
+
+        @attribute = @attribute.to_sym if @attribute.respond_to? :to_sym
+      end
+
+      def to_db
+        public_send @comparator
+      end
+
+      def equals
+        if @negated
+          { @attribute => { '$ne' => @value } }
+        else
+          { @attribute => @value }
+        end
+      end
+
+      def function func
+        f = { func => @value }
+
+        if @negated
+          { @attribute => { '$not' => f } }
+        else
+          { @attribute => f }
+        end
+      end
+
+      def less_than
+        function '$lt'
+      end
+
+      def lte
+        function '$lte'
+      end
+
+      def greater_than
+        function '$gt'
+      end
+
+      def gte
+        function '$gte'
+      end
+
+      def not_equal
+        function '$ne'
+      end
+
+      def in
+        function '$in'
+      end
+
+      def matches
+        if @negated
+          { @attribute => { '$not' => @value } }
+        else
+          { @attribute => @value }
+        end
+      end
+
+      def | other
+        QueryUnion.new(self, other)
+      end
+
+      def & other
+        QueryIntersection.new(self, other)
+      end
+
+      def negate
+        expr = dup
+        expr.negated = true
+        expr
+      end
+
+      def == other
+        attribute == other.attribute &&
+        comparator == other.comparator &&
+        value == other.value &&
+        negated == other.negated
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb/query_intersection.rb

@@ -0,0 +1,16 @@
+module Perpetuity
+  class MongoDB
+    class QueryIntersection
+      attr_reader :lhs, :rhs
+
+      def initialize lhs, rhs
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def to_db
+        { '$and' => [lhs.to_db, rhs.to_db] }
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb/query_union.rb

@@ -0,0 +1,16 @@
+module Perpetuity
+  class MongoDB
+    class QueryUnion
+      attr_reader :lhs, :rhs
+
+      def initialize lhs, rhs
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def to_db
+        { '$or' => [lhs.to_db, rhs.to_db] }
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb/serializer.rb

@@ -0,0 +1,174 @@
+require 'perpetuity/data_injectable'
+require 'perpetuity/reference'
+
+module Perpetuity
+  class MongoDB
+    class Serializer
+      include DataInjectable
+
+      attr_reader :mapper, :mapper_registry
+
+      def initialize(mapper)
+        @mapper = mapper
+        @class = mapper.mapped_class
+        @mapper_registry = mapper.mapper_registry
+      end
+
+      def attribute_for object, attribute_name
+        object.instance_variable_get("@#{attribute_name}")
+      end
+
+      def has_attribute? object, attribute_name
+        object.instance_variable_defined? "@#{attribute_name}"
+      end
+
+      def serialize object
+        attrs = mapper.attribute_set.map do |attrib|
+          next unless has_attribute? object, attrib.name
+
+          value = attribute_for object, attrib.name
+
+          serialized_value = if value.is_a? Reference
+            serialize_reference value
+          elsif value.is_a? Array
+            serialize_array(value, attrib.embedded?)
+          elsif mapper.data_source.can_serialize? value
+            value
+          elsif mapper_registry.has_mapper?(value.class)
+            serialize_with_foreign_mapper(value, attrib.embedded?)
+          else
+            marshal(value)
+          end
+
+          [attrib.name.to_s, serialized_value]
+        end
+
+        Hash[attrs.compact]
+      end
+
+      def serialize_changes changed, original
+        Hash[Array(serialize(changed)) - Array(serialize(original))]
+      end
+
+      def unserialize data
+        if data.is_a? Array
+          unserialize_object_array data
+        else
+          object = unserialize_object(data)
+          give_id_to object
+          object
+        end
+      end
+
+      def unserialize_object data, klass=@class
+        if data.is_a? Hash
+          object = klass.allocate
+          data.each do |attr, value|
+            inject_attribute object, attr, unserialize_attribute(value)
+          end
+          object
+        else
+          unserialize_attribute data
+        end
+      end
+
+      def unserialize_object_array objects
+        objects.map do |data|
+          object = unserialize_object data
+          give_id_to object
+          object
+        end
+      end
+
+      def unserialize_attribute data
+        return data.map { |i| unserialize_attribute i } if data.is_a? Array
+        return data unless data.is_a? Hash
+        metadata  = data.fetch("__metadata__", {})
+        marshaled = data.fetch("__marshaled__", false)
+
+        if marshaled
+          value = data.fetch("value")
+          return unmarshal(value)
+        end
+
+        if metadata.any?
+          klass = metadata['class'].split('::').inject(Kernel) do |scope, const_name|
+            scope.const_get(const_name)
+          end
+          id = metadata['id']
+
+          if id
+            Reference.new(klass, id)
+          else
+            unserialize_object(data, klass)
+          end
+        else
+          data
+        end
+      end
+
+      def serialize_with_foreign_mapper value, embedded = false
+        if embedded
+          value_mapper = mapper_registry[value.class]
+          value_serializer = Serializer.new(value_mapper)
+          attr = value_serializer.serialize(value)
+          attr.merge '__metadata__' =>  { 'class' => value.class }
+        else
+          serialize_reference(value)
+        end
+      end
+
+      def serialize_array enum, embedded
+        enum.map do |value|
+          if value.is_a? Reference
+            serialize_reference value
+          elsif value.is_a? Array
+            serialize_array(value)
+          elsif mapper.data_source.can_serialize? value
+            value
+          elsif mapper_registry.has_mapper?(value.class)
+            if embedded
+              {
+                '__metadata__' => {
+                  'class' => value.class.to_s
+                }
+              }.merge mapper_registry[value.class].serialize(value)
+            else
+              serialize_reference value
+            end
+          else
+            marshal value
+          end
+        end
+      end
+
+      def serialize_reference value
+        if value.is_a? Reference
+          reference = value
+        else
+          unless mapper.persisted? value
+            mapper_registry[value.class].insert value
+          end
+          reference = Reference.new(value.class.to_s, mapper.id_for(value))
+        end
+        {
+          '__metadata__' => {
+            'class' => reference.klass.to_s,
+            'id'    => reference.id
+          }
+        }
+      end
+
+      def marshal value
+        {
+          '__marshaled__' => true,
+          'value' => Marshal.dump(value)
+        }
+      end
+
+      def unmarshal value
+        Marshal.load(value)
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb/version.rb

@@ -0,0 +1,5 @@
+module Perpetuity
+  module Mongodb
+    VERSION = "1.0.0.beta"
+  end
+end

data/perpetuity-mongodb.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'perpetuity/mongodb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "perpetuity-mongodb"
+  spec.version       = Perpetuity::Mongodb::VERSION
+  spec.authors       = ["Jamie Gaskins"]
+  spec.email         = ["jgaskins@gmail.com"]
+  spec.description   = %q{MongoDB adapter for Perpetuity}
+  spec.summary       = %q{MongoDB adapter for Perpetuity}
+  spec.homepage      = "https://github.com/jgaskins/perpetuity-mongodb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "perpetuity", "~> 1.0.0.beta"
+  spec.add_runtime_dependency "moped"
+end

data/spec/perpetuity/mongodb/index_spec.rb

@@ -0,0 +1,44 @@
+require 'perpetuity/mongodb/index'
+
+module Perpetuity
+  class MongoDB
+    describe Index do
+      let(:attribute) { double(name: 'name') }
+      let(:index) { Index.new(Object, attribute) }
+
+      it 'is not active by default' do
+        index.should_not be_active
+      end
+
+      it 'can be activated' do
+        index.activate!
+        index.should be_active
+      end
+
+      it 'can be unique' do
+        index = Index.new(Object, attribute, unique: true)
+        index.should be_unique
+      end
+
+      it 'is not unique by default' do
+        index.should_not be_unique
+      end
+
+      describe 'index ordering' do
+        it 'can be ordered in ascending order' do
+          index = Index.new(Object, attribute, order: :ascending)
+          index.order.should be :ascending
+        end
+
+        it 'is ordered ascending by default' do
+          index.order.should be :ascending
+        end
+
+        it 'can be ordered in descending order' do
+          index = Index.new(Object, attribute, order: :descending)
+          index.order.should be :descending
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_attribute_spec.rb

@@ -0,0 +1,58 @@
+require 'perpetuity/mongodb/query_attribute'
+
+module Perpetuity
+  describe MongoDB::QueryAttribute do
+    let(:attribute) { MongoDB::QueryAttribute.new :attribute_name }
+    subject { attribute }
+
+    its(:name) { should == :attribute_name }
+
+    it 'allows checking subattributes' do
+      attribute.title.name.should == :'attribute_name.title'
+    end
+
+    it 'wraps .id subattribute in metadata' do
+      attribute.id.name.should == :'attribute_name.__metadata__.id'
+    end
+
+    it 'wraps .klass subattribute in metadata' do
+      attribute.klass.name.should == :'attribute_name.__metadata__.class'
+    end
+
+    it 'checks for equality' do
+      (attribute == 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for less than' do
+      (attribute < 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for <=' do
+      (attribute <= 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for greater than' do
+      (attribute > 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for >=' do
+      (attribute >= 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for inequality' do
+      (attribute != 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for regexp matches' do
+      (attribute =~ /value/).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for inclusion' do
+      (attribute.in [1, 2, 3]).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for its own truthiness' do
+      attribute.to_db.should == ((attribute != false) & (attribute != nil)).to_db
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_expression_spec.rb

@@ -0,0 +1,67 @@
+require 'perpetuity/mongodb/query_expression'
+
+module Perpetuity
+  describe MongoDB::QueryExpression do
+    let(:expression) { MongoDB::QueryExpression.new :attribute, :equals, :value }
+    subject { expression }
+
+    describe 'translation to Mongo expressions' do
+      it 'equality expression' do
+        expression.to_db.should == { attribute: :value }
+      end
+
+      it 'less-than expression' do
+        expression.comparator = :less_than
+        expression.to_db.should == { attribute: { '$lt' => :value } }
+      end
+
+      it 'less-than-or-equal-to expression' do
+        expression.comparator = :lte
+        expression.to_db.should == { attribute: { '$lte' => :value } }
+      end
+
+      it 'greater-than expression' do
+        expression.comparator = :greater_than
+        expression.to_db.should == { attribute: { '$gt' => :value } }
+      end
+
+      it 'greater-than-or-equal-to expression' do
+        expression.comparator = :gte
+        expression.to_db.should == { attribute: { '$gte' => :value } }
+      end
+
+      it 'not-equal' do
+        expression.comparator = :not_equal
+        expression.to_db.should == { attribute: { '$ne' => :value } }
+      end
+
+      it 'checks for inclusion' do
+        expression.comparator = :in
+        expression.to_db.should == { attribute: { '$in' => :value } }
+      end
+
+      it 'checks for regexp matching' do
+        expression.comparator = :matches
+        expression.to_db.should == { attribute: :value }
+      end
+    end
+
+    describe 'unions' do
+      let(:lhs) { MongoDB::QueryExpression.new :first, :equals, :one }
+      let(:rhs) { MongoDB::QueryExpression.new :second, :equals, :two }
+
+      it 'converts | to an $or query' do
+        (lhs | rhs).to_db.should == { '$or' => [{first: :one}, {second: :two}] }
+      end
+    end
+
+    describe 'intersections' do
+      let(:lhs) { MongoDB::QueryExpression.new :first, :equals, :one }
+      let(:rhs) { MongoDB::QueryExpression.new :second, :equals, :two }
+
+      it 'converts & to an $and query' do
+        (lhs & rhs).to_db.should == { '$and' => [{first: :one}, {second: :two}] }
+      end
+    end
+  end
+end