pacer 0.9.1.1-java → 1.0.0-java

data/lib/pacer/route/mixin/bulk_operations.rb

@@ -24,17 +24,16 @@ module Pacer::Routes
           target_graph.in_bulk_job = true
           size ||= target_graph.bulk_job_size
           counter = 0
-          each_slice(size) do |slice|
-            print counter if Pacer.verbose?
-            counter += size
-            target_graph.managed_manual_transaction do
-              target_graph.unmanaged_transactions do
-                slice.each do |element|
-                  yield element
-                end
+          target_graph.transaction do |commit, rollback|
+            each_slice(size) do |slice|
+              print counter if Pacer.verbose?
+              counter += size
+              slice.each do |element|
+                yield element
               end
-              print '.' if Pacer.verbose?
+              commit.call
             end
+            print '.' if Pacer.verbose?
           end
         ensure
           puts '!' if Pacer.verbose?

data/lib/pacer/route/mixin/route_operations.rb

@@ -60,13 +60,6 @@ module Pacer::Routes
       end
     end
 
-    # Store the current intermediate element in the route's vars hash by the
-    # given name so that it is accessible subsequently in the processing of the
-    # route.
-    def as(name)
-      chain_route :modules => VariableRouteModule, :variable_name => name
-    end
-
     # Returns true if this route could contain both vertices and edges.
     def mixed_route?
       self.is_a? Pacer::Core::Graph::MixedRoute
@@ -98,10 +91,23 @@ module Pacer::Routes
       results
     end
 
-    protected
-
-    def has_routable_class?
-      true
+    # Creates a terse, human-friendly name for the class based on its
+    # element type, function and info.
+    # @return [String]
+    def inspect_class_name
+      s = case element_type
+          when :vertex
+            'V'
+          when :edge
+            'E'
+          when :object
+            'Obj'
+          when :mixed
+            'Elem'
+          end
+      s = "#{s}-#{function.name.split('::').last.sub(/Filter|Route$/, '')}" if function
+      s = "#{s} #{ @info }" if @info
+      s
     end
   end
 end

data/lib/pacer/route/mixins.rb

@@ -1,3 +1,2 @@
 require 'pacer/route/mixin/bulk_operations'
 require 'pacer/route/mixin/route_operations'
-require 'pacer/route/mixin/variable_route_module'

data/lib/pacer/route.rb

@@ -1,12 +1,155 @@
-[Pacer::Core::Route, Pacer::ElementMixin, Pacer::Wrappers::EdgeWrapper, Pacer::Wrappers::VertexWrapper].each do |klass|
+[Pacer::Core::Route, Pacer::Wrappers::ElementWrapper, Pacer::Wrappers::EdgeWrapper, Pacer::Wrappers::VertexWrapper].each do |klass|
   klass.class_eval %{
     def chain_route(args_hash)
-      Pacer::Route.new({ :back => self }.merge(args_hash))
+      Pacer::RouteBuilder.current.chain self, args_hash
     end
   }
 end
 
 module Pacer
+
+  class RouteBuilder
+    class << self
+      attr_writer :current
+
+      def current
+        @current ||= RouteBuilder.new
+      end
+    end
+
+    attr_reader :types
+
+    def initialize
+      @types = Hash.new do |h, type_def|
+        h[type_def] = Class.new(Route) do
+          type_def.each do |mods|
+            mods.each do |mod|
+              include mod
+            end
+          end
+        end
+      end
+    end
+
+    def chain(source, args)
+      types[type_def(source, args)].new source, configuration(source, args), arguments(source, args)
+    end
+
+    protected
+
+    def source_value(source, name)
+      source.send name if source.respond_to? name
+    end
+
+    def type_def(source, args)
+      [
+        type_modules(source, args),
+        function_modules(source, args),
+        other_modules(source, args),
+        extension_modules(source, args)
+      ]
+    end
+
+    def configuration(source, args)
+      {
+        element_type: element_type(source, args),
+        graph: graph(source, args),
+        extensions: extensions(source, args),
+        wrapper: wrapper(source, args),
+        function: function_modules(source, args).first
+      }
+    end
+
+    def arguments(source, args)
+      args.reject do |key, val|
+        Set[:element_type, :wrapper, :extensions, :modules, :graph, :back, :filter, :side_effect, :transform, :visitor].include? key
+      end
+    end
+
+    def graph(source, args)
+      args[:graph] || source_value(source, :graph)
+    end
+
+    def element_type(source, args)
+      et = args[:element_type] || source_value(source, :element_type)
+      if not et
+        fail ClientError, "No element_type specified or inferred"
+      end
+      if not graph(source, args) and (et == :vertex or et == :edge or et == :mixed)
+        fail ClientError, "Element type #{ et.inspect } specified, but no graph specified."
+      end
+      et
+    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
+    end
+
+    def other_modules(source, args)
+      [*args[:modules]]
+    end
+
+    def type_from_source?(source, args)
+      element_type(source, args) == source_value(source, :element_type)
+    end
+
+    def wrapper(source, args)
+      args.fetch(:wrapper) do
+        source_value(source, :wrapper) if type_from_source? source, args
+      end
+    end
+
+    def extensions(source, args)
+      exts = args.fetch(:extensions) do
+        source_value(source, :extensions) if type_from_source? source, args
+      end
+      if exts.is_a? Set
+        exts.to_a
+      elsif exts.is_a? Module
+        [exts]
+      elsif exts.is_a? Array
+        exts.uniq
+      else
+        []
+      end
+    end
+
+    def all_extensions(source, args)
+      w = wrapper source, args
+      exts = extensions source, args
+      if w and exts
+        (w.extensions + exts).uniq
+      elsif w
+        w.extensions
+      elsif exts
+        exts
+      else
+        []
+      end
+    end
+
+    def extension_modules(source, args)
+      all_extensions(source, args).uniq.select do |mod|
+        mod.respond_to?(:const_defined?) and mod.const_defined? :Route
+      end.map { |mod| mod::Route }
+    end
+
+
+    def function_modules(source, args)
+      FunctionResolver.function(args).compact
+    end
+  end
+
+
   # The base class for almost everything in Pacer. Every route is an
   # instance of this class with a variety of modules mixed into the
   # instance at runtime.
@@ -37,11 +180,33 @@ module Pacer
     include Pacer::Core::Route
     include Pacer::Routes::RouteOperations
 
-    # The function mixed into this instance
-    attr_reader :function
+    attr_reader :config
+
+    def wrapper
+      config[:wrapper]
+    end
+
+    def extensions
+      config[:extensions]
+    end
+
+    def all_extensions
+      if wrapper
+        (wrapper.extensions + extensions).uniq
+      else
+        extensions
+      end
+    end
 
     # The type of object that this route emits.
-    attr_reader :element_type
+    def element_type
+      config[:element_type]
+    end
+
+    # The function mixed into this instance
+    def function
+      config[:function]
+    end
 
     # Additional info to include after the class name when generating a
     # name for this route.
@@ -57,18 +222,18 @@ module Pacer
     # Create a new route. It should be very rare that you would need to
     # directly create a Route object.
     #
-    # See {Core::Graph::GraphRoute} and {GraphMixin} for methods
+    # See {Core::Graph::GraphRoute} and {PacerGraph} for methods
     # to build routes based on a graph.
     #
-    # See {ElementMixin}, {VertexMixin} and
-    # {EdgeMixin} for methods to build routes based on an
+    # See {ElementWrapper}, {VertexWrapper} and
+    # {EdgeWrapper} for methods to build routes based on an
     # individual graph element.
     #
     # @see Core::Graph::GraphRoute
-    # @see GraphMixin
-    # @see ElementMixin
-    # @see VertexMixin
-    # @see EdgeMixin
+    # @see PacerGraph
+    # @see ElementWrapper
+    # @see VertexWrapper
+    # @see EdgeWrapper
     #
     # See Pacer's {Enumerable#to_route} method to create a route based
     # on an Array, a Set or any other Enumerable type.
@@ -104,125 +269,37 @@ module Pacer
     # When the route object is fully initialized, the
     # {#after_initialize} method is called to allow mixins to do any
     # additional setup.
-    def initialize(args = {})
-      @@graph = @back = @source = nil
-      @wrapper = nil
-      @extensions = Set[]
-      self.graph = args[:graph]
-      self.back = args[:back]
-      include_function args
-      set_element_type args
-      include_other_modules args
-      keys = args.keys - [:element_type, :modules, :graph, :back, :filter, :side_effect, :transform]
-      keys.each do |key|
-        send("#{key}=", args[key])
-      end
-      include_extensions args
-      after_initialize
-    rescue Exception => e
-      puts "Exception creating Route with #{ args.inspect }" if Pacer.verbose?
-      raise
-    end
-
-    protected
-
-    # Set the element type of this route and include the apropriate
-    # mixin to support the element type.
-    #
-    # @param [:vertex, :edge, :mixed, element type, Object] et the
-    #   element type to use
-    def element_type=(et)
-      if graph
-        @element_type = graph.element_type(et)
-        if @element_type == graph.element_type(:vertex)
-          extend Pacer::Core::Graph::VerticesRoute
-        elsif @element_type == graph.element_type(:edge)
-          extend Pacer::Core::Graph::EdgesRoute
-        elsif @element_type == graph.element_type(:mixed)
-          extend Pacer::Core::Graph::MixedRoute
-        end
-      elsif et == :object or et == Object
-        @element_type = Object
+    def initialize(source, config, args)
+      if source.is_a? Route
+        @back = source
       else
-        raise "Element type #{ et.inspect } specified, but no graph specified."
+        @source = source
       end
-    end
-
-    # This callback may be overridden. Be sure to call super() though.
-    # @return ignored
-    def after_initialize
-    end
-
-    # Find the module for the function to include based on the :filter,
-    # :side_effect or :transform argument given to {#initialize} and
-    # extend this instance with it.
-    def include_function(args)
-      @function, extension = FunctionResolver.function(args)
-      self.extend extension if extension
-      self.extend function if function
-    end
-
-    # @return [Route, nil] the previous route in the chain
-    def back_object(args)
-      back || args[:back]
-    end
-
-    # Get element type from the previous route in the chain.
-    # @return [element type, nil]
-    def back_element_type(args)
-      b = back_object(args)
-      if b.respond_to? :element_type
-        b.element_type
-      end
-    end
+      @config = config
+      @args = args
 
-    # If no element type has been specified, try to find one from
-    # the previous route in the chain.
-    # @raise [StandardError] if no element type can be found
-    def set_element_type(args)
-      if args[:element_type]
-        self.element_type = args[:element_type]
-      else
-        if bet = back_element_type(args)
-          self.element_type = bet
-        else
-          raise "No element_type specified or inferred"
-        end
+      args.each do |key, value|
+        send("#{key}=", value)
       end
-    end
 
-    # extends this class with any modules passed to {#initialize} in the
-    # :modules key.
-    def include_other_modules(args)
-      if mods = args[:modules]
-        @modules = [*mods]
-        @modules.each do |mod|
-          extend mod
+      after_initialize
+    rescue Exception => e
+      begin
+        if Pacer.verbose?
+          puts "Exception #{ e.class } #{ e.message } ..."
+          puts "... creating #{ config.inspect } route"
+          puts "... with #{ args.inspect }"
         end
+      rescue Exception
       end
+      raise e
     end
 
-    # Copy extensions from the previous route in the chain if the
-    # previous route's element type is the same as the current route's
-    # element type and no extensions were explicitly set on this route.
-    def include_extensions(args)
-      if back_element_type(args) == self.element_type and not args.key? :extensions and not args.key? :wrapper
-        back_obj = back_object(args)
-        if not wrapper and extensions.none?
-          self.wrapper = back_obj.wrapper if back_obj.respond_to? :wrapper
-          self.extensions = back_obj.extensions if back_obj.respond_to? :extensions
-        end
-      end
-    end
+    protected
 
-    # Creates a terse, human-friendly name for the class based on its
-    # element type, function and info.
-    # @return [String]
-    def inspect_class_name
-      s = "#{element_type.to_s.scan(/Elem|Obj|V|E/).last}"
-      s = "#{s}-#{function.name.split('::').last.sub(/Filter|Route$/, '')}" if function
-      s = "#{s} #{ @info }" if @info
-      s
+    # This callback may be overridden. Be sure to call super() though.
+    # @return ignored
+    def after_initialize
     end
   end
 end

data/lib/pacer/side_effect/aggregate.rb

@@ -1,7 +1,10 @@
 module Pacer
   module Routes::RouteOperations
     def aggregate(into = nil)
-      chain_route :side_effect => :aggregate, :into => into
+      aggregate = ::Pacer::SideEffect::Aggregate
+      r = self
+      r = section(into, aggregate::ElementSet) if into.is_a? Symbol
+      r.chain_route :side_effect => aggregate, :into => into
     end
   end
 
@@ -10,7 +13,14 @@ module Pacer
       import com.tinkerpop.pipes.sideeffect.AggregatePipe
       import java.util.HashSet
 
-      attr_accessor :into
+      include Pacer::Visitors::VisitsSection
+
+      attr_reader :into
+
+      def into=(name)
+        @into = name
+        self.section = name if name.is_a? Symbol
+      end
 
       protected
 
@@ -26,6 +36,16 @@ module Pacer
         pipe.setStarts end_pipe if end_pipe
         pipe
       end
+
+      class ElementSet < HashSet
+        def on_element(element)
+          add element
+        end
+
+        def reset
+          clear
+        end
+      end
     end
   end
 end

data/lib/pacer/side_effect/as.rb

@@ -0,0 +1,73 @@
+module Pacer
+  module Routes::RouteOperations
+    # Store the current intermediate element in the route's vars hash by the
+    # given name so that it is accessible subsequently in the processing of the
+    # route.
+    def as(name)
+      as = ::Pacer::SideEffect::As
+      section(name, as::SingleElementSet).chain_route :side_effect => as, :variable_name => name
+    end
+  end
+
+  module SideEffect
+    module As
+      class AsPipe < Pacer::Pipes::AbstractPipe
+
+        field_reader :starts
+        attr_accessor :vars
+
+        def initialize(pipe, vars, variable_name)
+          super()
+          setStarts pipe if pipe
+          @vars = vars
+          @variable_name = variable_name
+        end
+
+        def getCurrentPath
+          starts.getCurrentPath
+        end
+
+        protected
+
+        def processNextStart
+          @vars[@variable_name] = starts.next
+        end
+      end
+
+
+      import java.util.HashSet
+
+      attr_accessor :variable_name
+
+      protected
+
+      def attach_pipe(pipe)
+        if element_type == :vertex or element_type == :edge or element_type == :mixed
+          wrapped = Pacer::Pipes::WrappingPipe.new graph, element_type, extensions
+          wrapped.setStarts pipe
+          as_pipe = AsPipe.new(wrapped, vars, variable_name)
+          unwrapped = Pacer::Pipes::UnwrappingPipe.new
+          unwrapped.setStarts as_pipe
+          unwrapped
+        else
+          AsPipe.new(pipe, vars, variable_name)
+        end
+      end
+
+      def inspect_class_name
+        @variable_name.inspect
+      end
+
+      class SingleElementSet < HashSet
+        def on_element(element)
+          clear
+          add element
+        end
+
+        def reset
+          clear
+        end
+      end
+    end
+  end
+end

data/lib/pacer/side_effect/group_count.rb

@@ -17,9 +17,6 @@ module Pacer
       end
 
       def to_h
-        c = 0
-        each { c = c + 1 }
-        puts c
         h = {}
         min = @min || 0
         side_effect.each do |k,v|

data/lib/pacer/side_effect/is_unique.rb

@@ -15,17 +15,18 @@ module Pacer
   module SideEffect
     module IsUnique
       def unique?
-        pipe do |pipe|
-          pipe.next while pipe.unique?
-        end.unique?
+        checked = Pacer::Pipes::IsUniquePipe.new
+        checked.setStarts pipe
+        checked.next while checked.unique?
+        false
+      rescue Pacer::EmptyPipe, java.util.NoSuchElementException
+        true
       end
 
       protected
 
       def attach_pipe(end_pipe)
-        @pipe = Pacer::Pipes::IsUniquePipe.new
-        @pipe.setStarts(end_pipe) if end_pipe
-        @pipe
+        end_pipe
       end
     end
   end

data/lib/pacer/side_effect.rb

@@ -4,8 +4,8 @@ module Pacer
 end
 
 require 'pacer/side_effect/aggregate'
+require 'pacer/side_effect/as'
 require 'pacer/side_effect/group_count'
 require 'pacer/side_effect/is_unique'
 require 'pacer/side_effect/counted'
-require 'pacer/side_effect/section'
 require 'pacer/side_effect/visitor'

data/lib/pacer/support/enumerable.rb

@@ -35,20 +35,22 @@ module Enumerable
         e = iter.next
       end
     end
-  rescue StopIteration
+  rescue StopIteration, Pacer::EmptyPipe, java.util.NoSuchElementException
     hs
-  rescue NativeException => e
-    if (e.cause.kind_of?(java.util.NoSuchElementException))
-      hs
-    else
-      raise
-    end
+  end
+
+  def to_list
+    java.util.Arrays.asList *self
+  end
+
+  def to_iterable
+    Pacer::Pipes::EnumerablePipe.new self
   end
 
   # NOTE: if this is a collection of wrapped vertices or edges, Java pipes
   # may crash with something like:
   #
-  #   NativeException: java.lang.ClassCastException: org.jruby.RubyObject cannot be cast to com.tinkerpop.blueprints.pgm.Element
+  #   NativeException: java.lang.ClassCastException: org.jruby.RubyObject cannot be cast to com.tinkerpop.blueprints.Element
   #
   # You can work around that by passing the option :unwrap => true or
   # setting the :based_on parameter to a route that has extensions.
@@ -58,15 +60,15 @@ module Enumerable
     else
       based_on = opts[:based_on]
       if opts[:unwrap] or based_on and (based_on.wrapper or based_on.extensions.any?) and based_on.is_a? Pacer::Core::Graph::ElementRoute
-        source = Pacer::Route.new(:source => self, :element_type => :object).map { |e| e.element }
+        source = Pacer::RouteBuilder.current.chain(self, :element_type => :object).map { |e| e.element }
       else
         source = self
       end
       if based_on
-        Pacer::Route.new(:source => source, :element_type => opts.fetch(:element_type, based_on.element_type), :graph => based_on.graph, :wrapper => based_on.wrapper, :extensions => based_on.extensions, :info => based_on.info)
+        Pacer::RouteBuilder.current.chain(source, :element_type => opts.fetch(:element_type, based_on.element_type), :graph => based_on.graph, :wrapper => based_on.wrapper, :extensions => based_on.extensions, :info => based_on.info, :route_name => opts[:route_name])
       else
         graph = opts[:graph] if opts[:graph]
-        Pacer::Route.new(:source => source, :element_type => opts.fetch(:element_type, :object), :graph => graph, :wrapper => opts[:wrapper], :extensions => opts[:extensions], :info => opts[:info])
+        Pacer::RouteBuilder.current.chain(source, :element_type => opts.fetch(:element_type, :object), :graph => graph, :wrapper => opts[:wrapper], :extensions => opts[:extensions], :info => opts[:info], :route_name => opts[:route_name])
       end
     end
   end
@@ -80,7 +82,7 @@ module Enumerable
     r.chain_route(:graph => based_on.graph,
                   :element_type => based_on.element_type,
                   :pipe_class => based_on.send(:id_pipe_class),
-                  :pipe_args => [based_on.graph],
+                  :pipe_args => [based_on.graph.blueprints_graph],
                   :route_name => 'lookup',
                   :extensions => based_on.extensions,
                   :wrapper => based_on.wrapper,

data/lib/pacer/support/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def as(*args)
+    nil
+  end
+end

data/lib/pacer/support/proc.rb

@@ -7,10 +7,10 @@ class Proc
       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)
+      Pacer::RouteBuilder.current.chain(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])
+      Pacer::RouteBuilder.current.chain(source, :element_type => (opts[:element_type] || :object), :graph => graph, :extensions => opts[:extensions], :info => opts[:info])
     end
   end
 end