dm-core 0.9.11 → 0.10.0

data/lib/dm-core/query/conditions/operation.rb

@@ -0,0 +1,221 @@
+module DataMapper
+  class Query
+    module Conditions
+      class InvalidOperation < ArgumentError; end
+
+      class Operation
+        # TODO: document
+        # @api semipublic
+        def self.new(slug, *operands)
+          if klass = operation_class(slug)
+            klass.new(*operands)
+          else
+            raise "No Operation class for `#{slug.inspect}' has been defined"
+          end
+        end
+
+        # TODO: document
+        # @api semipublic
+        def self.operation_class(slug)
+          operation_classes[slug] ||= AbstractOperation.descendants.detect { |operation_class| operation_class.slug == slug }
+        end
+
+        # TODO: document
+        # @api private
+        def self.slugs
+          @slugs ||= AbstractOperation.descendants.map { |operation_class| operation_class.slug }
+        end
+
+        class << self
+          private
+
+          # TODO: document
+          # @api private
+          def operation_classes
+            @operation_classes ||= {}
+          end
+        end
+      end # class Operation
+
+      class AbstractOperation
+        include Enumerable
+
+        # TODO: document
+        # @api semipublic
+        attr_reader :operands
+
+        # TODO: document
+        # @api private
+        def self.descendants
+          @descendants ||= Set.new
+        end
+
+        # TODO: document
+        # @api private
+        def self.inherited(operation_class)
+          descendants << operation_class
+        end
+
+        # TODO: document
+        # @api semipublic
+        def self.slug(slug = nil)
+          slug ? @slug = slug : @slug
+        end
+
+        # TODO: document
+        # @api semipublic
+        def each
+          @operands.each { |*block_args| yield(*block_args) }
+        end
+
+        # TODO: document
+        # @api semipublic
+        def valid?
+          operands.all? do |operand|
+            if operand.respond_to?(:valid?)
+              operand.valid?
+            else
+              true
+            end
+          end
+        end
+
+        # TODO: document
+        # @api semipublic
+        def <<(operand)
+          @operands << operand
+          self
+        end
+
+        # TODO: document
+        # @api semipublic
+        def hash
+          @operands.sort_by { |operand| operand.hash }.hash
+        end
+
+        # TODO: document
+        # @api semipublic
+        def ==(other)
+          if equal?(other)
+            return true
+          end
+
+          other_class = other.class
+
+          unless other_class.respond_to?(:slug) && other_class.slug == self.class.slug
+            return false
+          end
+
+          unless other.respond_to?(:operands)
+            return false
+          end
+
+          cmp?(other, :==)
+        end
+
+        # TODO: document
+        # @api semipublic
+        def eql?(other)
+          if equal?(other)
+            return true
+          end
+
+          unless instance_of?(other.class)
+            return false
+          end
+
+          cmp?(other, :eql?)
+        end
+
+        # TODO: document
+        # @api semipublic
+        def inspect
+          "#<#{self.class} @operands=#{@operands.inspect}>"
+        end
+
+        private
+
+        # TODO: document
+        # @api semipublic
+        def initialize(*operands)
+          @operands = operands
+        end
+
+        # TODO: document
+        # @api semipublic
+        def initialize_copy(*)
+          @operands = @operands.map { |operand| operand.dup }
+        end
+
+        # TODO: document
+        # @api private
+        def cmp?(other, operator)
+          @operands.sort_by { |operand| operand.hash }.send(operator, other.operands.sort_by { |operand| operand.hash })
+        end
+      end # class AbstractOperation
+
+      module FlattenOperation
+        # TODO: document
+        # @api semipublic
+        def <<(operand)
+          if operand.kind_of?(self.class)
+            @operands.concat(operand.operands)
+            self
+          else
+            super
+          end
+        end
+      end # module FlattenOperation
+
+      class AndOperation < AbstractOperation
+        include FlattenOperation
+
+        slug :and
+
+        # TODO: document
+        # @api semipublic
+        def matches?(record)
+          @operands.all? { |operand| operand.matches?(record) }
+        end
+      end # class AndOperation
+
+      class OrOperation < AbstractOperation
+        include FlattenOperation
+
+        slug :or
+
+        # TODO: document
+        # @api semipublic
+        def matches?(record)
+          @operands.any? { |operand| operand.matches?(record) }
+        end
+      end # class OrOperation
+
+      class NotOperation < AbstractOperation
+        slug :not
+
+        # TODO: document
+        # @api semipublic
+        def matches?(record)
+          not @operands.first.matches?(record)
+        end
+
+        # TODO: document
+        # @api semipublic
+        def <<(operand)
+          raise ArgumentError, "#{self.class} cannot have more than one operand" if @operands.size > 0
+          super
+        end
+
+        private
+
+        # TODO: document
+        # @api semipublic
+        def initialize(*operands)
+          raise InvalidOperation, "#{self.class} is a unary operator" if operands.size > 1
+          super
+        end
+      end # class NotOperation
+    end # module Conditions
+  end # class Query
+end # module DataMapper

data/lib/dm-core/query/direction.rb

@@ -0,0 +1,43 @@
+# TODO: rename this DM::Symbol::Direction
+
+# TODO: add a method to convert it into a DM::Query::Sort object, eg:
+#   operator.sort_for(model)
+
+# TODO: rename #target to #property_name
+
+# TODO: make sure Query converts this into a DM::Query::Sort object
+#   immediately and passes that down to the Adapter
+
+# TODO: remove #get method
+
+module DataMapper
+  class Query
+    class Direction < Operator
+      extend Deprecate
+
+      deprecate :property,  :target
+      deprecate :direction, :operator
+
+      # TODO: document
+      # @api private
+      def reverse!
+        @operator = @operator == :asc ? :desc : :asc
+        self
+      end
+
+      # TODO: document
+      # @api private
+      def get(resource)
+        Sort.new(target.get(resource), @operator == :asc)
+      end
+
+      private
+
+      # TODO: document
+      # @api private
+      def initialize(target, operator = :asc)
+        super
+      end
+    end # class Direction
+  end # class Query
+end # module DataMapper

data/lib/dm-core/query/operator.rb

@@ -0,0 +1,84 @@
+# TODO: rename this DM::Symbol::Operator
+
+# TODO: add a method to convert it into a DM::Query::AbstractComparison object, eg:
+#   operator.comparison_for(repository, model)
+
+# TODO: rename #target to #property_name
+
+module DataMapper
+  class Query
+    class Operator
+      include Extlib::Assertions
+
+      # TODO: document
+      # @api private
+      attr_reader :target
+
+      # TODO: document
+      # @api private
+      attr_reader :operator
+
+      # TODO: document
+      # @api private
+      def ==(other)
+        if equal?(other)
+          return true
+        end
+
+        unless other.respond_to?(:target)
+          return false
+        end
+
+        unless other.respond_to?(:operator)
+          return false
+        end
+
+        cmp?(other, :==)
+      end
+
+      # TODO: document
+      # @api private
+      def eql?(other)
+        if equal?(other)
+          return true
+        end
+
+        unless instance_of?(other.class)
+          return false
+        end
+
+        cmp?(other, :eql?)
+      end
+
+      # TODO: document
+      # @api private
+      def hash
+        @target.hash
+      end
+
+      # TODO: document
+      # @api private
+      def inspect
+        "#<#{self.class.name} @target=#{target.inspect} @operator=#{operator.inspect}>"
+      end
+
+      private
+
+      # TODO: document
+      # @api private
+      def initialize(target, operator)
+        assert_kind_of 'operator', operator, Symbol
+
+        @target   = target
+        @operator = operator
+      end
+
+      # TODO: document
+      # @api private
+      def cmp?(other, operator)
+        target.send(operator, other.target) &&
+        self.operator.send(operator, other.operator)
+      end
+    end # class Operator
+  end # class Query
+end # module DataMapper

data/lib/dm-core/query/path.rb

@@ -0,0 +1,138 @@
+# TODO: instead of an Array of Path objects, create a Relationship
+# on the fly using :through on the previous relationship, creating a
+# chain.  Query::Path could then be a thin wrapper that specifies extra
+# conditions on the Relationships, like the target property o match
+# on.
+
+module DataMapper
+  class Query
+    class Path
+      instance_methods.each { |method| undef_method method unless %w[ __id__ __send__ send class dup object_id kind_of? instance_of? respond_to? equal? should should_not instance_variable_set instance_variable_get extend hash inspect ].include?(method.to_s) }
+
+      include Extlib::Assertions
+
+      # TODO: document
+      # @api semipublic
+      attr_reader :repository_name
+
+      # TODO: document
+      # @api semipublic
+      attr_reader :relationships
+
+      # TODO: document
+      # @api semipublic
+      attr_reader :model
+
+      # TODO: document
+      # @api semipublic
+      attr_reader :property
+
+      (Conditions::Comparison.slugs | [ :not ]).each do |slug|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{slug}                                                                                                    # def eql
+            #{"warn \"explicit use of '#{slug}' operator is deprecated (#{caller[0]})\"" if slug == :eql || slug == :in} #   warn "explicit use of 'eql' operator is deprecated (#{caller[0]})"
+            Operator.new(self, #{slug.inspect})                                                                          #   Operator.new(self, :eql)
+          end                                                                                                            # end
+        RUBY
+      end
+
+      # TODO: document
+      # @api public
+      def kind_of?(klass)
+        super || (defined?(@property) && @property.kind_of?(klass))
+      end
+
+      # TODO: document
+      # @api public
+      def instance_of?(klass)
+        super || (defined?(@property) && @property.instance_of?(klass))
+      end
+
+      # TODO: document
+      # @api semipublic
+      def respond_to?(method, include_private = false)
+        super                                                                   ||
+        (defined?(@property) && @property.respond_to?(method, include_private)) ||
+        @model.relationships(@repository_name).key?(method)                     ||
+        @model.properties(@repository_name).named?(method)
+      end
+
+      # TODO: document
+      # @api semipublic
+      def ==(other)
+        if equal?(other)
+          return true
+        end
+
+        unless other.respond_to?(:relationships)
+          return false
+        end
+
+        unless other.respond_to?(:property)
+          return false
+        end
+
+        cmp?(other, :==)
+      end
+
+      # TODO: document
+      # @api semipublic
+      def eql?(other)
+        if equal?(other)
+          return true
+        end
+
+        unless instance_of?(other.class)
+          return false
+        end
+
+        cmp?(other, :eql?)
+      end
+
+      private
+
+      # TODO: document
+      # @api semipublic
+      def initialize(relationships, property_name = nil)
+        assert_kind_of 'relationships', relationships, Array
+        assert_kind_of 'property_name', property_name, Symbol, NilClass
+
+        @relationships = relationships.dup
+
+        last_relationship = @relationships.last
+        @repository_name  = last_relationship.relative_target_repository_name
+        @model            = last_relationship.target_model
+
+        if property_name
+          @property = @model.properties(@repository_name)[property_name] ||
+            raise(ArgumentError, "Unknown property '#{property_name}' in #{@model}")
+        end
+      end
+
+      # TODO: document
+      # @api private
+      def cmp?(other, operator)
+        relationships.send(operator, other.relationships) &&
+        property.send(operator, other.property)
+      end
+
+      # TODO: document
+      # @api semipublic
+      def method_missing(method, *args)
+        if @property
+          return @property.send(method, *args)
+        end
+
+        if relationship = @model.relationships(@repository_name)[method]
+          return self.class.new(@relationships.dup << relationship)
+        end
+
+        if @model.properties(@repository_name).named?(method)
+          return self.class.new(@relationships, method)
+        end
+
+        raise NoMethodError, "undefined property or relationship '#{method}' on #{@model}"
+      end
+    end # class Path
+  end # class Query
+end # module DataMapper