pacer 0.9.1.1-java → 1.0.0-java

data/lib/pacer/filter/loop_filter.rb

@@ -1,6 +1,6 @@
 module Pacer
-  module Core
-    module Route
+  module Routes
+    module RouteOperations
       def loop(&block)
         chain_route :filter => :loop, :looping_route => block
       end
@@ -16,7 +16,7 @@ module Pacer
           arg.to_enum(:times).inject(self) do |route_end, count|
             yield route_end
           end
-        when Range 
+        when Range
           if arg.exclude_end?
             range = arg.begin..(arg.end - 1)
           else
@@ -36,18 +36,12 @@ module Pacer
           r.while_description = "repeat #{ arg.inspect }"
           r
         else
-          raise "Invalid repeat range"
+          fail ArgumentError, "Invalid repeat range"
         end
       end
     end
   end
 
-  module ElementMixin
-    def loop(&block)
-      chain_route :filter => :loop, :looping_route => block
-    end
-  end
-
   module Filter
     module LoopFilter
       attr_reader :looping_route
@@ -61,8 +55,7 @@ module Pacer
         end
       end
 
-      def while(yield_paths = false, &block)
-        @yield_paths = yield_paths
+      def while(&block)
         @control_block = block
         self
       end
@@ -71,8 +64,9 @@ module Pacer
 
       def attach_pipe(end_pipe)
         unless @control_block
-          raise 'No loop control block specified. Use either #while or #until after #loop.'
+          fail ClientError, 'No loop control block specified. Use either #while or #until after #loop.'
         end
+
         pipe = Pacer::Pipes::LoopPipe.new(graph, looping_pipe, @control_block)
         pipe.setStarts(end_pipe) if end_pipe
         pipe

data/lib/pacer/filter/object_filter.rb

@@ -2,30 +2,24 @@ module Pacer
   module Routes
     module RouteOperations
       def is(value)
-        if value.nil? and graph and defined? Pacer::DexGraph and graph.is_a? Pacer::DexGraph
-          # NOTE: This is a workaround for https://github.com/tinkerpop/blueprints/issues/178
-          only(value)
+        if value.is_a? Symbol
+          chain_route :filter => :property, :block => proc { |v| v.vars[value] == v }
         else
-          if value.is_a? Symbol
-            chain_route :filter => :property, :block => proc { |v| v.vars[value] == v }
-          else
-            chain_route({ :filter => :object, :value => value })
-          end
+          chain_route({ :filter => :object, :value => value })
         end
       end
 
       def is_not(value)
-        if value.nil? and graph and defined? Pacer::DexGraph and graph.is_a? Pacer::DexGraph
-          # NOTE: This is a workaround for https://github.com/tinkerpop/blueprints/issues/178
-          except(value)
+        if value.is_a? Symbol
+          chain_route :filter => :property, :block => proc { |v| v.vars[value] != v }
         else
-          if value.is_a? Symbol
-            chain_route :filter => :property, :block => proc { |v| v.vars[value] != v }
-          else
-            chain_route({ :filter => :object, :value => value, :negate => true })
-          end
+          chain_route({ :filter => :object, :value => value, :negate => true })
         end
       end
+
+      def compact
+        is_not nil
+      end
     end
   end
 

data/lib/pacer/filter/property_filter/filters.rb

@@ -1,8 +1,40 @@
 module Pacer
   module Filter
+    class KeyIndex
+      attr_reader :graph, :element_type
+
+      def initialize(graph, element_type)
+        @graph = graph
+        @element_type = element_type
+      end
+
+      # FIXME: there is no count for key indices anymore. I'm counting
+      # up to 10 elements to try to find good indices, otherwise using
+      # anything...
+      def count(key, value)
+        iter = get(key, value).iterator
+        10.times do |n|
+          if iter.hasNext
+            iter.next
+          else
+            return n
+          end
+        end
+        1_000_000 # Random high number.
+      end
+
+      def get(key, value)
+        if element_type == :vertex
+          graph.blueprints_graph.getVertices(key, value)
+        else
+          graph.blueprints_graph.getEdges(key, value)
+        end
+      end
+    end
+
     module PropertyFilter
       class Filters
-        attr_reader :properties, :extensions, :route_modules
+        attr_reader :properties, :extensions, :route_modules, :best_index_value
         attr_accessor :wrapper, :blocks
 
         # Allow Pacer to use index counts to determine which index has
@@ -25,11 +57,11 @@ module Pacer
         # @attr [Boolean] search_manual_indices
         attr_accessor :search_manual_indices
 
-        protected
+      protected
 
         attr_accessor :non_ext_props
 
-        public
+      public
 
         def initialize(filters)
           @properties = []
@@ -47,7 +79,7 @@ module Pacer
         # @note this is not threadsafe if you are reusing predefined
         #   routes on multiple graphs.
         #
-        # @attr [GraphMixin] g a graph
+        # @attr [PacerGraph] g a graph
         attr_reader :graph
 
         def graph=(g)
@@ -70,55 +102,6 @@ module Pacer
           end
         end
 
-        def add_filter(filter, extension)
-          case filter
-          when Hash
-            reset_properties
-            filter.each do |k, v|
-              self.non_ext_props << [k.to_s, v] unless extension
-              self.properties << [k.to_s, v]
-            end
-          when Module, Class
-            if filter.is_a? Class and filter.ancestors.include? Pacer::Wrappers::ElementWrapper
-              self.wrapper = filter
-            else
-              self.extensions << filter
-            end
-            if filter.respond_to? :route_conditions
-              add_filters filter.route_conditions, filter
-            end
-            if filter.respond_to? :route
-              self.route_modules << filter
-            end
-          when Array
-            add_filters(filter, extension)
-          when nil
-          else
-            raise "Unknown filter: #{ filter.class }: #{ filter.inspect }"
-          end
-        end
-
-        def add_filters(filters, extension)
-          if filters.is_a? Array
-            filters.each do |filter|
-              add_filter filter, extension
-            end
-          else
-            add_filter filters, extension
-          end
-        end
-
-        def encode_value(value)
-          value = graph.encode_property(value)
-          if value.respond_to? :to_java
-            jvalue = value.to_java
-          elsif value.respond_to? :to_java_string
-            jvalue = value.to_java_string
-          else
-            jvalue = value
-          end
-        end
-
         def build_pipeline(route, start_pipe, pipe = nil)
           self.graph = route.graph
           pipe ||= start_pipe
@@ -173,39 +156,77 @@ module Pacer
           result
         end
 
-        protected
+      protected
+
+        def add_filter(filter, extension)
+          case filter
+          when Hash
+            reset_properties
+            filter.each do |k, v|
+              self.non_ext_props << [k.to_s, v] unless extension
+              self.properties << [k.to_s, v]
+            end
+          when Module, Class
+            if filter.is_a? Class and filter.ancestors.include? Pacer::Wrappers::ElementWrapper
+              self.wrapper = filter
+            else
+              self.extensions << filter
+            end
+            if filter.respond_to? :route_conditions
+              add_filters filter.route_conditions, filter
+            end
+            if filter.respond_to? :route
+              self.route_modules << filter
+            end
+          when Array
+            add_filters(filter, extension)
+          when nil
+          else
+            if filter.respond_to? :wrapper
+              self.wrapper = filter.wrapper
+              if filter.respond_to? :route_conditions
+                add_filters filter.route_conditions, filter
+              end
+            elsif filter.respond_to? :parts
+              self.extensions.concat filter.parts.to_a
+              if filter.respond_to? :route_conditions
+                add_filters filter.route_conditions, filter
+              end
+            else
+              raise "Unknown filter: #{ filter.class }: #{ filter.inspect }"
+            end
+          end
+        end
+
+        def add_filters(filters, extension)
+          if filters.is_a? Array
+            filters.each do |filter|
+              add_filter filter, extension
+            end
+          else
+            add_filter filters, extension
+          end
+        end
+
+        def encode_value(value)
+          value = graph.encode_property(value)
+          if value.respond_to? :to_java
+            jvalue = value.to_java
+          elsif value.respond_to? :to_java_string
+            jvalue = value.to_java_string
+          else
+            jvalue = value
+          end
+        end
 
         def find_best_index(element_type)
           return @best_index if @best_index
           avail = available_indices(element_type)
           return nil if avail.empty?
           index_options = []
-          yield avail, index_options if block_given?
           properties.each do |k, v|
-            if v.is_a? Hash
-              v.each do |k2, v2|
-                if (idxs = avail["name:#{k}"]).any?
-                  if choose_best_index
-                    idxs.each do |idx|
-                      index_options << [idx.count(k2, encode_value(v2)), [idx, k2, v2], [k, v]]
-                    end
-                  else
-                    @best_index_value = [k, v]
-                    return @best_index = [idxs.first, k2, v2]
-                  end
-                end
-              end
-            elsif (idxs = (avail["key:#{k}"] + avail[:all])).any?
-              if choose_best_index
-                idxs.each do |idx|
-                  index_options << [idx.count(k, encode_value(v)), [idx, k, v], [k, v]]
-                end
-              else
-                @best_index_value = [k, v]
-                return @best_index = [idxs.first, k, v]
-              end
-            else
-              nil
+            if index_for_property(avail, index_options, k, v)
+              return @best_index
             end
           end
           index_options = index_options.sort_by do |a|
@@ -223,6 +244,32 @@ module Pacer
           @best_index
         end
 
+        def index_for_property(avail, index_options, k, v)
+          if v.is_a? Hash
+            if (idxs = avail["name:#{k}"]).any?
+              v.each do |k2, v2|
+                return true if check_index(index_options, idxs, k2.to_s, v2, [k, v])
+              end
+            end
+            false
+          elsif (idxs = (avail["key:#{k}"] + avail[:all])).any?
+            true if check_index(index_options, idxs, k, v, [k, v])
+          end
+        end
+
+        def check_index(index_options, idxs, k, v, index_value)
+          if choose_best_index
+            idxs.each do |idx|
+              index_options << [idx.count(k, encode_value(v)), [idx, k, v], index_value]
+            end
+            false
+          else
+            @best_index_value = index_value
+            @best_index = [idxs.first, k, v]
+            true
+          end
+        end
+
         def reset_properties
           @encoded_properties = nil
           if @best_index_value
@@ -243,21 +290,15 @@ module Pacer
         def available_indices(element_type)
           return @available_indices if @available_indices
           @available_indices = Hash.new { |h, k| h[k] = [] }
-          return @available_indices unless indices
-          index_class = graph.index_class(element_type)
-          indices.each do |index|
-            next unless index.index_class == index_class
-            if index.index_type == Pacer.automatic_index
-              if keys = index.getAutoIndexKeys
-                keys.each do |key|
-                  @available_indices["key:#{key}"] << index
-                end
-              else
-                @available_indices[:all] << index
-              end
-            else
+          key_index = KeyIndex.new(graph, element_type)
+          graph.key_indices(element_type).each do |key|
+            @available_indices["key:#{key}"] = [key_index]
+          end
+          if search_manual_indices
+            indices.each do |index|
+              next unless graph.index_class? element_type, index.index_class
               @available_indices["name:#{index.index_name}"] = [index]
-              @available_indices[:all] << index if search_manual_indices
+              @available_indices[:all] << index
             end
           end
           @available_indices

data/lib/pacer/filter/property_filter.rb

@@ -28,43 +28,48 @@ module Pacer
         filters.is_a? Pacer::Filter::PropertyFilter::Filters
       end
 
-      def property_filter_before(base, filters, block)
-        filters = Pacer::Route.edge_filters(filters)
+      def property_filter_before(base, args, block)
+        filters = Pacer::Route.edge_filters(args)
         filters.blocks = [block] if block
+        args = chain_args(filters)
         if filters.extensions_only? and base.is_a? Route
-          base.wrapper ||= filters.wrapper if filters.wrapper
-          base.add_extensions(filters.extensions)
-          yield base
+          yield base.chain_route(args)
         elsif filters and filters.any?
-          yield new(:back => base, :filter => :property, :filters => filters)
+          yield base.chain_route(args.merge!(filter: :property, filters: filters))
         else
           yield base
         end
       end
 
-      def property_filter(base, filters, block)
-        filters = Pacer::Route.edge_filters(filters)
+      def property_filter(base, args, block)
+        filters = Pacer::Route.edge_filters(args)
         filters.blocks = [block] if block
+        args = chain_args(filters)
         if filters.extensions_only? and base.is_a? Route
-          base.wrapper ||= filters.wrapper if filters.wrapper
-          base.add_extensions(filters.extensions)
-        elsif filters and filters.any?
-          new(:back => base, :filter => :property, :filters => filters)
-        elsif Pacer.vertex? base
-          new(:back => base, :pipe_class => Pacer::Pipes::IdentityPipe)
-        elsif Pacer.edge? base
-          new(:back => base, :pipe_class => Pacer::Pipes::IdentityPipe)
+          base.chain_route(args)
+        elsif filters.any?
+          base.chain_route(args.merge!(filter: :property, filters: filters))
+        elsif base.is_a? Pacer::Wrappers::ElementWrapper
+          base.chain_route({})
         else
           base
         end
       end
+
+      def chain_args(filters)
+        if filters.wrapper or (filters.extensions and not filters.extensions.empty?)
+          { extensions: filters.extensions, wrapper: filters.wrapper }
+        else
+          {}
+        end
+      end
     end
   end
 
   module Filter
     module PropertyFilter
       #import com.tinkerpop.pipes.filter.LabelCollectionFilterPipe
-      import com.tinkerpop.pipes.filter.PropertyFilterPipe
+      import com.tinkerpop.gremlin.pipes.filter.PropertyFilterPipe
 
       def filters=(f)
         if f.is_a? Filters
@@ -72,8 +77,6 @@ module Pacer
         else
           @filters = EdgeFilters.new(f)
         end
-        self.wrapper ||= f.wrapper if f.wrapper
-        add_extensions f.extensions
       end
 
       # Return an array of filter options for the current route.

data/lib/pacer/filter/where_filter/node_visitor.rb

@@ -7,7 +7,7 @@ module Pacer
         import com.tinkerpop.pipes.filter.AndFilterPipe
         import com.tinkerpop.pipes.filter.OrFilterPipe
         import com.tinkerpop.pipes.filter.ObjectFilterPipe
-        import com.tinkerpop.pipes.transform.PropertyPipe
+        import com.tinkerpop.gremlin.pipes.transform.PropertyPipe
         import com.tinkerpop.pipes.transform.HasCountPipe
         NeverPipe = Pacer::Pipes::NeverPipe
         IdentityPipe = Pacer::Pipes::IdentityPipe
@@ -34,11 +34,11 @@ module Pacer
           '>=' => FilterPipe::Filter::LESS_THAN_EQUAL
         )
 
-        COMPARITORS = %w[ == != > < >= <= ] 
+        COMPARATORS = %w[ == != > < >= <= ]
         METHODS = %w[ + - * / % ]
-        REGEX_COMPARITORS = %w[ =~ !~ ]
+        REGEX_COMPARATORS = %w[ =~ !~ ]
 
-        VALID_OPERATIONS = COMPARITORS + METHODS # + REGEX_COMPARITORS
+        VALID_OPERATIONS = COMPARATORS + METHODS # + REGEX_COMPARATORS
 
         class Pipe
           def initialize(pipe, *args)
@@ -118,7 +118,7 @@ module Pacer
           # TODO: support regex matches
 
           raise "Operation not supported: #{ name }" unless VALID_OPERATIONS.include? name
-          if COMPARITORS.include? name
+          if COMPARATORS.include? name
             if a.is_a? Value and b.is_a? Value
               if a.value.send name, b.value
                 Pipe.new IdentityPipe
@@ -139,11 +139,23 @@ module Pacer
               Pipe.new CrossProductTransformPipe, name, a, b
             end
           end
-        end 
+        end
+
+        def negate(pipe)
+          Pipe.new(Pipeline, pipe, Pipe.new(HasCountPipe, -1, 0), Pipe.new(ObjectFilterPipe, true, Filters['==']))
+        end
+
+        def comparable_pipe(pipe)
+          if pipe.pipe == PropertyPipe
+            build_comparison(pipe, Value.new(nil), '!=')
+          else
+            pipe
+          end
+        end
 
         def visitAndNode(node)
-          a = node.first_node.accept(self)
-          b = node.second_node.accept(self)
+          a = comparable_pipe node.first_node.accept(self)
+          b = comparable_pipe node.second_node.accept(self)
 
           if a.pipe == AndFilterPipe and b.pipe == AndFilterPipe
             Pipe.new AndFilterPipe, *a.args, *b.args
@@ -154,11 +166,11 @@ module Pacer
           else
             Pipe.new AndFilterPipe, a, b
           end
-        end 
+        end
 
         def visitArrayNode(node)
           Value.new Value.new(node.child_nodes.map { |n| n.accept self }).values!
-        end 
+        end
 
         def visitBignumNode(node)
           Value.new node.value.to_s
@@ -174,12 +186,16 @@ module Pacer
             if a.is_a? Value
               Value.new a.value.send(a.name)
             elsif a.pipe == PropertyPipe
-              Pipe.new(UnaryTransformPipe, node.name, a)
+              if node.name == '!'
+                negate(comparable_pipe(a))
+              else
+                Pipe.new(UnaryTransformPipe, node.name, a)
+              end
             else
               case node.name
               when '!'
                 # Special case for "a == 1 and not (b == 1)", etc.
-                Pipe.new(Pipeline, a, Pipe.new(HasCountPipe, -1, 0), Pipe.new(ObjectFilterPipe, true, Filters['==']))
+                negate a
               else
                 raise 'not sure'
               end
@@ -189,11 +205,11 @@ module Pacer
 
         def visitFalseNode(node)
           Pipe.new NeverPipe
-        end 
+        end
 
         def visitFixnumNode(node)
           Value.new node.value
-        end 
+        end
 
         def visitFloatNode(node)
           Value.new node.value
@@ -207,7 +223,7 @@ module Pacer
           a = Pipe.new PropertyPipe, node.name
           b = node.value_node.accept(self)
           build_comparison(a, b, '==')
-        end 
+        end
 
         def visitLocalVarNode(node)
           Pipe.new PropertyPipe, node.name
@@ -215,15 +231,16 @@ module Pacer
 
         def visitNewlineNode(node)
           node.next_node.accept(self)
-        end 
+        end
 
         def visitNilNode(node)
           Value.new nil
-        end 
+        end
 
         def visitOrNode(node)
-          a = node.first_node.accept(self)
-          b = node.second_node.accept(self)
+          a = comparable_pipe node.first_node.accept(self)
+          b = comparable_pipe node.second_node.accept(self)
+
           if a.pipe == OrFilterPipe and b.pipe == OrFilterPipe
             Pipe.new OrFilterPipe, *a.args, *b.args
           elsif a.pipe == OrFilterPipe
@@ -233,7 +250,7 @@ module Pacer
           else
             Pipe.new OrFilterPipe, a, b
           end
-        end 
+        end
 
         def visitRootNode(node)
           pipe = node.body_node.accept self
@@ -246,25 +263,29 @@ module Pacer
               Pipe.new NeverPipe
             end
           else
-            Pipe.new AndFilterPipe, pipe
+            Pipe.new AndFilterPipe, comparable_pipe(pipe)
           end
-        end 
+        end
 
         def visitStrNode(node)
           Value.new node.value
-        end 
+        end
 
         def visitSymbolNode(node)
           Value.new values.fetch(node.name.to_sym, node.name.to_sym)
-        end 
+        end
 
         def visitTrueNode(node)
           Pipe.new IdentityPipe
-        end 
+        end
 
         def visitVCallNode(node)
           Pipe.new PropertyPipe, node.name
-        end 
+        end
+
+        def visitXStrNode(node)
+          Pipe.new PropertyPipe, node.value
+        end
 
         def visitYieldNode(node)
           block = node.args_node.child_nodes.first.accept(self)

data/lib/pacer/filter/where_filter.rb

@@ -1,10 +1,27 @@
 require 'pacer/filter/where_filter/node_visitor'
+require 'jruby' # for JRuby.parse
 
 module Pacer
   module Routes
     module RouteOperations
-      def where(str, values = {})
-        chain_route :filter => :where, :where_statement => str, :values => values
+      def where(str, values = {}, *more, &block)
+        if str.is_a? String or str.is_a? Symbol
+          if str !~ /\A\s*\Z/
+            chain_route :filter => :where, :where_statement => str.to_s, :values => values
+          else
+            self
+          end
+        else
+          filter(str, values, *more, &block)
+        end
+      end
+
+      def unless(str, values = {})
+        if str and str !~ /\A\s*\Z/
+          where "not (#{str})", values
+        else
+          self
+        end
       end
     end
   end
@@ -24,7 +41,11 @@ module Pacer
       end
 
       def intermediate
-        @intermediate ||= parsed.accept(NodeVisitor.new(self, values || {}))
+        encoded_values = {}
+        if values
+          values.each { |k, v| encoded_values[k.to_sym] = graph.encode_property(v) }
+        end
+        @intermediate ||= parsed.accept(NodeVisitor.new(self, encoded_values))
       end
 
       def build!