pacer 0.9.1.1-java

data/lib/pacer/support/native_exception.rb

@@ -0,0 +1,22 @@
+class NativeException
+  def unravel
+    e = self
+    while e and e.respond_to? :cause
+      puts '--------------------'
+      puts e.class.to_s
+      puts e.message
+      pp e.backtrace.to_a
+      e = e.cause
+    end
+    puts '======================'
+  end
+
+  def root_cause
+    rc = e = self
+    while e and e.respond_to? :cause
+      rc = e
+      e = e.cause
+    end
+    rc
+  end
+end

data/lib/pacer/support/proc.rb

@@ -0,0 +1,16 @@
+class Proc
+  def to_route(opts = {})
+    based_on = opts[:based_on]
+    if opts[:unwrap] or based_on and based_on.extensions and based_on.graph
+      source = proc { self.call.map { |e| e.element } }
+    else
+      source = self
+    end
+    if based_on
+      Pacer::Route.new(:source => source, :element_type => :mixed, :graph => based_on.graph, :extensions => based_on.extensions, :info => based_on.info)
+    else
+      graph = opts[:graph] if opts[:graph]
+      Pacer::Route.new(:source => source, :element_type => (opts[:element_type] || :object), :graph => graph, :extensions => opts[:extensions], :info => opts[:info])
+    end
+  end
+end

data/lib/pacer/support.rb

@@ -0,0 +1,10 @@
+module Pacer
+  module Support
+  end
+end
+require 'pacer/support/iterator_mixins'
+require 'pacer/support/array_list'
+require 'pacer/support/enumerable'
+require 'pacer/support/proc'
+require 'pacer/support/hash'
+require 'pacer/support/native_exception'

data/lib/pacer/transform/cap.rb

@@ -0,0 +1,50 @@
+module Pacer
+  module Core::SideEffect
+    def cap
+      back.chain_route :transform => :cap, :with => self, :element_type => :object
+    end
+  end
+
+  module Transform
+    module Cap
+      import com.tinkerpop.pipes.transform.SideEffectCapPipe
+
+      def with=(route)
+        @side_effect = route
+      end
+
+      protected
+
+      def pipe_source
+        s, e = super
+        if not s and not e
+          s = e = Pacer::Pipes::IdentityPipe.new
+        end
+        [s, e]
+      end
+
+      def side_effect_pipe(end_pipe)
+        old_back = @side_effect.back
+        begin
+          empty = Pacer::Route.new :filter => :empty, :back => self
+          @side_effect.back = empty
+          _, side_effect_pipe = @side_effect.send :build_pipeline
+          side_effect_pipe.setStarts end_pipe if end_pipe
+          side_effect_pipe
+        ensure
+          @side_effect.back = old_back
+        end
+      end
+
+      def attach_pipe(end_pipe)
+        pipe = SideEffectCapPipe.new side_effect_pipe(end_pipe)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        "#{ inspect_class_name }(#{ @side_effect.send(:inspect_string) })"
+      end
+    end
+  end
+end

data/lib/pacer/transform/gather.rb

@@ -0,0 +1,9 @@
+module Pacer
+  module Core
+    module Route
+      def gather
+        aggregate.cap
+      end
+    end
+  end
+end

data/lib/pacer/transform/has_count_cap.rb

@@ -0,0 +1,41 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def has_count_route(opts = {})
+        chain_route({ :transform => :has_count_cap }.merge(opts))
+      end
+
+      def has_count?(opts = {})
+        has_count_route(opts).first
+      end
+    end
+  end
+
+  module Transform
+    module HasCountCap
+      import com.tinkerpop.pipes.transform.HasCountPipe
+
+      attr_accessor :min, :max
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = HasCountPipe.new(min || -1, max || -1)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        if min and max
+          "HasCount(#{ min }..#{max})"
+        elsif min
+          "HasCount(>= #{ min })"
+        elsif max
+          "HasCount(<= #{ max })"
+        else
+          "HasCount(...any...)"
+        end
+      end
+    end
+  end
+end

data/lib/pacer/transform/join.rb

@@ -0,0 +1,181 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def join(name = nil, options = {}, &block)
+        args = {
+          :transform => :join,
+          element_type: :vertex,
+          graph: options.fetch(:multi_graph, Pacer::MultiGraph.new),
+          from_graph: graph
+        }
+        args[:multi_graph] = options[:multi_graph] if options[:multi_graph]
+        route = chain_route(args)
+        route = route.key { |v| v } unless name == :key
+        if block and name == :key
+          route.key &block
+        elsif block
+          route.join(name || :values, &block)
+        else
+          route
+        end
+      end
+    end
+  end
+
+
+  module Transform
+    module Join
+      class CombinePipe < Pacer::Pipes::RubyPipe
+        import com.tinkerpop.pipes.sideeffect.SideEffectPipe
+        import java.util.ArrayList
+        import java.util.LinkedList
+
+        include SideEffectPipe rescue nil # may raise exception on reload.
+
+        attr_accessor :multi_graph, :current_keys, :current_values, :join_on
+        attr_reader :key_expando, :key_end, :values_pipes, :from_graph
+
+        def initialize(from_graph, multi_graph)
+          super()
+          @from_graph = from_graph
+          @multi_graph = multi_graph || Pacer::MultiGraph.new
+          @values_pipes = []
+          @current_keys = []
+          @current_values = []
+        end
+
+        def setKeyPipe(from_pipe, to_pipe)
+          @key_expando, @key_end = prepare_aggregate_pipe(from_pipe, to_pipe)
+        end
+
+        def addValuesPipe(name, from_pipe, to_pipe)
+          values_pipes << [name, *prepare_aggregate_pipe(from_pipe, to_pipe)]
+        end
+
+        def getSideEffect
+          multi_graph
+        end
+
+        protected
+
+        def processNextStart
+          while true
+            if current_keys.empty?
+              element = starts.next
+              element.graph = from_graph if element.respond_to? :graph
+              self.current_keys = get_keys(element)
+              self.current_values = get_values(element) unless current_keys.empty?
+            else
+              key = current_keys.removeFirst
+              if key
+                combined = multi_graph.send(:getVertex, key) || multi_graph.send(:addVertex, key)
+              else
+                combined = multi_graph.send(:addVertex, nil)
+              end
+              combined.join_on join_on if join_on
+              combined[:key] = key
+              current_values.each do |key, values|
+                combined.append_property_array key, values
+              end
+              return combined
+            end
+          end
+        rescue NativeException => e
+          if e.cause.getClass == Pacer::NoSuchElementException.getClass
+            raise e.cause
+          else
+            raise e
+          end
+        end
+
+        def get_keys(element)
+          array = LinkedList.new
+          if key_expando
+            array.addAll next_results(key_expando, key_end, element)
+          else
+            array.add nil
+          end
+          array
+        end
+
+        def get_values(element)
+          values_pipes.map do |name, expando, to_pipe|
+            [name, next_results(expando, to_pipe, element)]
+          end
+        end
+
+        # doesn't need to be spun out because it's a capped aggregator
+        def next_results(expando, pipe, element)
+          pipe.reset
+          expando.add element, ArrayList.new, nil
+          array = pipe.next
+          array.each { |element| element.graph = from_graph if element.respond_to? :graph }
+          array
+        end
+
+        def prepare_aggregate_pipe(from_pipe, to_pipe)
+          expando = Pacer::Pipes::ExpandablePipe.new
+          expando.setStarts ArrayList.new.iterator
+          from_pipe.setStarts(expando)
+          agg_pipe = com.tinkerpop.pipes.sideeffect.AggregatePipe.new LinkedList.new
+          cap_pipe = com.tinkerpop.pipes.transform.SideEffectCapPipe.new agg_pipe
+          agg_pipe.setStarts to_pipe
+          cap_pipe.setStarts to_pipe
+          [expando, cap_pipe]
+        end
+      end
+
+      include Pacer::Core::SideEffect
+
+      attr_accessor :existing_multi_graph, :key_route, :values_routes, :from_graph
+      attr_writer :join_on
+
+      def key(&block)
+        self.key_route = Pacer::Route.block_branch(self, block)
+        self
+      end
+
+      def join(name = nil, &block)
+        self.key_route = nil if name == :key
+        if block
+          values_routes << [(name || :values), Pacer::Route.block_branch(self, block)]
+        else
+          values_routes << [(name || :values), Pacer::Route.block_branch(self, proc { |v| v })]
+        end
+        self
+      end
+
+      def join_on(*keys)
+        @join_on = keys
+        self
+      end
+
+      def multigraph
+        cap.first
+      end
+
+      protected
+
+      def after_initialize
+        @values_routes = []
+      end
+
+      def attach_pipe(end_pipe)
+        pipe = CombinePipe.new(from_graph, existing_multi_graph)
+        self.graph = pipe.multi_graph
+        pipe.setKeyPipe *key_route.send(:build_pipeline) if key_route
+        pipe.join_on = @join_on
+        values_routes.each do |name, route|
+          pipe.addValuesPipe name, *route.send(:build_pipeline)
+        end
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        "#{ inspect_class_name }(#{ key_route.inspect }: #{ Hash[values_routes].inspect })"
+      end
+    end
+  end
+end
+    

data/lib/pacer/transform/map.rb

@@ -0,0 +1,23 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def map(opts = {}, &block)
+        chain_route({:transform => :map, :block => block, :element_type => :object}.merge(opts))
+      end
+    end
+  end
+
+  module Transform
+    module Map
+      attr_accessor :block
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = Pacer::Pipes::MapPipe.new(back, block)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/transform/path.rb

@@ -0,0 +1,50 @@
+module Pacer
+  module Core
+    module Route
+      def paths
+        chain_route :transform => :path, :element_type => :object
+      end
+    end
+  end
+
+  module Transform
+    module Path
+      import com.tinkerpop.pipes.transform.PathPipe
+
+      def transpose
+        collect { |arraylist| arraylist.to_a }.transpose
+      end
+
+      def subgraph(target_graph = nil)
+        raise "Can't create a subgraph within itself." if target_graph == graph
+        target_graph ||= Pacer.tg
+        target_graph.vertex_name ||= graph.vertex_name
+        bulk_job(nil, target_graph) do |path|
+          path_route = path.to_route(:graph => graph, :element_type => :mixed)
+          path_route.v.each do |vertex|
+            vertex.clone_into target_graph
+          end
+          path_route.e.each do |edge|
+            edge.clone_into target_graph
+          end
+        end
+        target_graph
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = PathPipe.new
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      def configure_iterator(iter)
+        if respond_to? :graph
+          iter.extend Pacer::Core::Route::IteratorPathMixin
+          iter.graph = graph
+        end
+      end
+    end
+  end
+end

data/lib/pacer/transform/process.rb

@@ -0,0 +1,23 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def process(opts = {}, &block)
+        chain_route({:transform => :process, :block => block}.merge(opts))
+      end
+    end
+  end
+
+  module Transform
+    module Process
+      attr_accessor :block
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = Pacer::Pipes::ProcessPipe.new(back, block)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/transform/scatter.rb

@@ -0,0 +1,23 @@
+module Pacer
+  module Core
+    module Route
+      def scatter(args = {})
+        chain_route({transform: :scatter, element_type: :object}.merge(args))
+      end
+    end
+  end
+
+  module Transform
+    module Scatter
+      import com.tinkerpop.pipes.transform.ScatterPipe
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = ScatterPipe.new
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/transform/sort_section.rb

@@ -0,0 +1,103 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def sort_section(section = nil, &block)
+        chain_route transform: :sort_section, block: block, section: section
+      end
+    end
+  end
+
+  module Transform
+    module SortSection
+      class SortSectionPipe < Pacer::Pipes::RubyPipe
+        attr_reader :block_1, :block_2, :to_sort, :to_emit, :section
+
+        def initialize(section, block)
+          super()
+          @to_emit = []
+          @section = section
+          @to_sort = []
+          if section
+            section.visitor = self
+          else
+            on_element nil
+          end
+          if block
+            if block.arity == 1
+              @block_1 = block
+              section.use_on_element = false
+            elsif block.arity == 2 or block.arity < 0
+              @block_2 = block
+            end
+          else
+            section.use_on_element = false
+          end
+        end
+
+        def processNextStart
+          while to_emit.empty?
+            element = @starts.next
+            to_sort << element
+          end
+          to_emit.shift
+        rescue NativeException => e
+          if e.cause.getClass == Pacer::NoSuchElementException.getClass
+            if to_emit.empty?
+              raise e.cause
+            else
+              after_element
+              retry
+            end
+          else
+            raise e
+          end
+        end
+
+        def on_element(element)
+          @section_element = element
+        end
+
+        def after_element
+          if to_sort.any?
+            if block_1
+              sorted = to_sort.sort_by do |element|
+                block_1.call element
+              end
+            elsif block_2
+              sorted = to_sort.sort_by do |element|
+                block_2.call element, @section_element
+              end
+            else
+              sorted = to_sort.sort
+            end
+            to_emit.concat sorted
+            @to_sort = []
+          end
+        end
+      end
+
+      attr_accessor :block
+      attr_reader :section_name, :section_route
+
+      def section=(section)
+        if section.is_a? Symbol
+          @section_name = section
+          @section_route = @back.get_section_route(section)
+        elsif section.is_a? Pacer::Route and section.respond_to? :section_name
+          @section_name = section.section_name
+          @section_route = section
+        else
+          raise ArgumentError, "Unknown section #{ section }. Provide either a name or a route created with the #section methed."
+        end
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = SortSectionPipe.new(@section_route.send(:section_visitor), block)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/transform/stream_sort.rb

@@ -0,0 +1,21 @@
+module Pacer
+  module Routes::RouteOperations
+    def stream_sort(buffer = 1000, silo = 100)
+      chain_route :transform => :stream_sort, :buffer => buffer, :silo => silo
+    end
+  end
+
+  module Transform
+    module StreamSort
+      attr_accessor :buffer, :silo
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = Pacer::Pipes::StreamSortPipe.new buffer, silo
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/transform/stream_uniq.rb

@@ -0,0 +1,21 @@
+module Pacer
+  module Routes::RouteOperations
+    def stream_uniq(buffer = 1000)
+      chain_route :transform => :stream_uniq, :buffer => buffer
+    end
+  end
+
+  module Transform
+    module StreamUniq
+      attr_accessor :buffer
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = Pacer::Pipes::StreamUniqPipe.new buffer
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/transform.rb

@@ -0,0 +1,16 @@
+module Pacer
+  module Transform
+  end
+end
+
+require 'pacer/transform/cap'
+require 'pacer/transform/stream_sort'
+require 'pacer/transform/stream_uniq'
+require 'pacer/transform/gather'
+require 'pacer/transform/map'
+require 'pacer/transform/process'
+require 'pacer/transform/join'
+require 'pacer/transform/path'
+require 'pacer/transform/scatter'
+require 'pacer/transform/has_count_cap'
+require 'pacer/transform/sort_section'