pacer-neo4j 2.0.1-java → 2.1.0-java

data/lib/pacer-neo4j.rb

@@ -8,3 +8,77 @@ require 'pacer-neo4j/version'
 require Pacer::Neo4j::JAR
 
 require 'pacer-neo4j/graph'
+require 'pacer-neo4j/algo/path_pipe'
+require 'pacer-neo4j/algo/block_cost_evaluator'
+require 'pacer-neo4j/algo/block_estimate_evaluator'
+require 'pacer-neo4j/algo/block_path_expander'
+require 'pacer-neo4j/algo/path_wrapper'
+require 'pacer-neo4j/algo/traversal_branch_wrapper'
+require 'pacer-neo4j/algo'
+require 'pacer-neo4j/raw_vertex_wrapping_pipe'
+require 'pacer-neo4j/lucene_filter'
+
+Pacer::FunctionResolver.clear_cache
+
+module Pacer
+  # Add 'static methods' to the Pacer namespace.
+  class << self
+    # Return a graph for the given path. Will create a graph if none exists at
+    # that location. (The graph is only created if data is actually added to it).
+    #
+    # If the graph is opened from a path, it will be registered to be closed by
+    # Ruby's at_exit callback, but if an already open graph is given, it will
+    # not.
+    #
+    # Please note that Pacer turns on Neo4j's checkElementsInTransaction
+    # feature by default. For some sort of performance improvement at
+    # the expense of an odd consistency model within transactions that
+    # require considerable more complexity in client code, you can use
+    # `graph.setCheckElementsInTransaction(false)` to disable the
+    # feature.
+    def neo4j(path_or_graph, args = nil)
+      bp_neo_class = com.tinkerpop.blueprints.impls.neo4j.Neo4jGraph
+      if path_or_graph.is_a? String
+        path = File.expand_path(path_or_graph)
+        open = proc do
+          graph = Pacer.open_graphs[path]
+          unless graph
+            if args
+              graph = bp_neo_class.new(path, args.to_hash_map)
+            else
+              graph = bp_neo_class.new(path)
+            end
+            Pacer.open_graphs[path] = graph
+            graph.setCheckElementsInTransaction true
+          end
+          graph
+        end
+        shutdown = proc do |g|
+          g.blueprints_graph.shutdown
+          Pacer.open_graphs.delete path
+        end
+        Neo4j::Graph.new(Pacer::YamlEncoder, open, shutdown)
+      else
+        # Don't register the new graph so that it won't be automatically closed.
+        Neo4j::Graph.new Pacer::YamlEncoder, proc { bp_neo_class.new(path_or_graph) }
+      end
+    end
+
+    def neo_batch(path)
+      bp_neo_class = com.tinkerpop.blueprints.impls.neo4jbatch.Neo4jBatchGraph
+      path = File.expand_path(path)
+      open = proc do
+        graph = bp_neo_class.new(path)
+        Pacer.open_graphs[path] = :open_batch_graph
+        graph
+      end
+      shutdown = proc do |g|
+        g.blueprints_graph.shutdown
+        Pacer.open_graphs.delete path
+      end
+      g = PacerGraph.new(Pacer::YamlEncoder, open, shutdown)
+      g.disable_transactions = true
+      g
+    end
+  end
+end

data/lib/pacer-neo4j/algo.rb

@@ -0,0 +1,406 @@
+module Pacer
+  module Core::Graph
+    module VerticesRoute
+      def path_to(to_v, opts = {})
+        route = self
+        route = make_pairs(to_v) if to_v.is_a? Enumerable
+        route.chain_route({transform: :path_finder, element_type: :path, max_hits: 1, target: to_v}.merge opts)
+      end
+
+      def paths_to(to_v, opts = {})
+        route = self
+        route = make_pairs(to_v) if to_v.is_a? Enumerable
+        route.chain_route({transform: :path_finder, element_type: :path, target: to_v}.merge opts)
+      end
+    end
+
+    module PathRoute
+      def expand(opts = {})
+        chain_route({transform: :path_finder, element_type: :path}.merge opts)
+      end
+    end
+  end
+
+
+  module Transform
+    module PathFinder
+      import org.neo4j.graphalgo.CommonEvaluators
+      import org.neo4j.graphalgo.GraphAlgoFactory
+      import org.neo4j.graphdb.Direction
+      import org.neo4j.kernel.Traversal
+      import org.neo4j.graphdb.DynamicRelationshipType
+      include Pacer::Neo4j::Algo
+
+      def after_initialize
+        fail Pacer::ClientError, 'graph must be neo4j' unless graph.vendor == 'neo4j'
+      end
+
+      def help(opt = nil)
+        case opt
+when nil
+  puts <<HELP
+Finds paths between pairs of vertices. The algorithm used depends on the
+options specified. All supported path finding algorithms including in Neo4j 1.8
+are included, and all of their documented usages are possible.
+
+USAGE:
+
+vertices.path_to(targets, options = {})
+    Find the first path from each vertex to each target vertex
+
+vertices.paths_to(targets, options = {})
+    Find multiple paths from each vertex to each target vertex
+
+paths.expand(options = {})
+    Find multiple paths from the first vertex in each path to the last vertex
+    in each path.
+
+All options are optional!
+
+These methods only work on Neo4j graphs.
+
+More details:
+
+help :options      for simple path algorithms and other options
+  find_all, cyclical, length, max_depth, max_hits
+
+help :cost         for Dijkstra and aStar
+  cost, cost_property, cost_default
+
+help :estimate     for aStar
+  estimate, estimate_default, lat_property, long_property
+
+help :expansion    customize how any path is expanded
+  in_labels, out_labels, both_labels, expander, forward, reverse
+
+HELP
+when :path
+  puts <<HELP
+Details for path:         expander: proc { |path, state| edges }
+
+#end_v        Returns the end vertex of this path.
+#start_v      Returns the start vertex of this path.
+#length       Returns the length of this path.
+#path         Iterates through both the vertices and edges of this path in
+              order.
+#end_e        Returns the last edge in this path.
+#v            Returns all the vertices in this path starting from the start
+              vertex going forward towards the end vertex.
+#e            Returns all the edges in between the vertices which this path
+              consists of.
+#reverse_v    Like #v but reversed.
+#reverse_e    Like #e but reversed.
+
+The following methods all proxy to the vertex returned by #end_v: and behave
+exactly like standard Pacer Vertex methods.
+
+The iterators can be combined with the + operator.
+
+Fast edge iterators:
+  #out_edges(*args)
+  #in_edges(*args)
+  #both_edges(*args)
+
+Fast vertex iterators:
+  #out_vertices(*args)
+  #in_vertices(*args)
+  #both_vertices(*args)
+
+Edge routes:
+  #out_e(*args)
+  #in_e(*args)
+  #both_e(*args)
+
+Vertex routes:
+  #out(*args)
+  #in(*args)
+  #both(*args)
+
+HELP
+when :expansion
+  puts <<HELP
+Path expansion options:
+
+  By default, all edges will be followed. By specifying expansion rules you can
+  limit which paths are attempted. All algorithms use the same expanders so
+  these options do not effect the algorithm selection.
+
+  in_labels: label | [labels]    only follow : in edges  : with the given label(s)
+  out_labels:                                : out edges :
+  both_labels:                               : edges     :
+      These options can be combined.
+
+  Expanders search forward from the start vertex and backwards from the target
+  vertex. Either expander
+
+  expander: Proc | PathExpander   Custom rule for forward search
+      If no reverse is specified, will be used for reverse too.
+  forward:                        synonym for the expander option
+  reverse:  Proc | PathExpander   Custom rule for the reverse search
+
+      proc { |path, state| edges }:
+        path is a Pacer::Neo4j::Algo::PathWrapper - help(:path) for details
+        The proc must simply return an Enumerable of edges that the
+
+HELP
+when :options
+  puts <<HELP
+Simple options:
+
+  find_all: Boolean    Find all non-cyclical paths.
+      Algorithm: allSimplePaths
+
+  cyclical: Boolean    Find all paths including cyclical ones.
+      Algorithm: allPaths
+
+  length: Number       Number of edges that the path contains.
+      Algorithm: pathsWithLength
+      Returns only paths of the specified length.
+
+  max_depth: Number    Number of edges to search in a potential path.
+      Default: 5
+      Limits how many edges will be traversed searching for a path. Higher
+      numbers can take exponentially longer, I think.  Does not apply to aStar,
+      Dijkstra, or pathsWithLength algorithms.
+
+      Required for find_all, cyclical, and shortest path algorithms.
+
+  max_hits: Number     Maximum number of paths to find for each pair of vertices.
+      #path_to defaults this to 1. All algorithms use this but only
+      some support it natively in Neo4j's implementations.
+
+
+HELP
+when :cost
+  puts <<HELP
+Cost options:
+
+  Specifying these chooses the Dijkstra algorithm unless an estimate is also
+  specified.
+
+  cost: Proc | CostEvaluator   Calculate the cost for this edge.
+      Must return a Numeric unless cost_default is set.
+      proc { |edge, direction| Float }:
+        direction is either :in or :out.
+
+  cost_property: String        get the cost from the given edge property
+  cost_default: Float          default if the property isn't there
+
+HELP
+when :estimate
+  puts <<HELP
+Estimate options
+  Specifying these together with cost chooses the a* / aStar algorithm.
+
+  estimate:
+      Must return a Numeric unless estimate_default is set.
+      proc { |vertex, goal_vertex| Float }
+
+  estimate_default: Float   only works with the proc estimate
+
+  lat_property: String      latitude property name
+  long_property: String     longitude property name
+      Use latitude and longitude if all estimated vertices have the necessary
+      properties.
+
+HELP
+else
+  super
+end
+        description
+      end
+
+      def method
+        if has_cost?
+          if has_estimate?
+            :aStar
+          else
+            :dijkstra
+          end
+        elsif cyclical and max_depth
+          :all
+        elsif find_all and max_depth
+          :all_simple
+        elsif length
+          :with_length
+        elsif max_depth
+          if max_hits
+            :shortest_with_max_hits
+          else
+            :shortest
+          end
+        end
+      end
+
+      attr_accessor :target
+
+      # specify one or many edge labels that the path may take in the given direction
+      attr_accessor :in_labels, :out_labels, :both_labels
+
+      # note that expander procs *must* return edge(s) that are connected to the end_v of the given path
+      #
+      # expander yields: { |path, state| path.is_a? Pacer::Neo4j::Algo::PathWrapper }
+      attr_accessor :expander, :forward, :reverse
+
+      # use dijkstra unless the below estimate properties are set
+      #
+      # note that cost proc must return a Numeric unless cost_default is set
+      #
+      # cost yields: { |edge, direction| [:in, :out, :both].include? direction }
+      attr_accessor :cost, :cost_property, :cost_default
+
+      def set_cost(property = nil, default = nil, &block)
+        self.cost_property = property
+        self.cost_default = default
+        self.cost = block
+        self
+      end
+
+      # use the aStar algorithm
+      #
+      # note that estimate proc must return a Numeric unless estimate_default is set
+      #
+      # estimate yields: { |vertex, goal_vertex| }
+      attr_accessor :estimate, :lat_property, :long_property, :estimate_default
+
+      def set_estimate(lat = nil, long = nil, &block)
+        self.lat_property = lat
+        self.long_property = long
+        self.estimate = block
+        self
+      end
+
+      # use pathsWithLength
+      #
+      # Return only paths of the given length
+      attr_accessor :length
+
+      # default to shortest_path unless find_all is set
+      attr_writer :max_depth
+      def max_depth
+        @max_depth || 5
+      end
+
+      # use shortestPath
+      attr_accessor :max_hits
+
+      # Possible values:
+      attr_accessor :find_all
+      attr_accessor :cyclical
+
+      protected
+
+      def attach_pipe(end_pipe)
+        if back.element_type == :path
+          p = PathFromPathPipe.new build_algo, graph, max_hits
+        else
+          p = PathPipe.new build_algo, graph, target, max_hits
+        end
+        p.setStarts end_pipe
+        attach_length_filter(p) if length and method != :with_length
+        p
+      end
+
+      def attach_length_filter(end_pipe)
+        pipe = Pacer::Pipes::BlockFilterPipe.new(self, proc { |p| p.length == length }, false)
+        pipe.set_starts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        if back.element_type == :path
+          "expand[#{method}](max_depth: #{ max_depth })"
+        else
+          "paths_to[#{method}](#{ target.inspect }, max_depth: #{ max_depth })"
+        end
+      end
+
+      private
+
+      def has_cost?
+        cost or cost_property or cost_default
+      end
+
+      def has_estimate?
+        estimate or (lat_property and long_property) or estimate_default
+      end
+
+      def build_algo
+        case method
+        when :aStar
+          GraphAlgoFactory.aStar build_expander, build_cost, build_estimate
+        when :dijkstra
+          GraphAlgoFactory.dijkstra build_expander, build_cost
+        when :with_length
+          GraphAlgoFactory.pathsWithLength build_expander, length
+        when :all
+          GraphAlgoFactory.allPaths build_expander, max_depth
+        when :all_simple
+          GraphAlgoFactory.allSimplePaths build_expander, max_depth
+        when :shortest_with_max_hits
+          GraphAlgoFactory.shortestPath build_expander, max_depth, max_hits
+        when :shortest
+          GraphAlgoFactory.shortestPath build_expander, max_depth
+        when nil
+          fail Pacer::ClientError, "Could not choose a path algorithm"
+        else
+          fail Pacer::LogicError, "Unable to build algo for #{ method }"
+        end
+      end
+
+      def build_expander
+        if forward.is_a? Proc and reverse.is_a? Proc
+          BlockPathExpander.new forward, reverse, graph, max_depth
+        elsif expander.is_a? Proc
+          BlockPathExpander.new expander, expander, graph, max_depth
+        elsif expander
+          expander
+        else
+          e = Traversal.emptyExpander
+          [*out_labels].each do |label|
+            e.add DynamicRelationshipType.withName(label.to_s), Direction::OUTGOING
+          end
+          [*in_labels].each do |label|
+            e.add DynamicRelationshipType.withName(label.to_s), Direction::INCOMING
+          end
+          [*both_labels].each do |label|
+            e.add DynamicRelationshipType.withName(label.to_s), Direction::BOTH
+          end
+          e
+        end
+      end
+
+      def build_cost
+        if cost.is_a? Proc
+          BlockCostEvaluator.new cost, graph, cost_default
+        elsif cost
+          cost
+        elsif cost_property
+          if cost_default
+            CommonEvaluators.doubleCostEvaluator cost_property.to_s, cost_default.to_f
+          else
+            CommonEvaluators.doubleCostEvaluator cost_property.to_s
+          end
+        elsif cost_default
+          CommonEvaluators.doubleCostEvaluator ' not a property ', cost_default.to_f
+        else
+          fail Pacer::LogicError, "could not build cost"
+        end
+      end
+
+      def build_estimate
+        if estimate.is_a? Proc
+          BlockEstimateEvaluator.new estimate, graph, estimate_default
+        elsif estimate
+          estimate
+        elsif lat_property and long_property
+          CommonEvaluators.geoEstimateEvaluator lat_property.to_s, long_property.to_s
+        elsif estimate_default
+          BlockEstimateEvaluator.new proc { estimate_default }, graph, estimate_default
+        else
+          fail Pacer::LogicError, "could not build estimate"
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/block_cost_evaluator.rb

@@ -0,0 +1,38 @@
+module Pacer
+  module Neo4j
+    module Algo
+      class BlockCostEvaluator
+        import org.neo4j.graphalgo.CostEvaluator
+        import org.neo4j.graphdb.Direction
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jEdge
+        include CostEvaluator
+
+        DIRS = {
+          Direction::INCOMING => :in,
+          Direction::OUTGOING => :out,
+          Direction::BOTH => :both
+        }
+
+        attr_reader :block, :graph, :default
+
+        def initialize(block, graph, default)
+          @block = block
+          @graph = graph
+          @default = default.to_f
+        end
+
+        def getCost(rel, dir)
+          e = Pacer::Wrappers::EdgeWrapper.new graph, Neo4jEdge.new(rel, graph.blueprints_graph)
+          result = block.call e, DIRS[dir]
+          if result.is_a? Numeric
+            result.to_f
+          elsif default
+            default
+          else
+            fail Pacer::ClientError, "No cost returned and no default specified: #{ result.inspect }"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/block_estimate_evaluator.rb

@@ -0,0 +1,32 @@
+module Pacer
+  module Neo4j
+    module Algo
+      class BlockEstimateEvaluator
+        import org.neo4j.graphalgo.EstimateEvaluator
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jVertex
+        include EstimateEvaluator
+
+        attr_reader :block, :graph, :default
+
+        def initialize(block, graph, default)
+          @block = block
+          @graph = graph
+          @default = default.to_f
+        end
+
+        def getCost(node, goal)
+          node = Pacer::Wrappers::VertexWrapper.new graph, Neo4jVertex.new(node, graph.blueprints_graph)
+          goal = Pacer::Wrappers::VertexWrapper.new graph, Neo4jVertex.new(goal, graph.blueprints_graph)
+          result = block.call node, goal
+          if result.is_a? Numeric
+            result.to_f
+          elsif default
+            default
+          else
+            fail Pacer::ClientError, "No estimate returned and no default specified: #{ result.inspect }"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/block_path_expander.rb

@@ -0,0 +1,61 @@
+module Pacer
+  module Neo4j
+    module Algo
+      class BlockPathExpander
+        import org.neo4j.graphdb.PathExpander
+        import com.tinkerpop.pipes.Pipe
+
+        include PathExpander
+        attr_reader :block, :rev, :graph, :max_depth
+
+        def initialize(block, rev, graph, max_depth)
+          @block = block
+          @rev = rev
+          @graph = graph
+          @max_depth = max_depth
+        end
+
+        def expand(path, state)
+          path = PathWrapper.new(path, graph)
+          if max_depth and path.length >= max_depth
+            result = []
+          else
+            result = block.call path, state
+          end
+          pipe = Pacer::Pipes::NakedPipe.new
+          pipe.set_starts result_to_enumerable(result)
+          pipe
+        end
+
+        def reverse
+          BlockPathExpander.new rev, block, graph, max_depth
+        end
+
+        def result_to_enumerable(result)
+          case result
+          when PathWrapper
+            fail "Don't just return the arguments in your expander, return edges!"
+          when Pacer::Route
+            if result.element_type == :edge
+              result.pipe.starts
+            else
+              fail "Expander must return edges"
+            end
+          when Pacer::Wrappers::EdgeWrapper
+            Pacer::Pipes::EnumerablePipe.new [result]
+          when Pacer::Pipes::WrappingPipe
+            result.starts
+          when Pipe
+            result
+          when Enumerable
+            Pacer::Pipes::EnumerablePipe.new result
+          when nil
+            Pacer::Pipes::EnumerablePipe.new []
+          else
+            fail "Can't figure out what to do with #{ result.class }"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/path_pipe.rb

@@ -0,0 +1,79 @@
+module Pacer
+  module Neo4j
+    module Algo
+      class PathPipe < Pacer::Pipes::RubyPipe
+        import org.neo4j.graphdb::Node
+        import org.neo4j.graphdb::Relationship
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jVertex
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jEdge
+
+        attr_reader :algo, :target, :graph, :max_hits
+        attr_accessor :current_paths, :hits
+
+        def initialize(algo, graph, target, max_hits)
+          super()
+          @algo = algo
+          @max_hits = max_hits || -1
+          @graph = graph.blueprints_graph
+          @target = unwrap target if target
+        end
+
+        def processNextStart
+          next_raw_path.map do |e|
+            if e.is_a? Node
+              Neo4jVertex.new e, graph
+            elsif e.is_a? Relationship
+              Neo4jEdge.new e, graph
+            else
+              e
+            end
+          end
+        end
+
+        def next_raw_path
+          loop do
+            if current_paths
+              if hits == 0
+                self.current_paths = nil
+              elsif current_paths.hasNext
+                self.hits -= 1
+                return current_paths.next
+              else
+                self.current_paths = nil
+              end
+            else
+              self.hits = max_hits
+              self.current_paths = @algo.findAllPaths(next_raw, target).iterator
+            end
+          end
+        end
+
+        def next_raw
+          unwrap starts.next
+        end
+
+        def unwrap(vertex)
+          if vertex.respond_to? :element
+            vertex.element.raw_element
+          else
+            vertex.raw_element
+          end
+        end
+      end
+
+      class PathFromPathPipe < PathPipe
+        attr_writer :target
+
+        def initialize(algo, graph, max_hits)
+          super(algo, graph, nil, max_hits)
+        end
+
+        def next_raw
+          path = starts.next
+          self.target = unwrap path.to_a.last
+          unwrap path[0]
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/path_wrapper.rb

@@ -0,0 +1,152 @@
+module Pacer
+  module Neo4j
+    module Algo
+      # Uses the interface defined here:
+      # http://api.neo4j.org/1.8/org/neo4j/graphdb/Path.html
+      #
+      # Note that I have removed methods that I didn't understand, assuming they are internal.
+      class PathWrapper
+        import org.neo4j.graphdb.Node
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jVertex
+        import com.tinkerpop.blueprints.impls.neo4j.Neo4jEdge
+
+        attr_reader :graph, :raw_path
+
+        def initialize(path, graph)
+          @raw_path = path
+          @graph = graph
+          @gv = graph.v
+          @ge = graph.e
+        end
+
+        #Returns the end vertex of this path.
+        def end_v
+          wrap_vertex raw_path.endNode
+        end
+
+        # Iterates through both the vertices and edges of this path in order.
+        def path
+          raw_path.iterator.to_route.map(graph: graph, element_type: :mixed) do |e|
+            if e.is_a? Node
+              wrap_vertex e
+            else
+              wrap_edge e
+            end
+          end
+        end
+
+        def to_a
+          path.to_a
+        end
+
+        # Returns the last edge in this path.
+        def end_e
+          wrap_edge raw_path.lastRelationship
+        end
+
+        # Returns the length of this path.
+        def length
+          raw_path.length
+        end
+
+        # Returns all the vertices in this path starting from the start vertex going forward towards the end vertex.
+        def v
+          raw_path.nodes.map { |n| wrap_vertex n }.to_route based_on: @gv
+        end
+
+        # Returns all the edges in between the vertices which this path consists of.
+        def e
+          raw_path.relationships.map { |r| wrap_edge r }.to_route based_on @ge
+        end
+
+        # Returns all the vertices in this path in reversed order, i.e.
+        def reverse_v
+          raw_path.reverseNodes.map { |n| wrap_vertex n }.to_route based_on @gv
+        end
+
+        # Returns all the edges in between the vertices which this path consists of in reverse order, i.e.
+        def reverse_e
+          raw_path.reverseRelationships.map { |r| wrap_edge r }.to_route based_on @ge
+        end
+
+        # Returns the start vertex of this path.
+        def start_v
+          wrap_vertex raw_path.startNode
+        end
+
+        def to_s
+          "#{ start_v.inspect }-(#{length})->#{end_v.inspect}"
+        end
+
+        def inspect
+          "#<Path #{ to_s }>"
+        end
+
+        # skips route creation = faster but less features
+        def out_edges(*args)
+          end_v.out_edges(*args)
+        end
+
+        # skips route creation = faster but less features
+        def in_edges(*args)
+          end_v.in_edges(*args)
+        end
+
+        # skips route creation = faster but less features
+        def both_edges(*args)
+          end_v.both_edges(*args)
+        end
+
+        # skips route creation = faster but less features
+        def out_vertices(*args)
+          end_v.out_vertices(*args)
+        end
+
+        # skips route creation = faster but less features
+        def in_vertices(*args)
+          end_v.in_vertices(*args)
+        end
+
+        # skips route creation = faster but less features
+        def both_vertices(*args)
+          end_v.both_vertices(*args)
+        end
+
+
+        def out_e(*args)
+          end_v.out_e(*args)
+        end
+
+        def in_e(*args)
+          end_v.in_e(*args)
+        end
+
+        def both_e(*args)
+          end_v.both_e(*args)
+        end
+
+        def out(*args)
+          end_v.out(*args)
+        end
+
+        def in(*args)
+          end_v.in(*args)
+        end
+
+        def both(*args)
+          end_v.both(*args)
+        end
+
+        private
+
+        def wrap_vertex(v)
+          Pacer::Wrappers::VertexWrapper.new graph, Neo4jVertex.new(v, graph.blueprints_graph)
+        end
+
+        def wrap_edge(e)
+          Pacer::Wrappers::EdgeWrapper.new graph, Neo4jEdge.new(e, graph.blueprints_graph)
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/algo/traversal_branch_wrapper.rb

@@ -0,0 +1,47 @@
+module Pacer
+  module Neo4j
+    module Algo
+      # Uses the interface defined here:
+      # http://api.neo4j.org/1.8/org/neo4j/graphdb/traversal/TraversalBranch.html
+      #
+      # Note that I have removed methods that I didn't understand, assuming they are internal.
+      class TraversalBranchWrapper < PathWrapper
+        # Returns whether or not the traversal should continue further along this branch.
+        def continues?
+          raw_path.continues
+        end
+
+        # Returns the number of edges this expansion source has expanded.
+        def num_expanded
+          raw_path.expanded
+        end
+
+        # Returns whether or not this branch (the Path representation of this
+        # branch at least) should be included in the result of this traversal,
+        # i.e. returned as one of the Paths from f.ex.
+        # TraversalDescription.traverse(org.neo4j.graphdb.Node...)
+        def included?
+          raw_path.includes
+        end
+
+        # The parent expansion source which created this TraversalBranch.
+        def parent
+          TraversalBranchWrapper.new raw_path.parent, graph
+        end
+
+        # Explicitly tell this branch to be pruned so that consecutive calls to #next() is guaranteed to return null.
+        def prune!
+          raw_path.prune
+        end
+
+        def to_s
+          "#{super} num_expanded: #{ num_expanded }#{ continues? ? ' continues' : '' }#{ included? ? ' included' : '' }"
+        end
+
+        def inspect
+          "#<TBR #{to_s}>"
+        end
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/graph.rb

@@ -1,50 +1,82 @@
-require 'yaml'
-
 module Pacer
+  module Neo4j
+    class Graph < PacerGraph
+      # I'm not sure exactly what this impacts but if it is false, many Pacer tests fail.
+      #
+      # Presumably Neo4j is faster with it set to false.
+      def safe_transactions=(b)
+        blueprints_graph.setCheckElementsInTransaction b
+      end
+
+      def safe_transactions
+        blueprints_graph.getCheckElementsInTransaction
+      end
+
+      def key_index_cache(type, name, size = :undefined)
+        if size == :undefined
+          lucene_auto_index(type).getCacheCapacity name
+        else
+          lucene_auto_index(type).setCacheCapacity name, size
+        end
+      end
+
+      private
+
+      def index_properties(type, filters)
+        filters.properties.select { |k, v| key_indices(type).include?(k) and not v.nil? }
+      end
 
-  # Add 'static methods' to the Pacer namespace.
-  class << self
-    # Return a graph for the given path. Will create a graph if none exists at
-    # that location. (The graph is only created if data is actually added to it).
-    #
-    # If the graph is opened from a path, it will be registered to be closed by
-    # Ruby's at_exit callback, but if an already open graph is given, it will
-    # not.
-    #
-    # Please note that Pacer turns on Neo4j's checkElementsInTransaction
-    # feature by default. For some sort of performance improvement at
-    # the expense of an odd consistency model within transactions that
-    # require considerable more complexity in client code, you can use
-    # `graph.setCheckElementsInTransaction(false)` to disable the
-    # feature.
-    def neo4j(path_or_graph, args = nil)
-      neo = com.tinkerpop.blueprints.impls.neo4j.Neo4jGraph
-      if path_or_graph.is_a? String
-        path = File.expand_path(path_or_graph)
-        open = proc do
-          graph = Pacer.open_graphs[path]
-          unless graph
-            if args
-              graph = neo.new(path, args.to_hash_map)
+      def build_query(type, filters)
+        indexed = index_properties type, filters
+        if indexed.any?
+          indexed.map do |k, v|
+            if v.is_a? Numeric
+              "#{k}:#{v}"
             else
-              graph = neo.new(path)
+              s = encode_property(v)
+              if s.is_a? String and s =~ /\s/
+                %{#{k}:"#{s}"}
+              else
+                "#{k}:#{s}"
+              end
             end
-            Pacer.open_graphs[path] = graph
-            graph.setCheckElementsInTransaction true
-          end
-          graph
+          end.join " AND "
+        else
+          nil
         end
-        shutdown = proc do |g|
-          g.blueprints_graph.shutdown
-          Pacer.open_graphs[path] = nil
+      end
+
+      def neo_graph
+        blueprints_graph.raw_graph
+      end
+
+      def lucene_auto_index(type)
+        if type == :vertex
+          neo_graph.index.getNodeAutoIndexer.getIndexInternal
+        elsif type == :edge
+          neo_graph.index.getRelationshipAutoIndexer.getIndexInternal
+        end
+      end
+
+      def indexed_route(element_type, filters, block)
+        if search_manual_indices
+          super
+        else
+          query = build_query(element_type, filters)
+          if query
+            route = lucene query, element_type: element_type
+            filters.remove_property_keys key_indices(element_type)
+            if filters.any?
+              Pacer::Route.property_filter(route, filters, block)
+            else
+              route
+            end
+          elsif filters.route_modules.any?
+            mod = filters.route_modules.shift
+            Pacer::Route.property_filter(mod.route(self), filters, block)
+          end
         end
-        PacerGraph.new(Pacer::YamlEncoder, open, shutdown)
-      else
-        # Don't register the new graph so that it won't be automatically closed.
-        PacerGraph.new Pacer::YamlEncoder, proc { neo.new(path_or_graph) }
       end
     end
   end
-
-
 end

data/lib/pacer-neo4j/lucene_filter.rb

@@ -0,0 +1,112 @@
+module Pacer
+  module Neo4j
+    class Graph
+      def lucene(query, opts = {})
+        opts = { back: self, element_type: :vertex }.merge opts
+        chain_route(opts.merge(query: query,
+                               filter: :lucene,
+                               index: choose_index(opts)))
+      end
+
+      private
+
+      def choose_index(opts)
+        et = opts[:element_type]
+        idx = opts[:index]
+        case idx
+        when String, Symbol
+          index(idx, et).index.raw_index
+        when Pacer::Wrappers::IndexWrapper
+          idx.index.raw_index
+        when com.tinkerpop.blueprints.Index
+          idx.raw_index
+        else
+          lucene_auto_index(et)
+        end
+      end
+    end
+  end
+
+
+  module Filter
+    module LuceneFilter
+      import org.neo4j.index.lucene.QueryContext
+
+      attr_accessor :index, :query, :sort_by, :reverse_numeric, :sort_numeric, :sort_by_score, :top, :fast
+
+      def count(max = nil)
+        iter = query_result
+        c = iter.count
+        if c >= 0
+          c
+        elsif max
+          iter.inject(0) do |n, _|
+            if n == max
+              return :max
+            else
+              n + 1
+            end
+          end
+        else
+          iter.inject(0) { |n, _| n + 1 }
+        end
+      ensure
+        iter.close
+      end
+
+      def sort_by_score!
+        self.sort_by_score = true
+        self
+      end
+
+      def sort(*keys)
+        self.sort_by = keys
+        self
+      end
+
+      def top_hits(n)
+        self.top = n
+        self
+      end
+
+      def fast!
+        self.fast = true
+        self
+      end
+
+      protected
+
+      def build_query
+        qc = QueryContext.new(query)
+        qc = qc.tradeCorrectnessForSpeed if fast
+        qc = qc.top(top) if top
+        if sort_by_score
+          qc.sortByScore
+        elsif sort_by
+          qc.sort(*[*sort_by].map(&:to_s))
+        elsif sort_numeric
+          qc.sortNumeric(sort_numeric, false)
+        elsif reverse_numeric
+          qc.sortNumeric(reverse_numeric, true)
+        else
+          qc
+        end
+      end
+
+      def query_result
+        index.query build_query
+      end
+
+      def source_iterator
+        pipe = Pacer::Neo4j::RawVertexWrappingPipe.new graph
+        pipe.setStarts query_result
+        pipe.enablePath(true)
+        pipe
+      end
+
+      def inspect_string
+        "#{ inspect_class_name }(#{ query }) ~ #{ query_result.count }"
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/raw_vertex_wrapping_pipe.rb

@@ -0,0 +1,18 @@
+module Pacer
+  module Neo4j
+    class RawVertexWrappingPipe < Pacer::Pipes::RubyPipe
+      import com.tinkerpop.blueprints.impls.neo4j.Neo4jVertex
+
+      attr_reader :graph
+
+      def initialize(graph)
+        super()
+        @graph = graph.blueprints_graph
+      end
+
+      def processNextStart
+        Neo4jVertex.new starts.next, graph
+      end
+    end
+  end
+end

data/lib/pacer-neo4j/version.rb

@@ -1,6 +1,6 @@
 module Pacer
   module Neo4j
-    VERSION = "2.0.1"
+    VERSION = "2.1.0"
     JAR = "pacer-neo4j-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"
     BLUEPRINTS_VERSION = "2.1.0"

data/pom.xml

@@ -7,7 +7,7 @@
     <artifactId>pacer-neo4j</artifactId>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <properties>
-      <gem.version>2.0.1</gem.version>
+      <gem.version>2.1.0</gem.version>
       <blueprints.version>2.1.0</blueprints.version>
       <pipes.version>2.1.0</pipes.version>
     </properties>
@@ -32,6 +32,11 @@
             <artifactId>blueprints-neo4j-graph</artifactId>
             <version>${blueprints.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.tinkerpop.blueprints</groupId>
+            <artifactId>blueprints-neo4jbatch-graph</artifactId>
+            <version>${blueprints.version}</version>
+        </dependency>
     </dependencies>
 
     <repositories>

metadata

@@ -2,14 +2,14 @@
 name: pacer-neo4j
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 2.0.1
+  version: 2.1.0
 platform: java
 authors:
 - Darrick Wiebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000 Z
+date: 2012-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pacer
@@ -39,13 +39,22 @@ files:
 - README.md
 - Rakefile
 - lib/pacer-neo4j.rb
+- lib/pacer-neo4j/algo.rb
+- lib/pacer-neo4j/algo/block_cost_evaluator.rb
+- lib/pacer-neo4j/algo/block_estimate_evaluator.rb
+- lib/pacer-neo4j/algo/block_path_expander.rb
+- lib/pacer-neo4j/algo/path_pipe.rb
+- lib/pacer-neo4j/algo/path_wrapper.rb
+- lib/pacer-neo4j/algo/traversal_branch_wrapper.rb
 - lib/pacer-neo4j/graph.rb
+- lib/pacer-neo4j/lucene_filter.rb
+- lib/pacer-neo4j/raw_vertex_wrapping_pipe.rb
 - lib/pacer-neo4j/rspec.rb
 - lib/pacer-neo4j/version.rb
 - pacer-neo4j.gemspec
 - pom.xml
 - pom/standalone.xml
-- lib/pacer-neo4j-2.0.1-standalone.jar
+- lib/pacer-neo4j-2.1.0-standalone.jar
 homepage: http://neo4j.org
 licenses: []
 post_install_message: