pacer 1.0.3-java → 1.1.0-java

data/lib/pacer/route_builder.rb

@@ -8,7 +8,7 @@ module Pacer
       end
     end
 
-    attr_reader :types
+    attr_reader :types, :element_types
 
     def initialize
       @types = Hash.new do |h, type_def|
@@ -20,6 +20,12 @@ module Pacer
           end
         end
       end
+
+      @element_types = Hash.new { |h, k| h[k] = [] }
+      element_types[:vertex] = [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::VerticesRoute]
+      element_types[:edge] = [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::EdgesRoute]
+      element_types[:mixed] = [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::MixedRoute]
+      element_types[:path] = [Pacer::Core::Graph::PathRoute]
     end
 
     def chain(source, args)
@@ -73,16 +79,7 @@ module Pacer
     end
 
     def type_modules(source, args)
-      case element_type source, args
-      when :vertex
-        [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::VerticesRoute]
-      when :edge
-        [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::EdgesRoute]
-      when :mixed
-        [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::MixedRoute]
-      else
-        []
-      end
+      element_types[element_type source, args]
     end
 
     def other_modules(source, args)

data/lib/pacer/side_effect/counted.rb

@@ -8,6 +8,7 @@ module Pacer
       def count
         counted.count
       end
+      alias run! count
     end
   end
 

data/lib/pacer/side_effect/group_count.rb

@@ -19,7 +19,7 @@ module Pacer
       def to_h
         h = {}
         min = @min || 0
-        side_effect.each do |k,v|
+        cap.first.each do |k,v|
           h[k] = v if v >= min
         end
         h

data/lib/pacer/support/array.rb

@@ -0,0 +1,18 @@
+
+class Array
+  PipesPipe = com.tinkerpop.pipes.Pipe
+  unless instance_methods.include? :plus_without_multi
+    alias plus_without_multi +
+    def +(other)
+      plus_with_multi(other)
+    end
+  end
+
+  def plus_with_multi(other)
+    if other.is_a? PipesPipe or other.is_a? Enumerator
+      Pacer::Pipes::MultiPipe.new [self, other]
+    else
+      plus_without_multi(other)
+    end
+  end
+end

data/lib/pacer/support/enumerable.rb

@@ -47,6 +47,10 @@ module Enumerable
     Pacer::Pipes::EnumerablePipe.new self
   end
 
+  def +(other)
+    Pacer::Pipes::MultiPipe.new [self, other]
+  end
+
   # NOTE: if this is a collection of wrapped vertices or edges, Java pipes
   # may crash with something like:
   #

data/lib/pacer/transform/cap.rb

@@ -9,6 +9,37 @@ module Pacer
     module Cap
       import com.tinkerpop.pipes.transform.SideEffectCapPipe
 
+      def help(section = nil)
+        case section
+        when nil
+          puts <<HELP
+Cap executes the full pipeline until it is empty, discarding all of the
+pipeline's results. It then calls getSideEffect from the previous pipe
+segment and emits that value as the only resulting value of the route.
+
+The value of getSideEffect is generally calculated by processing each
+element of the route. A good example is #count which is actually
+implemented as follows:
+
+  r = g.v.counted.cap     #=> #<GraphV -> Obj-Cap(V-Counted)>
+  r.to_a                  #=> [123]
+
+In this example, #counted is a side effect pipe. Side effect pipes can
+be used on their own but their value is not reliable until the full
+pipeline has been processed:
+
+  pipe = g.v.counted.pipe
+  pipe.getSideEffect      #=> 0
+  pipe.next               #=> #<V[3]>
+  pipe.getSideEffect      #=> 1
+
+HELP
+        else
+          super
+        end
+        description
+      end
+
       def with=(route)
         @side_effect = route
       end

data/lib/pacer/transform/flat_map.rb

@@ -0,0 +1,9 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def flat_map(opts = {}, &block)
+        map(&block).scatter(opts)
+      end
+    end
+  end
+end

data/lib/pacer/transform/make_pairs.rb

@@ -0,0 +1,29 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def make_pairs(other = nil, &block)
+        if block
+          # This would be cool if it could create a pair based on
+          fail 'not implemented yet'
+        elsif other
+          if other.is_a? Route and [element_type, other.element_type].all? { |t| [:vertex, :edge].include? t }
+            et = :path
+          else
+            et = :object
+          end
+          other = other.to_a
+          if other.empty?
+            empty(self)
+          else
+            flat_map(element_type: et, route_name: 'make_pairs') do |el|
+              other.map { |o| [el, o] }
+            end
+          end
+        else
+          fail Pacer::ClientError, 'No source for pairs given to make_pairs'
+        end
+      end
+    end
+  end
+end
+

data/lib/pacer/transform/map.rb

@@ -11,13 +11,61 @@ module Pacer
     module Map
       attr_accessor :block
 
+      def help(section = nil)
+        case section
+        when nil
+          puts <<HELP
+Works much like Ruby's built-in map method but has some extra options and,
+like all routes, does not evaluate immediately (see the :routes help topic).
+
+Example:
+
+  mapped = [1,2,3].to_route.map { |n| n + 1 }   #=> #<Obj -> Obj-Map>
+
+  mapped.to_a                                   #=> [2,3,4]
+  mapped.limit(1).to_a                          #=> [2]
+
+Note that the block will be called *twice* in the above example where limit(1)
+is applied to the route after the map is defined. Routes do some pre-processing
+and you can not assume that a function executed within a route will be executed
+the expected number of times without carefully testing your logic.
+
+Further, note that routes may be re-executed multiple times:
+
+  [mapped.to_a, mapped.to_a]                    #=> [[2,3,4], [2,3,4]]
+
+The element_type option is frequently useful. The following looks up elements
+by ID in the graph and produces a fully-fledged vertices route:
+
+  route = [1,2,3].to_route
+  mapped = route.map(graph: g, element_type: :vertex) { |n| g.vertex(n) }
+
+  mapped.out_e                                  #=> #<Obj -> V-Map -> outE>
+  mapped.in_e                                   #=> #<Obj -> V-Map -> inE>
+
+If you want to map over a route immediately without adding a map step to it,
+use the synonym for #map built-in to Ruby: #collect
+
+  [1,2,3].to_route.collect { |n| n + 1 }        #=> [2,3,4]
+
+HELP
+        else
+          super
+        end
+        description
+      end
+
       protected
 
       def attach_pipe(end_pipe)
         # Must wrap based on parent pipe because the element in the block has
         # not yet been affected by any of this block's transforms.
-        pf = Pacer::Wrappers::WrappingPipeFunction.new back || source, block
-        pf = Pacer::Wrappers::UnwrappingPipeFunction.new pf
+        if back and back.element_type == :path
+          pf = Pacer::Wrappers::PathWrappingPipeFunction.new back, block
+        else
+          pf = Pacer::Wrappers::WrappingPipeFunction.new back || source, block
+          pf = Pacer::Wrappers::UnwrappingPipeFunction.new pf
+        end
         pipe = com.tinkerpop.pipes.transform.TransformFunctionPipe.new pf
         pipe.setStarts end_pipe if end_pipe
         pipe

data/lib/pacer/transform/path.rb

@@ -2,7 +2,7 @@ module Pacer
   module Core
     module Route
       def paths(*exts)
-        route = chain_route :transform => :path, :element_type => :object
+        route = chain_route :transform => :path, :element_type => :path
         if exts.any?
           exts = exts.map { |e| Array.wrap(e) if e }
           route.map(modules: Pacer::Transform::Path::Methods) do |path|
@@ -17,40 +17,35 @@ module Pacer
 
   module Transform
     module Path
-      module Methods
-        def transpose
-          collect { |arraylist| arraylist.to_a }.transpose
-        end
+      import com.tinkerpop.pipes.transform.PathPipe
 
-        def subgraph(target_graph = nil, opts = {})
-          raise "Can't create a subgraph within itself." if target_graph == graph
-          target_graph ||= Pacer.tg
-          target_graph.vertex_name ||= graph.vertex_name
-          missing_edges = Set[]
-          bulk_job(nil, target_graph) do |path|
-            path.select { |e| e.is_a? Pacer::Vertex }.each do |vertex|
-              vertex.clone_into target_graph
-            end
-            path.select { |e| e.is_a? Pacer::Edge }.each do |edge|
-              unless edge.clone_into target_graph, ignore_missing_vertices: true
-                missing_edges << edge
-              end
-            end
-          end
-          if missing_edges.any?
-            missing_edges.to_route(graph: graph, element_type: :edge).bulk_job nil, target_graph do |edge|
-              edge.clone_into target_graph,
-                ignore_missing_vertices: opts[:ignore_missing_vertices],
-                show_missing_vertices: opts[:show_missing_vertices]
-            end
-          end
-          target_graph
-        end
-      end
+      def help(section = nil)
+        case section
+        when nil
+          puts <<HELP
+Each path returned by this method represents each intermediate value that was
+used to calculate the resulting value:
 
-      import com.tinkerpop.pipes.transform.PathPipe
+  r = [1,2,3].to_route.map { |n| n*2 }
+  p = r.paths                           #=> #<Obj -> Obj-Map -> Path-Path>
+  p.to_a                                #=> [[1,1], [2,4], [3,6]]
+
+This is especially useful for graph traversals.
+
+  g.v.out_e.in_v.out_e.in_v.paths.first #=> [#<V[37]>,
+                                        #    #<E[41]:37-patcit-38>,
+                                        #    #<V[38]>,
+                                        #    #<E[40]:38-document-id-39>,
+                                        #    #<V[39]>]
 
-      include Methods
+See the :paths section for more details and general information about paths.
+
+HELP
+        else
+          super
+        end
+        description
+      end
 
       protected
 
@@ -59,16 +54,6 @@ module Pacer
         pipe.setStarts end_pipe if end_pipe
         pipe
       end
-
-      def configure_iterator(iter)
-        if respond_to? :graph
-          pipe = Pacer::Pipes::PathWrappingPipe.new(graph)
-          pipe.setStarts iter
-          pipe
-        else
-          iter
-        end
-      end
     end
   end
 end

data/lib/pacer/transform/path_tree.rb

@@ -0,0 +1,111 @@
+module Pacer
+  module Core
+    module Graph
+      module PathRoute
+        # Transform raw paths to a tree:
+        # [a b c]
+        # [a b d]
+        # [a e f]
+        # [a e g]
+        # -- becomes --
+        # [a [b [c]
+        #       [d]]
+        #    [e [f]
+        #       [g]]]
+
+        # The default comparator block is { |prev, current| prev == current }
+        def tree(&block)
+          wrapped.chain_route transform: :path_tree, element_type: :object, compare: block
+        end
+      end
+    end
+  end
+
+  module Transform
+    module PathTree
+      attr_accessor :compare
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = PathTreePipe.new compare
+        pipe.setStarts end_pipe
+        pipe
+      end
+
+      class PathTreePipe < Pacer::Pipes::RubyPipe
+        def initialize(compare = nil)
+          super()
+          self.building_path = nil
+          self.prev_path = nil
+          self.compare = compare || proc { |a, b| a == b }
+        end
+
+        # NOTE: doesn't handle variable length paths yet...
+        def processNextStart()
+          while true
+            path = starts.next
+            if building_path
+              if compare.call path.first, building_path.first
+                add_path path
+              else
+                return next_path(path)
+              end
+            else
+              next_path(path)
+            end
+          end
+        rescue Pacer::EmptyPipe, java.util.NoSuchElementException
+          if building_path
+            r = building_path
+            self.building_path = nil
+            r
+          else
+            raise EmptyPipe.instance
+          end
+        end
+
+        private
+
+        attr_accessor :building_path, :prev_path, :compare
+
+        def make(path)
+          path.reverse.inject(nil) do |inner, e|
+            if inner
+              [e, inner]
+            else
+              [e]
+            end
+          end
+        end
+
+        def add_path(path)
+          working = building_path
+          (1..path.length - 1).each do |pos|
+            current = path[pos]
+            prev = prev_path[pos]
+            if compare.call current, prev
+              working = working.last
+            else
+              if pos < path.length
+                working << make(path[pos..-1])
+              else
+                working << [current]
+              end
+              break
+            end
+          end
+          self.prev_path = path
+        end
+
+        def next_path(path)
+          finished = building_path
+          self.building_path = make path
+          self.prev_path = path
+          finished
+        end
+      end
+    end
+  end
+end
+

data/lib/pacer/transform/payload.rb

@@ -0,0 +1,50 @@
+module Pacer::Core::Graph::ElementRoute
+  def payload(&block)
+    chain_route transform: :payload, block: block
+  end
+end
+
+module Pacer::Transform
+  module Payload
+    attr_accessor :block
+
+    protected
+
+    def attach_pipe(end_pipe)
+      pipe = PayloadPipe.new(self, block)
+      pipe.setStarts end_pipe if end_pipe
+      pipe
+    end
+
+    class PayloadPipe < Pacer::Pipes::RubyPipe
+      field_reader :currentEnd
+
+      attr_reader :block, :wrapper
+
+      def initialize(route, block)
+        super()
+        if route.element_type == :edge
+          @wrapper = Pacer::Payload::Edge
+        elsif route.element_type == :vertex
+          @wrapper = Pacer::Payload::Vertex
+        else
+          fail Pacer::ClientError, 'Can not use PayloadPipe on non-element data'
+        end
+        block ||= proc { |el| nil }
+        @block = Pacer::Wrappers::WrappingPipeFunction.new route, block
+      end
+
+      def processNextStart
+        el = starts.next
+        @wrapper.new el, block.call(el)
+      end
+
+      def getPathToHere
+        path = super
+        path.remove path.size - 1
+        path.add currentEnd
+        path
+      end
+    end
+  end
+end