perpetuity 0.7.3 → 1.0.0.beta

data/lib/perpetuity/mongodb/index.rb

@@ -1,52 +0,0 @@
-module Perpetuity
-  class MongoDB
-    class Index
-      KEY_ORDERS = { 1 => :ascending, -1 => :descending }
-      attr_reader :collection, :attribute
-
-      def initialize klass, attribute, options={}
-        @collection = klass
-        @attribute = attribute
-        @unique = options.fetch(:unique) { false }
-        @order = options.fetch(:order) { :ascending }
-        @activated = false
-      end
-
-      def active?
-        @activated
-      end
-
-      def inactive?
-        !active?
-      end
-
-      def activate!
-        @activated = true
-      end
-
-      def unique?
-        @unique
-      end
-
-      def order
-        @order
-      end
-
-      def == other
-        hash == other.hash
-      end
-
-      def eql? other
-        self == other
-      end
-
-      def attribute_name
-        attribute.respond_to?(:name) ? attribute.name : attribute
-      end
-
-      def hash
-        "#{collection}/#{attribute_name}:#{unique?}:#{order}".hash
-      end
-    end
-  end
-end

data/lib/perpetuity/mongodb/nil_query.rb

@@ -1,11 +0,0 @@
-module Perpetuity
-  class NilQuery
-    def self.new
-      @instance ||= allocate
-    end
-
-    def to_db
-      {}
-    end
-  end
-end

data/lib/perpetuity/mongodb/query.rb

@@ -1,33 +0,0 @@
-require 'perpetuity/mongodb/query_attribute'
-require 'perpetuity/mongodb/nil_query'
-
-module Perpetuity
-  class MongoDB
-    class Query
-      attr_reader :query
-      def initialize &block
-        if block_given?
-          @query = block.call(self)
-        else
-          @query = NilQuery.new
-        end
-      end
-
-      def to_db
-        @query.to_db
-      end
-
-      def negate
-        @query.negate
-      end
-
-      def method_missing missing_method
-        QueryAttribute.new missing_method
-      end
-
-      def == other
-        query == other.query
-      end
-    end
-  end
-end

data/lib/perpetuity/mongodb/query_attribute.rb

@@ -1,66 +0,0 @@
-require 'perpetuity/mongodb/query_expression'
-
-module Perpetuity
-  class MongoDB
-    class QueryAttribute
-      attr_reader :name
-
-      def initialize name
-        @name = name
-      end
-
-      def == value
-        QueryExpression.new self, :equals, value
-      end
-
-      def < value
-        QueryExpression.new self, :less_than, value
-      end
-
-      def >= value
-        QueryExpression.new self, :gte, value
-      end
-
-      def > value
-        QueryExpression.new self, :greater_than, value
-      end
-
-      def <= value
-        QueryExpression.new self, :lte, value
-      end
-
-      def != value
-        QueryExpression.new self, :not_equal, value
-      end
-      alias :not_equal? :'!='
-
-      def =~ regexp
-        QueryExpression.new self, :matches, regexp
-      end
-
-      def in collection
-        QueryExpression.new self, :in, collection
-      end
-
-      def to_sym
-        name
-      end
-
-      def to_db
-        ((self != false) & (self != nil)).to_db
-      end
-
-      def method_missing name
-        if name.to_s == 'id'
-          name = :"#{self.name}.__metadata__.#{name}"
-        elsif name.to_s == 'klass'
-          name = :"#{self.name}.__metadata__.class"
-        else
-          name = :"#{self.name}.#{name}"
-        end
-
-        self.class.new(name)
-      end
-    end
-  end
-end

data/lib/perpetuity/mongodb/query_expression.rb

@@ -1,94 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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