datamapper-dm-core 0.9.11 → 0.10.0

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

@@ -0,0 +1,247 @@
+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
+        extend Equalizer
+
+        equalize :slug, :sorted_operands
+
+        # 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
+
+        # Return the comparison class slug
+        #
+        # @return [Symbol]
+        #   the comparison class slug
+        #
+        # @api private
+        def slug
+          self.class.slug
+        end
+
+        # TODO: document
+        # @api semipublic
+        def each
+          @operands.each { |*block_args| yield(*block_args) }
+        end
+
+        # TODO: document
+        # @api semipublic
+        def valid?
+          operands.any? && 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 inspect
+          "#<#{self.class} @operands=#{@operands.inspect}>"
+        end
+
+        # Return a list of operands in predictable order
+        #
+        # @return [Array<AbstractOperation>]
+        #   list of operands sorted in deterministic order
+        #
+        # @api private
+        def sorted_operands
+          @operands.sort_by { |operand| operand.hash }
+        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
+      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
+
+      class NullOperation < AbstractOperation
+        undef_method :<<
+
+        slug :null
+
+        # Match the record
+        #
+        # @param [Resource] record
+        #   the resource to match
+        #
+        # @return [true]
+        #   every record matches
+        #
+        # @api semipublic
+        def matches?(record)
+          true
+        end
+
+        # Test validity of the operation
+        #
+        # @return [true]
+        #   always valid
+        #
+        # @api semipublic
+        def valid?
+          true
+        end
+
+        # Treat the operation the same as nil
+        #
+        # @return [true]
+        #   should be treated as nil
+        #
+        # @api semipublic
+        def nil?
+          true
+        end
+
+        # Inspecting the operation should return the same as nil
+        #
+        # @return [String]
+        #   return the string 'nil'
+        #
+        # @api semipublic
+        def inspect
+          'nil'
+        end
+      end
+    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,42 @@
+# 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
+      extend Equalizer
+
+      equalize :target, :operator
+
+      # TODO: document
+      # @api private
+      attr_reader :target
+
+      # TODO: document
+      # @api private
+      attr_reader :operator
+
+      # 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
+    end # class Operator
+  end # class Query
+end # module DataMapper

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

@@ -0,0 +1,102 @@
+# 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
+      extend Equalizer
+
+      equalize :relationships, :property
+
+      # 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) : false)
+      end
+
+      # TODO: document
+      # @api public
+      def instance_of?(klass)
+        super || (defined?(@property) ? @property.instance_of?(klass) : false)
+      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
+
+      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 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

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

@@ -0,0 +1,45 @@
+# TODO: add #reverse and #reverse! methods
+
+module DataMapper
+  class Query
+    class Sort
+      # TODO: document
+      # @api semipublic
+      attr_reader :value
+
+      # TODO: document
+      # @api semipublic
+      def direction
+        @ascending ? :ascending : :descending
+      end
+
+      # TODO: document
+      # @api private
+      def <=>(other)
+        other_value = other.value
+
+        cmp = case
+          when @value.nil? && other_value.nil?
+            0
+          when @value.nil?
+            1
+          when other_value.nil?
+            -1
+          else
+            @value <=> other_value
+        end
+
+        @ascending ? cmp : cmp * -1
+      end
+
+      private
+
+      # TODO: document
+      # @api private
+      def initialize(value, ascending = true)
+        @value     = value
+        @ascending = ascending
+      end
+    end # class Sort
+  end # class Query
+end # module DataMapper