pacer 0.9.1.1-java

data/lib/pacer/filter/empty_filter.rb

@@ -0,0 +1,70 @@
+module Pacer
+  class Route
+    class << self
+      # This method is useful for creating sideline routes that branch
+      # off of the current route.
+      #
+      # It creates a new route without any source based on the type,
+      # filters, function and extensions of the given route. The main
+      # thing about the returned route is that the pipeline that is
+      # built from it will not include any of the pipes that make up
+      # the route it's based on.
+      #
+      # @param [Route] back the route the new route is based on.
+      # @return [Route]
+      def empty(back)
+        Pacer::Route.new :filter => :empty, :back => back
+      end
+
+      def block_branch(back, block, branch_start = nil)
+        if block.arity == 0
+          route = block.call rescue nil
+        else
+          unless branch_start
+            if back.is_a? Pacer::Graph 
+              branch_start = back
+            else
+              branch_start = Pacer::Route.empty(back)
+            end
+          end
+          route = block.call(branch_start) rescue nil
+        end
+        if route == branch_start
+          identity_branch(back).route
+        elsif route.is_a? Pacer::Route
+          route.route
+        else
+          empty(back).map(&block).route
+        end
+      end
+
+      def identity_branch(back)
+        Pacer::Route.empty(back).chain_route(:pipe_class => Pacer::Pipes::IdentityPipe,
+                                             :route_name => '@').route
+      end
+
+    end
+  end
+
+
+  module Filter
+    module EmptyFilter
+      protected
+
+      def after_initialize
+        @back = @source = nil
+        super
+      end
+
+      def build_pipeline
+        nil
+      end
+
+      def inspect_class_name
+        s = "#{element_type.to_s.scan(/Elem|Obj|V|E/).last}"
+        s = "#{s} #{ @info }" if @info
+        s
+      end
+    end
+  end
+end

data/lib/pacer/filter/future_filter.rb

@@ -0,0 +1,68 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def lookahead(opts = {}, &block)
+        chain_route({ :filter => :future, :block => block }.merge(opts))
+      end
+
+      def neg_lookahead(opts = {}, &block)
+        chain_route({ :filter => :future, :neg_block => block }.merge(opts))
+      end
+    end
+  end
+
+  module Filter
+    module FutureFilter
+      import com.tinkerpop.pipes.filter.FutureFilterPipe
+
+      attr_accessor :min, :max
+
+      def block=(block)
+        @future_filter = [block, true]
+      end
+
+      def neg_block=(block)
+        @future_filter = [block, false]
+      end
+
+      protected
+
+      def after_initialize
+        @future_filter = nil unless defined? @future_filter
+        @route = nil unless defined? @route
+        super
+      end
+
+      def attach_pipe(end_pipe)
+        pipe = FutureFilterPipe.new(lookahead_pipe)
+        pipe.set_starts(end_pipe) if end_pipe
+        pipe
+      end
+
+      def lookahead_route
+        if @future_filter
+          block, has_elements = @future_filter
+          @future_filter = nil
+          route = block.call(Pacer::Route.empty(self))
+          if min or max
+            route = route.has_count_route(:min => min, :max => max).is(true)
+          end
+          unless has_elements
+            route = route.chain_route(:element_type => :object, :pipe_class => Pacer::Pipes::IsEmptyPipe, :route_name => 'negate')
+          end
+          @route = route
+        elsif @route
+          @route
+        end
+      end
+
+      def lookahead_pipe
+        Pacer::Route.pipeline(lookahead_route)
+      end
+
+      def inspect_string
+        "#{ inspect_class_name }(#{ lookahead_route.inspect })"
+      end
+    end
+  end
+end

data/lib/pacer/filter/index_filter.rb

@@ -0,0 +1,30 @@
+module Pacer
+  module Filter
+    module IndexFilter
+      attr_accessor :index, :key, :value
+
+      def count
+        if @index and @key and @value
+          if @index.respond_to? :count
+            @index.count(@key, graph.encode_property(@value))
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      protected
+
+      def source_iterator
+        src = index.get(key, graph.encode_property(value)) || java.util.ArrayList.new
+        src.iterator
+      end
+
+      def inspect_string
+        "#{ inspect_class_name }(#{ key }: #{value.inspect})"
+      end
+    end
+  end
+end

data/lib/pacer/filter/loop_filter.rb

@@ -0,0 +1,95 @@
+module Pacer
+  module Core
+    module Route
+      def loop(&block)
+        chain_route :filter => :loop, :looping_route => block
+      end
+
+      # Apply the given path fragment multiple times in succession. If a Range
+      # or Array of numbers is given, the results are a combination of the
+      # results from all of the specified repetition levels. That is useful if
+      # a pattern may be nested to varying depths.
+      def repeat(arg, &block)
+        case arg
+        when Fixnum
+          range = arg..arg
+          arg.to_enum(:times).inject(self) do |route_end, count|
+            yield route_end
+          end
+        when Range 
+          if arg.exclude_end?
+            range = arg.begin..(arg.end - 1)
+          else
+            range = arg
+          end
+          r = self.loop(&block).while do |e, depth, p|
+            if depth < range.begin
+              :loop
+            elsif depth < range.end
+              :loop_and_emit
+            elsif depth == range.end
+              :emit
+            else
+              false
+            end
+          end
+          r.while_description = "repeat #{ arg.inspect }"
+          r
+        else
+          raise "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
+      attr_accessor :while_description
+
+      def looping_route=(route)
+        if route.is_a? Proc
+          @looping_route = Pacer::Route.block_branch(self, route)
+        else
+          @looping_route = route
+        end
+      end
+
+      def while(yield_paths = false, &block)
+        @yield_paths = yield_paths
+        @control_block = block
+        self
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        unless @control_block
+          raise '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
+      end
+
+      def looping_pipe
+        Pacer::Route.pipeline(looping_route)
+      end
+
+      def inspect_string
+        s = "#{ inspect_class_name }(#{ @looping_route.inspect })"
+        if while_description
+          "#{ s }(#{ while_description })"
+        else
+          s
+        end
+      end
+    end
+  end
+end

data/lib/pacer/filter/object_filter.rb

@@ -0,0 +1,55 @@
+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)
+        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
+        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)
+        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
+        end
+      end
+    end
+  end
+
+  module Filter
+    module ObjectFilter
+      import com.tinkerpop.pipes.filter.ObjectFilterPipe
+
+      attr_accessor :value, :negate
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = ObjectFilterPipe.new(value, negate ? Pacer::Pipes::NOT_EQUAL : Pacer::Pipes::EQUAL)
+        pipe.set_starts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        if negate
+          "is_not(#{ value.inspect })"
+        else
+          "is(#{ value.inspect })"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module Pacer
+  module Filter
+    module PropertyFilter
+      class EdgeFilters < Filters
+        attr_accessor :labels
+
+        protected
+
+        attr_accessor :non_ext_labels
+
+        public
+
+        def initialize(filters)
+          @best_index = nil
+          self.labels = []
+          self.non_ext_labels = []
+          super
+        end
+
+        def add_filter(filter, extension)
+          case filter
+          when String, Symbol
+            reset_properties
+            self.non_ext_labels << filter
+            self.labels << filter.to_s
+          else
+            super
+          end
+        end
+
+        def build_pipeline(route, start_pipe = nil, pipe = nil)
+          pipe ||= start_pipe
+          if labels.any?
+            label_pipe = Pacer::Pipes::LabelCollectionFilterPipe.new labels
+            label_pipe.set_starts pipe if pipe
+            Pacer.debug_pipes << { :name => labels.inspect, :start => pipe, :end => block_pipe } if Pacer.debug_pipes
+            pipe = label_pipe
+            start_pipe ||= pipe
+          end
+          super(route, start_pipe, pipe)
+        end
+
+        def any?
+          labels.any? or super
+        end
+
+        def to_s
+          if labels.any?
+            [labels.map { |l| l.to_sym.inspect }.join(', '), super].reject { |s| s == '' }.join ', '
+          else
+            super
+          end
+        end
+
+        def best_index(route)
+          index, key, value = find_best_index(route)
+          if key == 'label'
+            labels.delete value
+          end
+          super
+        end
+
+        protected
+
+        def reset_properties
+          @encoded_properties = nil
+          if @best_index
+            # put removed index label back...
+            i, k, v = @best_index
+            labels << v if k == 'label'
+          end
+          super
+        end
+
+        def find_best_index(route)
+          super do |avail, index_options|
+            labels.each do |label|
+              if idxs = avail["key:label"]
+                if choose_best_index
+                  idxs.each do |idx|
+                    index_options << [idx.count('label', label), idx, k, v]
+                  end
+                else
+                  return @best_index = [idxs.first, 'label', label]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,269 @@
+module Pacer
+  module Filter
+    module PropertyFilter
+      class Filters
+        attr_reader :properties, :extensions, :route_modules
+        attr_accessor :wrapper, :blocks
+
+        # Allow Pacer to use index counts to determine which index has
+        # the least number elements for the available keys in the query.
+        #
+        # @attr [Boolean] choose_best_index
+        attr_accessor :choose_best_index
+
+        # Allow Pacer to use manual indices without explicitly
+        # referencing them by name.
+        #
+        # @example Explicit manual index:
+        #
+        #   graph.v(:index_name => { :index_key => value })
+        #
+        # @example Non-explicit index lookup:
+        #
+        #   graph.v(:index_key => value)
+        #
+        # @attr [Boolean] search_manual_indices
+        attr_accessor :search_manual_indices
+
+        protected
+
+        attr_accessor :non_ext_props
+
+        public
+
+        def initialize(filters)
+          @properties = []
+          @blocks = []
+          @extensions = []
+          @wrapper = nil
+          @route_modules = []
+          @non_ext_props = []
+          @best_index_value = nil
+          add_filters filters, nil
+        end
+
+        # Set which graph this filter is currently operating on
+        #
+        # @note this is not threadsafe if you are reusing predefined
+        #   routes on multiple graphs.
+        #
+        # @attr [GraphMixin] g a graph
+        attr_reader :graph
+
+        def graph=(g)
+          if graph != g
+            reset_properties
+            @graph = g
+          end
+        end
+
+        # Set which indices are available to be used to determine the
+        # best_index.
+        #
+        # @attr [Array<Pacer::IndexMixin>] i an array of indices
+        attr_reader :indices
+
+        def indices=(i)
+          if indices != i
+            reset_properties
+            @indices = i
+          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
+          route_modules.each do |mod|
+            extension_route = mod.route(Pacer::Route.empty(route))
+            s, e = extension_route.send :build_pipeline
+            s.setStarts(pipe) if pipe
+            start_pipe ||= s
+            pipe = e
+          end
+          encoded_properties.each do |key, value|
+            new_pipe = PropertyFilterPipe.new(key, value, Pacer::Pipes::EQUAL)
+            new_pipe.set_starts pipe if pipe
+            Pacer.debug_pipes << { :name => key, :start => pipe, :end => new_pipe } if Pacer.debug_pipes
+            pipe = new_pipe
+            start_pipe ||= pipe
+          end
+          blocks.each do |block|
+            block_pipe = Pacer::Pipes::BlockFilterPipe.new(route, block)
+            block_pipe.set_starts pipe if pipe
+            Pacer.debug_pipes << { :name => 'block', :start => pipe, :end => block_pipe } if Pacer.debug_pipes
+            pipe = block_pipe
+            start_pipe ||= pipe
+          end
+          [start_pipe, pipe]
+        end
+
+        def any?
+          properties.any? or blocks.any? or route_modules.any? or extensions.any?
+        end
+
+        def extensions_only?
+          properties.none? and blocks.none? and route_modules.none? and (extensions.any? or wrapper)
+        end
+
+        def to_s
+          strings = []
+          strings << [wrapper.name] if wrapper
+          strings.concat extensions.map { |e| e.name }
+          strings.concat((non_ext_props - [@best_index_value]).map { |k, v| "#{ k }==#{ v.inspect }" })
+          strings.concat blocks.map { '&block' }
+          strings.concat route_modules.map { |mod| mod.name }
+          strings.join ', '
+        end
+
+        def best_index(element_type)
+          result = find_best_index(element_type)
+          # the call to find_best_index produces @best_index_value:
+          if properties.delete @best_index_value
+            @encoded_properties = nil
+          end
+          result
+        end
+
+        protected
+
+        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
+            end
+          end
+          index_options = index_options.sort_by do |a|
+            count = a.first
+            if count == 0 and search_manual_indices
+              # Only use 0 result indices if there is no alternative
+              # because most manual indices won't be populating the
+              # data in question.
+              java.lang.Integer::MAX_VALUE
+            else
+              count
+            end
+          end
+          _, @best_index, @best_index_value = index_options.first || [nil, [], []]
+          @best_index
+        end
+
+        def reset_properties
+          @encoded_properties = nil
+          if @best_index_value
+            # put removed index property back...
+            properties << @best_index_value
+          end
+          @best_index = nil
+          @best_index_value = nil
+          @available_indices = nil
+        end
+
+        def encoded_properties
+          @encoded_properties ||= properties.map do |k, v|
+            [k, encode_value(v)]
+          end
+        end
+
+        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
+              @available_indices["name:#{index.index_name}"] = [index]
+              @available_indices[:all] << index if search_manual_indices
+            end
+          end
+          @available_indices
+        end
+
+      end
+    end
+  end
+end