pacer 0.9.1.1-java

data/lib/pacer/route.rb

@@ -0,0 +1,228 @@
+[Pacer::Core::Route, Pacer::ElementMixin, 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))
+    end
+  }
+end
+
+module Pacer
+  # 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.
+  #
+  # The class definition only contains methods directly related to the
+  # construction of new Routes. For methods more likely to be used, see
+  # the {Core::Route} module which is always mixed into this class.
+  #
+  # @see Core::Route
+  class Route
+    class << self
+      # A pipeline is sometimes required if a pipe needs to be passed
+      # into a method that will change the starts on the same object
+      # that it requests the next result from.
+      #
+      # @param [Route] route the route to create a pipeline based on
+      # @return [Pacer::Pipes::BlackboxPipeline] an instantiated pipeline
+      def pipeline(route)
+        s, e = route.send(:build_pipeline)
+        if s.equal?(e)
+          s
+        else
+          Pacer::Pipes::BlackboxPipeline.new s, e
+        end
+      end
+    end
+
+    include Pacer::Core::Route
+    include Pacer::Routes::RouteOperations
+
+    # The function mixed into this instance
+    attr_reader :function
+
+    # The type of object that this route emits.
+    attr_reader :element_type
+
+    # Additional info to include after the class name when generating a
+    # name for this route.
+    attr_accessor :info
+
+    # The previous route in the chain
+    attr_reader :back
+
+    # The soure of data for the entire chain. Routes that have a source
+    # generally should not have a {#back}
+    attr_reader :source
+
+    # 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
+    # to build routes based on a graph.
+    #
+    # See {ElementMixin}, {VertexMixin} and
+    # {EdgeMixin} for methods to build routes based on an
+    # individual graph element.
+    #
+    # @see Core::Graph::GraphRoute
+    # @see GraphMixin
+    # @see ElementMixin
+    # @see VertexMixin
+    # @see EdgeMixin
+    #
+    # See Pacer's {Enumerable#to_route} method to create a route based
+    # on an Array, a Set or any other Enumerable type.
+    #
+    # @param [Hash] args
+    # @option args [Graph] :graph the graph this route is based on
+    # @option args [Route] :bace the previous route in the chain
+    # @option args [element type] :element_type
+    # @option args [Module] :modules additional modules to mix in
+    # @option args [Symbol, Module] :filter the filter to use as this
+    #   route's function
+    # @option args [Symbol, Module] :side_effect the side effect to use
+    #   as this route's function (Also triggers the {Core::SideEffect}
+    #   mixin)
+    # @option args [Symbol, Module] :transform the transform module to
+    #   use as this route's function
+    # @option args [[Module]] :extensions extensions for this route
+    #
+    # All other keys sent to the args method will be converted into
+    # setter method calls and called against the instantiated route to
+    # allow modules to define their own setup however they need.
+    #
+    # @example If a route is constructed with the a custom key:
+    #   route = Route.new(:filter => :block, :block => proc { |element| element.element_id.even? })
+    #
+    #   # is theoretically the same as
+    #
+    #   route = Route.new
+    #   route.extend Pacer::Filter::BlockFilter
+    #   route.block = proc { |element| element.element_id.even? }
+    #   route
+    #
+    # 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
+      else
+        raise "Element type #{ et.inspect } specified, but no graph specified."
+      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
+
+    # 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
+      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
+        end
+      end
+    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
+
+    # 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
+    end
+  end
+end

data/lib/pacer/routes.rb

@@ -0,0 +1,6 @@
+module Pacer
+  module Routes
+    # Defines the Routes namespace
+  end
+end
+require 'pacer/route/mixins'

data/lib/pacer/side_effect/aggregate.rb

@@ -0,0 +1,31 @@
+module Pacer
+  module Routes::RouteOperations
+    def aggregate(into = nil)
+      chain_route :side_effect => :aggregate, :into => into
+    end
+  end
+
+  module SideEffect
+    module Aggregate
+      import com.tinkerpop.pipes.sideeffect.AggregatePipe
+      import java.util.HashSet
+
+      attr_accessor :into
+
+      protected
+
+      def attach_pipe(end_pipe)
+        if into.is_a? Symbol
+          hs = vars[into] = HashSet.new
+          pipe = AggregatePipe.new hs
+        elsif into
+          pipe = AggregatePipe.new into
+        else
+          pipe = AggregatePipe.new HashSet.new
+        end
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/side_effect/counted.rb

@@ -0,0 +1,30 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def counted
+        chain_route :side_effect => :counted
+      end
+
+      def count
+        counted.count
+      end
+    end
+  end
+
+
+  module SideEffect
+    module Counted
+      def count
+        cap.first
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        @pipe = com.tinkerpop.pipes.sideeffect.CountPipe.new
+        @pipe.setStarts(end_pipe) if end_pipe
+        @pipe
+      end
+    end
+  end
+end

data/lib/pacer/side_effect/group_count.rb

@@ -0,0 +1,44 @@
+module Pacer
+  module Routes::RouteOperations
+    def fast_group_count(hash_map = nil)
+      chain_route :side_effect => :group_count, :hash_map => hash_map
+    end
+  end
+
+  module SideEffect
+    module GroupCount
+      def hash_map=(hash_map)
+        @hash_map = hash_map
+      end
+
+      def at_least(n)
+        @min = n
+        self
+      end
+
+      def to_h
+        c = 0
+        each { c = c + 1 }
+        puts c
+        h = {}
+        min = @min || 0
+        side_effect.each do |k,v|
+          h[k] = v if v >= min
+        end
+        h
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        if @hash_map
+          @pipe = com.tinkerpop.pipes.sideeffect.GroupCountPipe.new @hash_map
+        else
+          @pipe = com.tinkerpop.pipes.sideeffect.GroupCountPipe.new
+        end
+        @pipe.set_starts(end_pipe) if end_pipe
+        @pipe
+      end
+    end
+  end
+end

data/lib/pacer/side_effect/is_unique.rb

@@ -0,0 +1,32 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def is_unique
+        chain_route :side_effect => :is_unique
+      end
+
+      def unique?
+        is_unique.unique?
+      end
+    end
+  end
+
+
+  module SideEffect
+    module IsUnique
+      def unique?
+        pipe do |pipe|
+          pipe.next while pipe.unique?
+        end.unique?
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        @pipe = Pacer::Pipes::IsUniquePipe.new
+        @pipe.setStarts(end_pipe) if end_pipe
+        @pipe
+      end
+    end
+  end
+end

data/lib/pacer/side_effect/section.rb

@@ -0,0 +1,25 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def section(section_name = nil)
+        chain_route side_effect: :section, section_name: section_name
+      end
+    end
+  end
+
+  module SideEffect
+    module Section
+      attr_accessor :section_name
+
+      protected
+
+      attr_reader :section_visitor
+
+      def attach_pipe(end_pipe)
+        @section_visitor = pipe = Pacer::Pipes::SimpleVisitorPipe.new
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/side_effect/visitor.rb

@@ -0,0 +1,37 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def visitor(visitor)
+        chain_route side_effect: :visitor, visitor: visitor
+      end
+    end
+  end
+
+  module SideEffect
+    module Visitor
+      attr_reader :visitor
+
+      def visitor=(v)
+        @visitor = v
+        @visitor = @visitor.on_route(self) if @visitor.respond_to? :on_route
+      end
+
+      def element_type
+        if @visitor.respond_to? :element_type
+          @visitor.element_type
+        else
+          super
+        end
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = @visitor.attach_pipe(end_pipe) if @visitor.respond_to? :attach_pipe
+        pipe ||= Pacer::Pipes::VisitorPipe.new(visitor)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/side_effect.rb

@@ -0,0 +1,11 @@
+module Pacer
+  module SideEffect
+  end
+end
+
+require 'pacer/side_effect/aggregate'
+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/array_list.rb

@@ -0,0 +1,28 @@
+java.util.ArrayList
+class Java::JavaUtil::ArrayList
+  def inspect
+    to_a.inspect
+  end
+end
+
+java.util.LinkedList
+class Java::JavaUtil::LinkedList
+  def inspect
+    to_a.inspect
+  end
+end
+
+require 'set'
+java.util.HashSet
+class Java::JavaUtil::HashSet
+  def inspect
+    to_set.inspect.sub(/Set/, 'HashSet')
+  end
+end
+
+java.util.HashMap
+class Java::JavaUtil::HashMap
+  def to_hash_map
+    self
+  end
+end

data/lib/pacer/support/enumerable.rb

@@ -0,0 +1,100 @@
+# Extend the built-in Enumerable module:
+module Enumerable
+
+  def one?
+    counter = 0
+    each do
+      return false if counter == 1
+      counter += 1
+    end
+    counter == 1
+  end
+
+  def many?
+    counter = 0
+    any? { if counter == 1; true; else; counter += 1; false; end }
+  end
+
+  # Transform the enumerable into a java HashSet.
+  def to_hashset(method = nil, *args)
+    return self if self.is_a? java.util.HashSet and not method
+    hs = java.util.HashSet.new
+    iter = self.each rescue nil
+    if not iter and respond_to? :iterator
+      iter = self.iterator
+    end
+    e = iter.next
+    if method
+      while true
+        hs.add e.send(method, *args)
+        e = iter.next
+      end
+    else
+      while true
+        hs.add e
+        e = iter.next
+      end
+    end
+  rescue StopIteration
+    hs
+  rescue NativeException => e
+    if (e.cause.kind_of?(java.util.NoSuchElementException))
+      hs
+    else
+      raise
+    end
+  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
+  #
+  # You can work around that by passing the option :unwrap => true or
+  # setting the :based_on parameter to a route that has extensions.
+  def to_route(opts = {})
+    if self.is_a? Pacer::Core::Route
+      self
+    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 }
+      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)
+      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])
+      end
+    end
+  end
+
+  def id_to_element_route(args = {})
+    based_on = args[:based_on]
+    raise 'Must supply :based_on option' unless based_on
+    raise 'Graph routes do not contain element ids to look up' if self.is_a? Pacer::Core::Route and graph
+    raise 'Based on route must be a graph route' unless based_on.graph
+    r = to_route(:info => "#{ count } ids")
+    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],
+                  :route_name => 'lookup',
+                  :extensions => based_on.extensions,
+                  :wrapper => based_on.wrapper,
+                  :info => [args[:name], based_on.info].compact.join(':')).is_not(nil)
+  end
+
+  def group_count
+    result = Hash.new(0)
+    if block_given?
+      each { |e| result[yield(e)] += 1 }
+    else
+      each { |e| result[e] += 1 }
+    end
+    result
+  end
+
+end

data/lib/pacer/support/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def to_hash_map
+    hm = java.util.HashMap.new
+    each do |key, value|
+      hm.put key, value
+    end
+    hm
+  end
+end

data/lib/pacer/support/iterator_mixins.rb

@@ -0,0 +1,110 @@
+module Pacer::Core::Route
+  # This mixin allows an iterator to be returned from methods that perform a
+  # transformation on the elements in their collection. Set the block property
+  # to the proc that does the transformation.
+  module IteratorBlockMixin
+    attr_accessor :graph
+
+    # Set the block that does the transformation.
+    def block=(block)
+      @block = block
+    end
+
+    def next
+      item = super
+      item.graph ||= @graph
+      @block.call(item)
+    end
+  end
+
+  module IteratorPathMixin
+    attr_accessor :graph
+
+    def next
+      super.collect do |e|
+        e.graph ||= @graph if e.respond_to? :graph=
+        e
+      end
+    end
+  end
+
+  module IteratorExtensionsMixin
+    attr_accessor :graph, :extensions
+
+    def next
+      item = super
+      # TODO: optimize this (and other) check:
+      #   - exception?
+      #   - type check?
+      #   - method check?
+      #   - ...?
+      if item.respond_to? :graph=
+        item = item.add_extensions @extensions
+        item.graph ||= @graph
+      end
+      item
+    end
+  end
+
+  module IteratorWrapperMixin
+    attr_reader :graph, :extensions, :wrapper
+
+    def wrapper=(w)
+      @base_wrapper = w
+      @wrapper = build_wrapper?
+      @set_graph = set_graph?
+    end
+
+    def graph=(g)
+      @graph = g
+      @wrapper = build_wrapper?
+      @set_graph = set_graph?
+    end
+
+    def extensions=(exts)
+      @extensions = exts
+      @wrapper = build_wrapper?
+      @set_graph = set_graph?
+    end
+
+    def build_wrapper?
+      @base_wrapper = nil unless defined? @base_wrapper
+      @extensions = nil unless defined? @extensions
+      if @base_wrapper and @extensions
+        @wrapper = @base_wrapper.wrapper_for(@base_wrapper.extensions + @extensions.to_a)
+      elsif @base_wrapper
+        @wrapper = @base_wrapper
+      elsif @extensions
+        # We don't know what type of wrapper to create
+      end
+    end
+
+    if RUBY_VERSION =~ /^1\.8\./
+      def set_graph?
+        graph and wrapper and wrapper.instance_methods.include?('graph=')
+      end
+    else
+      def set_graph?
+        graph and wrapper and wrapper.instance_methods.include?(:graph=)
+      end
+    end
+
+    def next
+      item = wrapper.new(super)
+      item.graph ||= graph if @set_graph
+      item
+    end
+  end
+
+  module IteratorMixin
+    attr_accessor :graph
+
+    def next
+      item = super
+      if item.respond_to? :graph=
+        item.graph ||= @graph
+      end
+      item
+    end
+  end
+end