sbf-dm-core 1.3.0.beta

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

@@ -0,0 +1,33 @@
+# 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
+      # @api private
+      def reverse!
+        @operator = (@operator == :asc) ? :desc : :asc
+        self
+      end
+
+      # @api private
+      def get(resource)
+        Sort.new(target.get(resource), @operator == :asc)
+      end
+
+      # @api private
+      private def initialize(target, operator = :asc)
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# 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 DataMapper::Assertions
+      extend Equalizer
+
+      equalize :target, :operator
+
+      # @api private
+      attr_reader :target
+
+      # @api private
+      attr_reader :operator
+
+      # @api private
+      def inspect
+        "#<#{self.class.name} @target=#{target.inspect} @operator=#{operator.inspect}>"
+      end
+
+      # @api private
+      private def initialize(target, operator)
+        @target = target
+        @operator = operator.to_sym
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# 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
+      # TODO: replace this with BasicObject
+      instance_methods.each do |method|
+        next if method =~ /\A__/ ||
+                %w(send class dup object_id kind_of? instance_of? respond_to? respond_to_missing? equal? freeze frozen? should should_not
+                   instance_variables instance_variable_set instance_variable_get instance_variable_defined? remove_instance_variable extend
+                   hash inspect to_s copy_object initialize_dup).include?(method.to_s)
+
+        undef_method method
+      end
+
+      include DataMapper::Assertions
+      extend Equalizer
+
+      equalize :relationships, :property
+
+      # @api semipublic
+      attr_reader :repository_name
+
+      # @api semipublic
+      attr_reader :relationships
+
+      # @api semipublic
+      attr_reader :model
+
+      # @api semipublic
+      attr_reader :property
+
+      (Conditions::Comparison.slugs | [:not]).each do |slug|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{slug}                                                                                                      # def eql
+            #{if %i(eql in).include?(slug)
+                "raise \"explicit use of '#{slug}' operator is deprecated (#{caller.first})\""
+              end}  #   raise "explicit use of 'eql' operator is deprecated (#{caller.first})"
+            Operator.new(self, #{slug.inspect})                                                                            #   Operator.new(self, :eql)
+          end                                                                                                              # end
+        RUBY
+      end
+
+      # @api public
+      def kind_of?(klass)
+        super || (defined?(@property) ? @property.is_a?(klass) : false)
+      end
+
+      # @api public
+      def instance_of?(klass)
+        super || (defined?(@property) ? @property.instance_of?(klass) : false)
+      end
+
+      # Used for creating :order options. This technique may be deprecated,
+      # so marking as semipublic until the issue is resolved.
+      #
+      # @api semipublic
+      def asc
+        Operator.new(property, :asc)
+      end
+
+      # Used for creating :order options. This technique may be deprecated,
+      # so marking as semipublic until the issue is resolved.
+      #
+      # @api semipublic
+      def desc
+        Operator.new(property, :desc)
+      end
+
+      # @api semipublic
+      def respond_to?(method, include_private = false)
+        super ||
+          (defined?(@property) && @property.respond_to?(method, include_private)) ||
+          @model.relationships(@repository_name).named?(method)                   ||
+          @model.properties(@repository_name).named?(method)
+      end
+
+      # @api semipublic
+      private def initialize(relationships, property_name = nil)
+        @relationships = relationships.to_ary.dup
+
+        last_relationship = @relationships.last
+        @repository_name  = last_relationship.relative_target_repository_name
+        @model            = last_relationship.target_model
+
+        return unless property_name
+
+        property_name = property_name.to_sym
+        @property = @model.properties(@repository_name)[property_name] ||
+                    raise(ArgumentError, "Unknown property '#{property_name}' in #{@model}")
+      end
+
+      # @api semipublic
+      private def method_missing(method, *args)
+        return @property.send(method, *args) if @property
+
+        path_class = self.class
+
+        if (relationship = @model.relationships(@repository_name)[method])
+          return path_class.new(@relationships.dup << relationship)
+        end
+
+        return path_class.new(@relationships, method) if @model.properties(@repository_name).named?(method)
+
+        raise NoMethodError, "undefined property or relationship '#{method}' on #{@model}"
+      end
+    end
+  end
+end

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

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