dm-ambition 1.0.0 → 1.1.0.rc1

data/lib/dm-ambition/query/filter_processor.rb

@@ -1,184 +1,95 @@
-require 'parse_tree'
-require 'parse_tree_extensions'
-require 'ruby2ruby'
-
 module DataMapper
   module Ambition
     module Query
       class FilterProcessor < SexpProcessor
         attr_reader :conditions
 
-        def initialize(binding, model, negated = false)
+        def initialize(binding, model)
           super()
 
           self.expected        = Object # allow anything for now
           self.auto_shift_type = true
           self.default_method  = :process_error
 
-          @binding    = binding
-          @model      = model
-          @receiver   = nil
-
-          @container = DataMapper::Query::Conditions::Operation.new(:and)
+          @binding = binding
+          @model   = model
 
-          if negated
-            @conditions = DataMapper::Query::Conditions::Operation.new(:not, @container)
-          else
-            @conditions = @container
-          end
+          @conditions = @container = DataMapper::Query::Conditions::Operation.new(:and)
         end
 
         def process_error(exp)
-          raise "DEBUG: calling process_#{exp.shift} with #{exp.inspect} (in process_error)"
+          raise ArgumentError, "calling process_#{exp.shift} with #{exp.inspect}"
         end
 
         def process_iter(exp)
-          call_argslist = exp.shift
-          raise "DEBUG: invalid: #{call_argslist.inspct}" if call_argslist != s(:call, nil, :proc, s(:arglist))
-
-          # get the reciever
-          @receiver = process(exp.shift)
-
-          # process the Proc body
-          result = process(exp.shift)
-
-          if result.nil?
-            raise 'DEBUG: conditions must be supplied'
-          end
-
-          unless result.equal?(@container)
-            raise "DEBUG: invalid result processing body: #{result.inspect} (expected #{@container.inspect})"
-          end
-
-          result
-        end
-
-        def process_lasgn(exp)
           exp.shift
+          @receiver = process(exp.shift)
+          process(exp.shift)
         end
 
         def process_call(exp)
-          if exp.size == 3
-            lhs      = process(exp.shift)
-            operator = exp.shift
-            rhs      = process(exp.shift)
-
-            if operator == :send
-              operator = rhs.shift
-            end
+          lhs      = process(exp.shift)
+          operator = exp.shift
+          rhs      = process(exp.shift)
 
-            if rhs.size > 1
-              raise "DEBUG: rhs.size should not be larger than 1, but was #{rhs.size}: #{rhs.inspect}"
-            else
-              rhs = rhs.first
-            end
+          while [ :send, :__send__ ].include?(operator)
+            operator = rhs.shift
+          end
 
-            if lhs.nil?
-              nil
-            else
-              evaluate_operator(operator, lhs, rhs)
-            end
+          if lhs.nil? && operator != :==
+            call_method(operator, *rhs)
           else
-            raise "DEBUG: unhandled call: #{exp.inspect}"
+            evaluate_operator(operator, lhs, rhs.shift)
           end
         end
 
         def process_and(exp)
-          parent = @container
-
-          begin
-            unless @container.kind_of?(DataMapper::Query::Conditions::AndOperation)
-              parent << @container = DataMapper::Query::Conditions::Operation.new(:and)
-            end
-
-            while sexp = exp.shift
-              process(sexp)
-            end
-          ensure
-            @container = parent
-          end
-
-          @container
+          process_connective(exp, :and)
         end
 
         def process_or(exp)
-          parent = @container
-
-          begin
-            unless @container.kind_of?(DataMapper::Query::Conditions::OrOperation)
-              parent << @container = DataMapper::Query::Conditions::Operation.new(:or)
-            end
-
-            while sexp = exp.shift
-              process(sexp)
-            end
-          ensure
-            @container = parent
-          end
-
-          @container
+          process_connective(exp, :or)
         end
 
         def process_not(exp)
-          parent = @container
-
-          begin
-            parent << @container = DataMapper::Query::Conditions::Operation.new(:not)
-            process(exp.shift)
-          ensure
-            @container = parent
-          end
-
-          @container
+          process_connective(exp, :not)
         end
 
         def process_lvar(exp)
-          var = exp.shift
-          var == @receiver ? @model : value(var)
+          lvar = exp.shift
+          lvar.equal?(@receiver) ? @receiver : eval(lvar)
         end
 
         def process_arglist(exp)
-          arglist = []
-          while sexp = exp.shift
-            arglist << process(sexp)
-          end
-          arglist
-        end
-
-        def process_colon2(exp)
-          const = process(exp.shift)
-
-          const.const_get(exp.shift)
+          process_array(exp)
         end
 
-        def process_const(exp)
-          Object.const_get(exp.shift)
+        def process_block(exp)
+          process_array(exp).last
         end
 
         def process_match3(exp)
-          rhs = process(exp.shift)
-          lhs = process(exp.shift)
+          evaluate_operator(:=~, process(exp.shift), process(exp.shift))
+        end
 
-          evaluate_operator(:=~, lhs, rhs)
+        def process_colon2(exp)
+          process(exp.shift).const_get(exp.shift)
         end
 
-        def process_array(exp)
-          array = []
-          while sexp = exp.shift
-            array << process(sexp)
-          end
-          array
+        def process_const(exp)
+          Object.const_get(exp.shift)
         end
 
-        def process_hash(exp)
-          hash = {}
-          until exp.empty?
-            key   = process(exp.shift)
-            value = process(exp.shift)
+        def process_masgn(exp)
+          vars, values = process(exp.shift), process(exp.shift)
+          vars.zip(values) { |var, value| assign_value(var, value) }
+          values
+        end
 
-            hash[key] = value
-          end
-          hash
+        def process_lasgn(exp)
+          var = exp.shift
+          return var if exp.empty?
+          assign_value(var, process(exp.shift))
         end
 
         def process_str(exp)
@@ -186,9 +97,15 @@ module DataMapper
         end
 
         def process_lit(exp)
-          literal = exp.shift
-          exp.shift  # FIXME: workaround for bug in ParseTree or SexpProcessor
-          literal
+          exp.shift
+        end
+
+        def process_ivar(exp)
+          eval(exp.shift)
+        end
+
+        def process_gvar(exp)
+          eval(exp.shift)
         end
 
         def process_true(exp)
@@ -203,158 +120,135 @@ module DataMapper
           nil
         end
 
-        def process_ivar(exp)
-          value(exp.shift)
+        def process_array(exp)
+          array = []
+          array << process(exp.shift) until exp.empty?
+          array
         end
 
-        def process_gvar(exp)
-          value(exp.shift)
+        def process_hash(exp)
+          hash = {}
+          hash[process(exp.shift)] = process(exp.shift) until exp.empty?
+          hash
         end
 
-        def evaluate_operator(operator, lhs, rhs)
-          if operator == :=~ && !lhs.kind_of?(Regexp) && !rhs.kind_of?(Regexp)
-            raise "DEBUG: when using =~ operator one side should be a Regexp"
-          end
+      private
 
-          if lhs == @model
-            if rhs.nil?
-              @model.properties[operator]
-            elsif rhs.kind_of?(DataMapper::Resource) && operator == :==
-              resource = rhs
+        def process_connective(exp, operation)
+          parent, @container = @container, DataMapper::Query::Conditions::Operation.new(operation)
+          process(exp.shift) until exp.empty?
+          parent << @container
+        ensure
+          @container = parent
+        end
 
-              if resource.repository == DataMapper.repository &&
-                resource.saved? &&
-                !resource.dirty? &&
-                (key = resource.key).all?
+        def evaluate_operator(operator, lhs, rhs)
+          if    lhs.equal?(@receiver)              then evaluate_receiver_source(operator, lhs, rhs)
+          elsif rhs.equal?(@receiver)              then evaluate_receiver_target(operator, lhs, rhs)
+          elsif lhs.kind_of?(DataMapper::Property) then evaluate_property_source(operator, lhs, rhs)
+          elsif rhs.kind_of?(DataMapper::Property) then evaluate_property_target(operator, lhs, rhs)
+          else
+            lhs.send(operator, *Array(rhs))
+          end
+        end
 
-                @model.key.zip(key) do |property, bind_value|
-                  @container << DataMapper::Query::Conditions::Comparison.new(:eql, property, bind_value)
-                end
+        def evaluate_receiver_source(operator, lhs, rhs)
+          if rhs.nil? && @model.properties.named?(operator)
+            @model.properties[operator]
+          else
+            resources = operator == :== ? [ rhs ] : []
+            key       = @model.key
+            add_condition(DataMapper::Query.target_conditions(resources, key, key))
+          end
+        end
 
-                @container
+        def evaluate_receiver_target(operator, lhs, rhs)
+          resources = case lhs
+            when Hash
+              case operator
+                when :key?, :has_key?, :include?, :member? then lhs.keys.sort
+                when :value?, :has_value?                  then lhs.values.sort
+              end
+            when Enumerable
+              case operator
+                when :include?, :member? then lhs
+              end
+            when Resource
+              case operator
+                when :==, :eql? then lhs
               end
             else
-              raise "DEBUG: cannot call #{@model.name}.#{operator} with #{rhs.inspect}"
-            end
-
-          elsif rhs == @model
-            if @model.key.size > 1
-              raise 'Until OR conditions are added can only match resources with single keys'
-            end
-
-            resources = case lhs
-              when Array
-                case operator
-                  when :include?, :member? then lhs
-                end
-
-              when Hash
-                case operator
-                  when :key?, :has_key?, :include?, :member? then lhs.keys
-                  when :value?, :has_value?                  then lhs.values
-                end
-            end
-
-            unless resources
-              raise "DEBUG: cannot call #{lhs.class}##{operator} with #{rhs.inspect}"
-            end
-
-            unless resources.all? { |r| r.kind_of?(DataMapper::Resource) }
-              raise 'cannot compare against a non-resource'
-            end
-
-            property   = @model.key.first
-            bind_value = resources.map { |r| r.key.first }.sort
-
-            evaluate_operator(:include?, bind_value, property)
-
-          elsif lhs.kind_of?(DataMapper::Property)
-            property   = lhs
-            bind_value = rhs
-
-            # TODO: throw an exception if the operator is :== and the value is an Array
-            #   - this prevents conditions like { |u| u.val == [ 1, 2, 3 ] }
-
-            if operator == :nil? && bind_value.nil?
-              operator   = :==
-              bind_value = nil
-            end
-
-            operator = remap_operator(operator)
-
-            @container << DataMapper::Query::Conditions::Comparison.new(operator, property, bind_value)
-            @container
-
-          elsif rhs.kind_of?(DataMapper::Property)
-            property   = rhs
-            bind_value = lhs
-
-            # TODO: throw an exception if the operator is :== and the bind value is an Array
-            #   - this prevents conditions like { |u| [ 1, 2, 3 ] == u.val }
-
-            case bind_value
-              when Array
-                case operator
-                  when :include?, :member?
-                    operator = :in
-                  else
-                    raise "DEBUG: cannot call Array##{operator} with #{bind_value.inspect}"
-                end
-
-              when Range
-                case operator
-                  when :include?, :member?, :===
-                    operator = :in
-                  else
-                    raise "DEBUG: cannot call Range##{operator} with #{bind_value.inspect}"
-                end
-
-              when Hash
-                case operator
-                  when :key?, :has_key?, :include?, :member?
-                    operator   = :in
-                    bind_value = bind_value.keys
-                  when :value?, :has_value?
-                    operator   = :in
-                    bind_value = bind_value.values
-                  else
-                    raise "DEBUG: cannot call Hash##{operator} with #{bind_value.inspect}"
-                end
-            end
-
-            operator = remap_operator(operator)
-
-            @container << DataMapper::Query::Conditions::Comparison.new(operator, property, bind_value)
-            @container
-
-          elsif lhs.respond_to?(operator)
-            lhs.send(operator, *[ rhs ].compact)
+              []
+          end
 
-          else
-            raise "DEBUG: not handled: #{lhs.inspect} #{operator} #{rhs.inspect}"
+          key = @model.key
+          add_condition(DataMapper::Query.target_conditions(resources, key, key))
+        end
+
+        def evaluate_property_source(operator, lhs, rhs)
+          operator = operator == :nil? ? :eql : remap_operator(operator)
+          add_condition(DataMapper::Query::Conditions::Comparison.new(operator, lhs, rhs))
+        end
+
+        def evaluate_property_target(operator, lhs, rhs)
+          bind_value = lhs
 
+          operator = case bind_value
+            when Hash
+              case operator
+                when :key?, :has_key?, :include?, :member?
+                  bind_value = bind_value.keys.sort
+                  :in
+                when :value?, :has_value?
+                  bind_value = bind_value.values.sort
+                  :in
+              end
+            when Range
+              case operator
+                when :include?, :member?, :===
+                  :in
+              end
+            when Enumerable
+              case operator
+                when :include?, :member?
+                  bind_value = bind_value.sort
+                  :in
+              end
+            else
+              remap_operator(operator)
           end
+
+          add_condition(DataMapper::Query::Conditions::Comparison.new(operator, rhs, bind_value))
         end
 
-        # TODO: update dm-core internals to use the Ruby operators
-        # insted of the DM specific ones
         def remap_operator(operator)
           # remap Ruby to DM operators
           case operator
-            when :in then :in
             when :== then :eql
             when :=~ then :regexp
             when :>  then :gt
             when :>= then :gte
             when :<  then :lt
             when :<= then :lte
-            else raise "DEBUG: unknown operator #{operator}"
           end
         end
 
-        def value(value)
-          eval(value.to_s, @binding)
+        def eval(value, binding = @binding)
+          super(value.to_s, binding)
+        end
+
+        def call_method(name, *args)
+          eval("method(#{name.inspect})").call(*args)
         end
+
+        def assign_value(var, value)
+          eval("#{var} = #{value.inspect}")
+        end
+
+        def add_condition(condition)
+          @container << condition
+        end
+
       end # class FilterProcessor
     end # module Query
   end # module Ambition

data/lib/dm-ambition/query.rb

@@ -5,19 +5,18 @@ module DataMapper
 
       # TODO: spec and document this
       # @api semipublic
-      def filter(negated = false, &block)
+      def filter(&block)
         # TODO: benchmark Marshal versus just building the sexp on demand
 
         # deep clone the sexp for multiple re-use
         sexp = Marshal.load(@@sexps[block.to_s] ||= Marshal.dump(block.to_sexp))
 
-        processor = FilterProcessor.new(block.binding, model, negated)
+        processor = FilterProcessor.new(block.binding, model)
         processor.process(sexp)
 
-        merge(:conditions => processor.conditions)
+        self.class.new(repository, model, options.merge(:conditions => conditions & processor.conditions))
       end
+
     end # module Query
   end # module Ambition
 end # module DataMapper
-
-require Pathname(__FILE__).dirname.expand_path / 'query' / 'filter_processor'

data/lib/dm-ambition/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Ambition
-    VERSION = '1.0.0'
+    VERSION = '1.1.0.rc1'
   end
 end

data/lib/dm-ambition.rb

@@ -1,6 +1,13 @@
+require 'dm-core'
+require 'sourcify'
+require 'ruby2ruby'
+
 require 'dm-ambition/collection'
 require 'dm-ambition/model'
+
 require 'dm-ambition/query'
+require 'dm-ambition/query/filter_processor'
+
 require 'dm-ambition/version'
 
 module DataMapper