pacer-neo4j2 2.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65bbc2ebae5136c5b95bdf14891ecd538522e719
+  data.tar.gz: 84bef1fdf8c9bbb626ef089ef0cedd59dff19ead
+SHA512:
+  metadata.gz: 8e0a7bd049e14f3f101972f5a0696b6b6d47c30f575658a5cc713edd43605be26f86bbbb53149cbda18be86e7deadc4437053d32d118cf22e2a92e10a4bb1eb6
+  data.tar.gz: fc5480e6b8c60c18d56904b2e13b003607551a8111c40c4b45542d5a69ef7f21091a8a1c4fce8aec394937641f435bc9b2b390cc15ea32a0d0cf212b3a9aef19

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+target/*
+lib/*.jar

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in pacer-graph.gemspec
+gemspec

data/README.md

@@ -0,0 +1,23 @@
+# Neo4J Graph Database Adapter for Pacer
+
+[Pacer](https://github.com/pangloss/pacer) is a
+[JRuby](http://jruby.org) graph traversal framework built on the
+[Tinkerpop](http://www.tinkerpop.com) stack.
+
+This plugin enables full [Neo4J](http://neo4j.org) graph support in Pacer.
+
+
+## Usage
+
+Here is how you open a Neo4J graph in Pacer.
+
+  require 'pacer'
+  require 'pacer-neo4j2'
+
+  # Graph will be created if it doesn't exist
+  graph = Pacer.neo4j 'path/to/graph'
+
+All other operations are identical across graph implementations (except
+where certain features are not supported). See Pacer's documentation for
+more information.
+

data/Rakefile

@@ -0,0 +1,35 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+file 'pom.xml' => 'lib/pacer-neo4j2/version.rb' do
+  pom = File.read 'pom.xml'
+  when_writing('Update pom.xml version number') do
+    open 'pom.xml', 'w' do |f|
+      pom.each_line do |line|
+        line.sub!(%r{<gem.version>.*</gem.version>}, "<gem.version>#{ Pacer::Neo4j2::VERSION }</gem.version>")
+        line.sub!(%r{<blueprints.version>.*</blueprints.version>}, "<blueprints.version>#{ Pacer::Neo4j2::BLUEPRINTS_VERSION }</blueprints.version>")
+        line.sub!(%r{<pipes.version>.*</pipes.version>}, "<pipes.version>#{ Pacer::Neo4j2::PIPES_VERSION }</pipes.version>")
+        f << line
+      end
+    end
+  end
+end
+
+file Pacer::Neo4j2::JAR_PATH => 'pom.xml' do
+  when_writing("Execute 'mvn package' task") do
+    system('mvn clean package')
+  end
+end
+
+task :note do
+  puts "NOTE: touch lib/pacer-neo4j2/version.rb (or rake touch) to force everything to rebuild"
+end
+
+task :build => [:note, Pacer::Neo4j2::JAR_PATH]
+task :install => [:note, Pacer::Neo4j2::JAR_PATH]
+
+desc 'Touch version.rb so that the jar rebuilds'
+task :touch do
+  system 'touch', 'lib/pacer-neo4j2/version.rb'
+end
+

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

@@ -0,0 +1,38 @@
+module Pacer
+  module Neo4j2
+    module Algo
+      class BlockCostEvaluator
+        import org.neo4j.graphalgo.CostEvaluator
+        import org.neo4j.graphdb.Direction
+        import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Edge
+        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, Neo4j2Edge.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-neo4j2/algo/block_estimate_evaluator.rb

@@ -0,0 +1,32 @@
+module Pacer
+  module Neo4j2
+    module Algo
+      class BlockEstimateEvaluator
+        import org.neo4j.graphalgo.EstimateEvaluator
+        import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Vertex
+        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, Neo4j2Vertex.new(node, graph.blueprints_graph)
+          goal = Pacer::Wrappers::VertexWrapper.new graph, Neo4j2Vertex.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-neo4j2/algo/block_path_expander.rb

@@ -0,0 +1,61 @@
+module Pacer
+  module Neo4j2
+    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-neo4j2/algo/cypher_transform.rb

@@ -0,0 +1,129 @@
+module Pacer
+  module Core
+    module StringRoute
+      def raw_cypher(opts = {})
+        chain_route({element_type: :cypher, transform: Pacer::Transform::Cypher}.merge opts)
+      end
+
+      def cypher(opts = {})
+        raw_cypher(opts).paths
+      end
+    end
+
+    module Graph
+      module VerticesRoute
+        def raw_cypher(query, elements_per_query = nil)
+          reducer(element_type: :array).
+            enter { Set[] }.
+            leave { |x, a| x.nil? or (elements_per_query and a.length % elements_per_query == 0) }.
+            reduce { |v, ids| ids << v.element_id }.
+          map(element_type: :string) { |a| "start v=node(#{a.to_a.join(',')}) #{ query }"}.
+            raw_cypher
+        end
+
+        def cypher(query, elements_per_query = nil)
+          raw_cypher(query, elements_per_query).paths
+        end
+      end
+    end
+
+    module CypherRoute
+      def paths(*columns)
+        chain_route element_type: :path, transform: Pacer::Transform::CypherResults, columns: columns
+      end
+
+      def v(column = nil)
+        chain_route element_type: :vertex, transform: Pacer::Transform::CypherResults, columns: [column].compact, single: true
+      end
+
+      def e(column = nil)
+        chain_route element_type: :edge, transform: Pacer::Transform::CypherResults, columns: [column].compact, single: true
+      end
+
+      def results(*columns)
+        chain_route element_type: :array, transform: Pacer::Transform::CypherResults, columns: columns
+      end
+    end
+    Pacer::RouteBuilder.current.element_types[:cypher] = [CypherRoute]
+  end
+
+  module Transform
+    module Cypher
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = CypherPipe.new(self)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      class CypherPipe < Pacer::Pipes::RubyPipe
+        import org.neo4j.cypher.javacompat.ExecutionEngine
+
+        attr_reader :engine
+
+        def initialize(route)
+          super()
+          graph = route.graph.neo_graph
+          @engine = ExecutionEngine.new graph
+        end
+
+        protected
+
+        def processNextStart
+          engine.execute starts.next
+        end
+      end
+    end
+
+    module CypherResults
+      attr_accessor :columns, :single
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = ResultsPipe.new(self, columns, single)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      class ResultsPipe < Pacer::Pipes::RubyPipe
+        import org.neo4j.cypher.javacompat.ExecutionEngine
+
+        include Pacer::Neo4j2::Algo::Wrapping
+
+        attr_reader :columns, :graph, :single
+        attr_accessor :current
+
+        def initialize(route, columns, single)
+          super()
+          @single = single
+          @graph = route.graph
+          @columns = columns if columns and columns.any?
+        end
+
+        protected
+
+        def processNextStart
+          while true
+            if current
+              if current.first.hasNext
+                if single
+                  return wrap_path(current.map(&:next)).first
+                else
+                  return wrap_path current.map(&:next)
+                end
+              else
+                self.current = nil
+              end
+            else
+              results = starts.next
+              cols = columns || results.columns.to_a
+              self.current = cols.map { |col| results.columnAs col }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Pacer
+  module Neo4j2
+    module Algo
+      class PathPipe < Pacer::Pipes::RubyPipe
+        import org.neo4j.graphdb::Node
+        import org.neo4j.graphdb::Relationship
+        import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Vertex
+        import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Edge
+
+        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
+              Neo4j2Vertex.new e, graph
+            elsif e.is_a? Relationship
+              Neo4j2Edge.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-neo4j2/algo/path_wrapper.rb

@@ -0,0 +1,134 @@
+module Pacer
+  module Neo4j2
+    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
+        include Wrapping
+
+        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
+          wrap_path raw_path.iterator
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Pacer
+  module Neo4j2
+    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-neo4j2/algo/wrapping.rb

@@ -0,0 +1,34 @@
+module Pacer
+  module Neo4j2
+    module Algo
+      module Wrapping
+        import org.neo4j.graphdb.Node
+        import org.neo4j.graphdb.Relationship
+        import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Vertex
+        import com.tinkerpop.blueprints.impls.neo4j2.Neo4j2Edge
+
+        private
+
+        def wrap_path(p)
+          p.collect do |e|
+            if e.is_a? Node
+              wrap_vertex e
+            elsif e.is_a? Relationship
+              wrap_edge e
+            else
+              e
+            end
+          end
+        end
+
+        def wrap_vertex(v)
+          Pacer::Wrappers::VertexWrapper.new graph, Neo4j2Vertex.new(v, graph.blueprints_graph)
+        end
+
+        def wrap_edge(e)
+          Pacer::Wrappers::EdgeWrapper.new graph, Neo4j2Edge.new(e, graph.blueprints_graph)
+        end
+      end
+    end
+  end
+end