pacer 1.3.2-java → 1.3.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 941518faaec723674b8421588ee147d210b65b7a
-  data.tar.gz: 5624f8bf440519e6335d7f850d8cb0b3403c4d49
+  metadata.gz: e7e0a5a234c35970d36d359c87ba463f288153b1
+  data.tar.gz: 8fc9db2381222ca87e44dea2c59b41b8c41cf552
 SHA512:
-  metadata.gz: 85df9faed211d24e9a2810867194a41494955d76e03918b99150b03720eb93c2c83e1d4832215424b7f30d07138d0226333c634782950cd31a1d903c42004585
-  data.tar.gz: 25b18a28d5f9f25ee014ae6ea3940dc0c6dce0abfebdab76414394252018aa6d8da58da5e5faf45eec324861e7d910a3f84344151a67b8da72b0b0a4157f0e01
+  metadata.gz: 188528a64f6d2cb85fa57176ac500e9f9dc68b9859dc9b9fe6853025d5ce2a73812401f696654f8b5f8e5748671594dfd950088a96587a0fa2b15d285e03263d
+  data.tar.gz: 84608cddad663f171a8ad886f2c1f68e65ec33b9bea94a1107ec39301a2816e6fd10f69f49994145c0671effd4379ffc9c7c59819e4fd416c89cc40e65ee189c

data/ideas.rb

@@ -0,0 +1,32 @@
+g.v.parallel(threads: 8, in_buffer: 4, out_buffer: 10) { |v| v.out.out.out.out.out }
+
+# - eagerly consume (1) input and push into a channel
+#   - ChannelCapPipe
+#   - create a cap pipe that does this. The pipe's output is the channel
+#   - source data may be slow. Should probably not use a go block
+#   - 1 thread in a loop
+# - Control the construction of parallel pipes. Default 2 threads, make
+# it configurable.
+#   - standard copy split pipe can push the channel to subchannels
+#   - each parallel route pulls from the channel.
+#     - in a go block (waits will not block go thread pool)
+#     - ChannelReaderPipe
+#     - PathChannelReaderPipe
+#   - parallel routes are unmodified
+#   - cap each route - eagerly consume input and push into a channel
+#     - ChannelCapPipe again
+#   -
+#     - like ExhaustMergePipe + GatherPipe
+# - use alts to read from any of the channels
+# - ChannelAltsReaderPipe
+
+
+
+# CCP
+# CSP (parallelism is 1 thread per pipe being split into)
+#   CRP -> Work ... -> CCP
+#   CRP -> Work ... -> CCP
+#   ...
+# EMP
+# GP
+# CARP

data/lib/pacer/blueprints/group_vertex.rb

@@ -0,0 +1,59 @@
+module Pacer
+  # Created without property support, though it could easily be added if it is ever needed.
+  class GroupVertex
+    import com.tinkerpop.blueprints.util.VerticesFromEdgesIterable
+    IN = com.tinkerpop.blueprints.Direction::IN
+    OUT = com.tinkerpop.blueprints.Direction::OUT
+    BOTH = com.tinkerpop.blueprints.Direction::BOTH
+
+    attr_reader :components, :key
+    attr_reader :paths, :wrapper, :graph
+
+    # Initialize it with an empty set to force uniqueness. Non-unique by default.
+    def initialize(key, graph, wrapper, components = nil)
+      @key = key
+      @wrapper = wrapper
+      if components
+        @components = components
+      else
+        @components = []
+      end
+    end
+
+    def add_component(vertex)
+      components << vertex
+    end
+
+    include com.tinkerpop.blueprints.Element
+
+    def getId
+      "#{ key }:#{ components.count }"
+    end
+
+    def getPropertyKeys
+      Set[]
+    end
+
+    def getProperty(key)
+      case key
+      when 'components' then components.map { |c| wrapper.new graph, c }
+      when 'key' then key
+      when 'count' then components.count
+      end
+    end
+
+    include com.tinkerpop.blueprints.Vertex
+
+    def getRawVertex
+      self
+    end
+
+    def getVertices(direction, *labels)
+      VerticesFromEdgesIterable.new self, direction, *labels
+    end
+
+    def getEdges(direction, *labels)
+      Pacer::Pipes::MultiPipe.new components.map { |v| v.getEdges(direction, *labels) }
+    end
+  end
+end

data/lib/pacer/filter/limit_section_filter.rb

@@ -0,0 +1,57 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def limit_section(section = nil, max)
+        chain_route filter: Pacer::Filter::LimitSectionFilter, section_max: max, section: section
+      end
+    end
+  end
+
+  module Filter
+    module LimitSectionFilter
+      # VisitsSection module provides:
+      #  section=
+      #  section_visitor
+      include Pacer::Visitors::VisitsSection
+
+      attr_accessor :section_max
+
+      def attach_pipe(end_pipe)
+        pipe = LimitSectionPipe.new(self, section_visitor, section_max)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      class LimitSectionPipe < Pacer::Pipes::RubyPipe
+        attr_reader :max, :section, :route
+        attr_accessor :hits
+
+
+        def initialize(route, section, max)
+          super()
+          @hits = 0
+          @max = max
+          @section = section
+          @route = route
+          section.visitor = self if section
+        end
+
+        def processNextStart
+          while hits == max
+            starts.next
+          end
+          self.hits += 1
+          starts.next
+        end
+
+        def after_element
+          self.hits = 0
+        end
+
+        def reset
+          self.hits = 0
+        end
+      end
+    end
+  end
+end

data/lib/pacer/filter/loop_filter.rb

@@ -1,12 +1,12 @@
 module Pacer
   module Routes
     module RouteOperations
-      def loop(&block)
-        chain_route :filter => :loop, :looping_route => block
+      def loop(opts = {}, &block)
+        chain_route(opts.merge :filter => :loop, :looping_route => block)
       end
 
-      def all(&block)
-        loop(&block).while do |e, depth|
+      def all(opts = {}, &block)
+        loop(opts, &block).while do |e, depth|
           if depth == 0
             :loop
           else
@@ -60,6 +60,7 @@ module Pacer
     module LoopFilter
       attr_reader :looping_route
       attr_accessor :while_description
+      attr_reader :reverse_loop_route, :reverse_emit_route
 
       def help(section = nil)
         case section
@@ -162,15 +163,42 @@ HELP
       # this could have concurrency problems if multiple instances of the same
       # route
       def deepest!
-        @deepest = true
+        @loop_when_route = @looping_route
+        @reverse_loop_route = false
+        @emit_when_route = @looping_route
+        @reverse_emit_route = true
+        self
+      end
+
+      def loop_when(&block)
+        @loop_when_route = Pacer::Route.block_branch(self, block)
+        @reverse_loop_route = false
+        self
+      end
+
+      def loop_when_not(&block)
+        @loop_when_route = Pacer::Route.block_branch(self, block)
+        @reverse_loop_route = true
+        self
+      end
+
+      def emit_when(&block)
+        @emit_when_route = Pacer::Route.block_branch(self, block)
+        @reverse_emit_route = false
+        self
+      end
+
+      def emit_when_not(&block)
+        @emit_when_route = Pacer::Route.block_branch(self, block)
+        @reverse_emit_route = true
         self
       end
 
       protected
 
       def attach_pipe(end_pipe)
-        if @deepest
-          control_block = deepest_control_block
+        if @loop_when_route or @emit_when_route
+          control_block = route_control_block
         elsif @control_block
           control_block = @control_block
         else
@@ -181,19 +209,37 @@ HELP
         pipe
       end
 
-      def deepest_control_block
+      def expandable(route = nil)
         expando = Pacer::Pipes::ExpandablePipe.new
         empty = java.util.ArrayList.new
         expando.setStarts empty.iterator
-        control_pipe = looping_pipe
+        if route
+          control_pipe = Pacer::Route.pipeline route
+        else
+          control_pipe = Pacer::Pipes::IdentityPipe.new
+        end
         control_pipe.setStarts expando
+        [expando, control_pipe]
+      end
+
+      def route_control_block
+        loop_expando, loop_pipe = expandable @loop_when_route
+        emit_expando, emit_pipe = expandable @emit_when_route
         proc do |el, depth|
-          control_pipe.reset
-          expando.add el.element
-          if control_pipe.hasNext
-            :loop
+          loop_pipe.reset
+          loop_expando.add el.element
+          emit_pipe.reset
+          emit_expando.add el.element
+          if loop_pipe.hasNext ^ reverse_loop_route
+            if emit_pipe.hasNext ^ reverse_emit_route
+              :loop_and_emit
+            else
+              :loop
+            end
           elsif depth > 0
-            :emit
+            if emit_pipe.hasNext ^ reverse_emit_route
+              :emit
+            end
           end
         end
       end

data/lib/pacer/loader.rb

@@ -49,8 +49,7 @@ require 'pacer/function_resolver'
 require 'pacer/route'
 
 require 'pacer/blueprints/tg'
-require 'pacer/blueprints/ruby_graph'
-require 'pacer/blueprints/multi_graph'
+require 'pacer/blueprints/group_vertex'
 
 require 'pacer/blueprints/payload_elements'
 
@@ -79,6 +78,7 @@ require 'pacer/filter/loop_filter'
 require 'pacer/filter/block_filter'
 require 'pacer/filter/object_filter'
 require 'pacer/filter/random_filter'
+require 'pacer/filter/limit_section_filter'
 
 require 'pacer/transform/branch'
 require 'pacer/transform/cap'
@@ -97,6 +97,7 @@ require 'pacer/transform/wrapped_path'
 require 'pacer/transform/scatter'
 require 'pacer/transform/has_count_cap'
 require 'pacer/transform/sort_section'
+require 'pacer/transform/intersect_sections'
 require 'pacer/transform/payload'
 require 'pacer/transform/lookup_ids'
 

data/lib/pacer/route_builder.rb

@@ -42,6 +42,7 @@ module Pacer
     end
 
     def type_def(source, args)
+      source = args.fetch(:based_on, source)
       [
         type_modules(source, args),
         function_modules(source, args),
@@ -51,6 +52,7 @@ module Pacer
     end
 
     def configuration(source, args)
+      source = args.fetch(:based_on, source)
       {
         element_type: element_type(source, args),
         graph: graph(source, args),
@@ -62,7 +64,7 @@ module Pacer
 
     def arguments(source, args)
       args.reject do |key, val|
-        Set[:element_type, :wrapper, :extensions, :modules, :graph, :back, :filter, :side_effect, :transform, :visitor].include? key
+        Set[:element_type, :wrapper, :extensions, :modules, :graph, :back, :filter, :side_effect, :transform, :visitor, :based_on].include? key
       end
     end
 

data/lib/pacer/transform/intersect_sections.rb

@@ -0,0 +1,83 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def intersect_sections(section)
+        chain_route transform: Pacer::Transform::IntersectSections, section: section, operation: :intersection
+      end
+
+      def difference_sections(section)
+        chain_route transform: Pacer::Transform::IntersectSections, section: section, operation: :difference
+      end
+
+      def left_difference_sections(section)
+        chain_route transform: Pacer::Transform::IntersectSections, section: section, operation: :left_difference
+      end
+
+      def right_difference_sections(section)
+        chain_route transform: Pacer::Transform::IntersectSections, section: section, operation: :right_difference
+      end
+    end
+  end
+
+
+  module Transform
+    module IntersectSections
+      # VisitsSection module provides:
+      #  section=
+      #  section_visitor
+      include Pacer::Visitors::VisitsSection
+
+      attr_accessor :operation
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = IntersectSectionPipe.new(section_visitor, operation)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      class IntersectSectionPipe < Pacer::Pipes::RubyPipe
+        attr_reader :section, :reduce_block
+        attr_accessor :to_emit, :current_set, :all_sets
+
+        def initialize(section, operation)
+          super()
+          @section = section
+          case operation
+          when :difference
+            @reduce_block = proc { |a, b| (a - b) + (b - a) }
+          when :left_difference
+            @reduce_block = proc { |a, b| a - b }
+          when :right_difference
+            @reduce_block = proc { |a, b| b - a }
+          when :intersection
+            @reduce_block = proc { |a, b| a.intersection b }
+          end
+          self.all_sets = []
+          if section
+            section.visitor = self
+          else
+            on_element nil
+          end
+        end
+
+        def processNextStart
+          unless to_emit
+            while starts.hasNext
+              current_set << starts.next
+            end
+            self.to_emit = all_sets.reduce(&reduce_block).to_a
+          end
+          raise EmptyPipe.instance if to_emit.empty?
+          to_emit.shift
+        end
+
+        def on_element(x)
+          self.current_set = Set[]
+          all_sets << current_set
+        end
+      end
+    end
+  end
+end

data/lib/pacer/transform/join.rb

@@ -1,197 +1,70 @@
 module Pacer
   module Routes
     module RouteOperations
-      def key(&block)
-        join(:key, &block)
+      def join(&block)
+        chain_route transform: Pacer::Transform::Join, block: block
       end
 
-      def join(name = nil, options = {}, &block)
-        args = {
-          :transform => :join,
-          element_type: :vertex,
-          graph: options.fetch(:multi_graph, Pacer::MultiGraph.blank),
-          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
+      def unjoin
+        map { |g| g[:components] }.scatter extensions: extensions, graph: graph, element_type: element_type
       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
+      attr_reader :key_block, :unique
 
-        include SideEffectPipe rescue nil # may raise exception on reload.
+      def block=(block)
+        @key_block = block
+      end
 
-        attr_accessor :multi_graph, :current_keys, :current_values, :join_on
-        attr_reader :key_expando, :key_end, :values_pipes, :from_graph, :wrapper
+      def uniq
+        @unique = true
+        self
+      end
 
-        def initialize(from_graph, multi_graph)
-          super()
-          @from_graph = from_graph
-          @wrapper = Pacer::Wrappers::WrapperSelector.build from_graph
-          @multi_graph = multi_graph || Pacer::MultiGraph.blank
-          @values_pipes = []
-          @current_keys = []
-          @current_values = []
-        end
+      protected
 
-        def setKeyPipe(from_pipe, to_pipe)
-          @key_expando, @key_end = prepare_aggregate_pipe(from_pipe, to_pipe)
-        end
+      def attach_pipe(end_pipe)
+        pipe = JoinPipe.new(self, key_block, unique)
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
 
-        def addValuesPipe(name, from_pipe, to_pipe)
-          values_pipes << [name, *prepare_aggregate_pipe(from_pipe, to_pipe)]
-        end
+      class JoinPipe < Pacer::Pipes::RubyPipe
+        attr_reader :block, :groups, :unique
+        attr_accessor:to_emit
 
-        def getSideEffect
-          multi_graph
+        def initialize(back, key_block, unique)
+          super()
+          @unique = unique
+          @block = Pacer::Wrappers::WrappingPipeFunction.new back, key_block
         end
 
-        protected
-
         def processNextStart
-          while true
-            if current_keys.empty?
-              element = wrapper.new from_graph, starts.next
-              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.vertex(key) || multi_graph.create_vertex(key)
-              else
-                combined = multi_graph.create_vertex
-              end
-              combined.join_on join_on if join_on
-              combined[:key] = key
-              current_values.each do |key, values|
-                combined.element.append_property_array key, values
-              end
-              return combined
+          unless to_emit
+            coll = unique ? Set : Array
+            groups = Hash.new { |h, k| h[k] = Pacer::GroupVertex.new k, block.graph, block.wrapper, coll.new }
+            while starts.hasNext
+              el = starts.next
+              groups[block.call(el)].add_component el
             end
+            self.to_emit = groups.values
           end
-        end
-
-        def get_keys(element)
-          array = LinkedList.new
-          if key_expando
-            array.addAll next_results(key_expando, key_end, element)
+          if to_emit.empty?
+            raise Pacer::Pipes::EmptyPipe.instance
           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.map do |element|
-            if element.is_a? Pacer::Element
-              wrapper.new from_graph, element
-            else
-              element
-            end
+            to_emit.shift
           end
         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]
+        def reset
+          super
+          self.loaded = false
+          self.to_emit = nil
         end
       end
-
-      include Pacer::Core::SideEffect
-
-      attr_accessor :existing_multi_graph, :key_route, :values_routes, :from_graph
-      attr_writer :join_on
-
-      # FIXME: the pipe changes the graph. This does not fit with the idea of immutable routes.
-      def graph
-        @graph or super
-      end
-
-      def run!
-        super
-        @graph
-      end
-
-      def graph=(g)
-        @graph = g
-      end
-
-      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/parallel.rb

@@ -0,0 +1,17 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def parallel(opts = {}, &block)
+        threads = opts.fetch(:threads, 2)
+        branched = (0..threads).reduce(channel_cap buffer: opts.fetch(:in_buffer, threads)) do |r, n|
+          r.branch do |x|
+            b = block.call x.channel_reader
+            b.channel_cap
+          end
+        end
+        branched.merge_exhaustive.gather.channel_fan_in(buffer: opts.fetch(:out_buffer, threads),
+                                                        based_on: block.call(self))
+      end
+    end
+  end
+end

data/lib/pacer/version.rb

@@ -1,6 +1,6 @@
 module Pacer
   unless const_defined? :VERSION
-    VERSION = "1.3.2"
+    VERSION = "1.3.3"
 
     JAR = "pacer-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"

data/pom.xml

@@ -8,7 +8,7 @@
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <properties>
       <blueprints.version>2.3.0</blueprints.version>
-      <gem.version>1.3.2</gem.version>
+      <gem.version>1.3.3</gem.version>
       <pipes.version>2.3.0</pipes.version>
       <gremlin.version>2.3.0</gremlin.version>
     </properties>

data/spec/support/graph_runner.rb

@@ -45,53 +45,8 @@ class RSpec::GraphRunner
     end
   end
 
-  module RubyGraph
-    def all(usage_style = :read_write, indices = true, &block)
-      super
-      rg(usage_style, indices, &block)
-    end
-
-    def rg(usage_style = :read_write, indices = true, &block)
-      for_graph('rg', usage_style, indices, false, ruby_graph, ruby_graph2, nil, block)
-    end
-
-    protected
-
-    def ruby_graph
-      Pacer::PacerGraph.new Pacer::SimpleEncoder, proc { Pacer::RubyGraph.new }
-    end
-
-    def ruby_graph2
-      Pacer::PacerGraph.new Pacer::SimpleEncoder, proc { Pacer::RubyGraph.new }
-    end
-  end
-
-  module MultiGraph
-    def all(usage_style = :read_write, indices = true, &block)
-      super
-      multigraph(usage_style, indices, &block)
-    end
-
-    def multigraph(usage_style = :read_write, indices = true, &block)
-      for_graph('multigraph', usage_style, indices, false, multi_graph, multi_graph2, nil, block)
-    end
-
-    protected
-
-    def multi_graph
-      Pacer::MultiGraph.blank
-    end
-
-    def multi_graph2
-      Pacer::MultiGraph.blank
-    end
-  end
-
-
   include Stubs
   include Tg
-  #include RubyGraph
-  #include MultiGraph
   include Neo4j if defined? Neo4j
   include Dex if defined? Dex
   include Orient if defined? Orient

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pacer
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: java
 authors:
 - Darrick Wiebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-08-21 00:00:00.000000000 Z
+date: 2013-08-27 00:00:00.000000000 Z
 dependencies: []
 description: Pacer defines routes through a graph and then traverses them very quickly.
 email: darrick@innatesoftware.com
@@ -34,10 +34,10 @@ files:
 - bin/yard
 - bin/yardoc
 - blog/2012-09-18-pacer-1.0.md
+- ideas.rb
 - lib/pacer.rb
-- lib/pacer/blueprints/multi_graph.rb
+- lib/pacer/blueprints/group_vertex.rb
 - lib/pacer/blueprints/payload_elements.rb
-- lib/pacer/blueprints/ruby_graph.rb
 - lib/pacer/blueprints/tg.rb
 - lib/pacer/core/array_route.rb
 - lib/pacer/core/graph.rb
@@ -58,6 +58,7 @@ files:
 - lib/pacer/filter/empty_filter.rb
 - lib/pacer/filter/future_filter.rb
 - lib/pacer/filter/index_filter.rb
+- lib/pacer/filter/limit_section_filter.rb
 - lib/pacer/filter/loop_filter.rb
 - lib/pacer/filter/object_filter.rb
 - lib/pacer/filter/property_filter.rb
@@ -129,10 +130,12 @@ files:
 - lib/pacer/transform/flat_map.rb
 - lib/pacer/transform/gather.rb
 - lib/pacer/transform/has_count_cap.rb
+- lib/pacer/transform/intersect_sections.rb
 - lib/pacer/transform/join.rb
 - lib/pacer/transform/lookup_ids.rb
 - lib/pacer/transform/make_pairs.rb
 - lib/pacer/transform/map.rb
+- lib/pacer/transform/parallel.rb
 - lib/pacer/transform/path.rb
 - lib/pacer/transform/path_tree.rb
 - lib/pacer/transform/payload.rb
@@ -200,7 +203,6 @@ files:
 - spec/pacer/side_effect/is_unique_spec.rb
 - spec/pacer/support/array_list_spec.rb
 - spec/pacer/support/enumerable_spec.rb
-- spec/pacer/transform/join_spec.rb
 - spec/pacer/transform/map_spec.rb
 - spec/pacer/transform/path_spec.rb
 - spec/pacer/transform/path_tree_spec.rb
@@ -218,7 +220,7 @@ files:
 - spec/support/use_transactions.rb
 - spec/tackle/simple_mixin.rb
 - spec/tackle/tinkerpop_graph_mixins.rb
-- lib/pacer-1.3.2-standalone.jar
+- lib/pacer-1.3.3-standalone.jar
 homepage: http://github.com/pangloss/pacer
 licenses:
 - MIT
@@ -280,7 +282,6 @@ test_files:
 - spec/pacer/side_effect/is_unique_spec.rb
 - spec/pacer/support/array_list_spec.rb
 - spec/pacer/support/enumerable_spec.rb
-- spec/pacer/transform/join_spec.rb
 - spec/pacer/transform/map_spec.rb
 - spec/pacer/transform/path_spec.rb
 - spec/pacer/transform/path_tree_spec.rb

data/lib/pacer/blueprints/multi_graph.rb

@@ -1,109 +0,0 @@
-module Pacer
-  class MultiGraph < RubyGraph
-    def self.blank
-      PacerGraph.new SimpleEncoder, proc { MultiGraph.new }
-    end
-
-    protected
-
-    def vertex_class
-      MultiVertex
-    end
-
-    def edge_class
-      RubyEdge
-    end
-  end
-
-
-  class MultiVertex < RubyVertex
-    import com.tinkerpop.pipes.util.iterators.MultiIterator
-
-    def initialize(*args)
-      super
-      @vertex_keys = Set[]
-      @join_keys = @vertex_keys
-    end
-
-    attr_accessor :vertex_keys, :join_keys
-
-    def join_on(keys)
-      if keys.is_a? Enumerable
-        @join_keys = keys.map { |k| k.to_s }.to_set
-      elsif keys
-        @join_keys = Set[keys.to_s]
-      else
-        @join_keys = Set[]
-      end
-    end
-
-    def vertices
-      join_keys.flat_map do |key|
-        @properties[key]
-      end
-    end
-
-    def setProperty(key, value)
-      case value
-      when Pacer::Vertex
-        vertex_keys << key.to_s
-        super
-      when Hash
-        vertex_keys.delete key.to_s
-        super
-      when Enumerable
-        values = value.to_a
-        if values.any? and values.all? { |v| v.is_a? Pacer::Vertex }
-          vertex_keys << key.to_s
-        end
-        super(key, values)
-      else
-        vertex_keys.delete key.to_s
-        super
-      end
-    end
-
-    def append_property_array(key, value)
-      values = value.to_a
-      existing_values = getProperty(key)
-      if existing_values
-        if vertex_keys.include? key and not values.all? { |v| v.is_a? Pacer::Vertex }
-          vertex_keys.delete key.to_s
-        end
-        raise "Can't append to key #{ key } because it is not an Array" unless existing_values.is_a? Array
-      else
-        existing_values = []
-        setProperty(key, existing_values)
-        vertex_keys << key.to_s if values.all? { |v| v.is_a? Pacer::Vertex }
-      end
-      existing_values.concat values
-    end
-
-    def removeProperty(key)
-      vertex_keys.delete key.to_s
-      super
-    end
-
-    def getEdges(direction, *labels)
-      vs = vertices
-      if vs.any?
-        labels = extract_varargs_strings(labels)
-        p = Pacer::Pipes::IdentityPipe.new
-        p.setStarts(MultiIterator.new super, *vs.map { |v| v.getEdges(direction, *labels).iterator })
-        p
-      else
-        super
-      end
-    end
-
-    def inspect
-      s = super
-      s[2] = 'M'
-      s
-    end
-
-    def to_s
-      "m[#{ element_id }]"
-    end
-  end
-end

data/lib/pacer/blueprints/ruby_graph.rb

@@ -1,223 +0,0 @@
-module Pacer
-  class RubyGraph
-    import com.tinkerpop.blueprints.Element
-    import com.tinkerpop.blueprints.Graph
-    import com.tinkerpop.blueprints.Features
-
-    include Graph
-
-    FEATURES = Features.new.tap do |features|
-      features.supportsDuplicateEdges = true
-      features.supportsSelfLoops = true
-      features.supportsSerializableObjectProperty = true
-      features.supportsBooleanProperty = true
-      features.supportsDoubleProperty = true
-      features.supportsFloatProperty = true
-      features.supportsIntegerProperty = true
-      features.supportsPrimitiveArrayProperty = true
-      features.supportsUniformListProperty = true
-      features.supportsMixedListProperty = true
-      features.supportsLongProperty = true
-      features.supportsMapProperty = true
-      features.supportsStringProperty = true
-
-      features.ignoresSuppliedIds = false
-      features.isPersistent = false
-      features.isWrapper = false
-
-      features.supportsIndices = false
-      features.supportsKeyIndices = false
-      features.supportsVertexKeyIndex = false
-      features.supportsEdgeKeyIndex = false
-      features.supportsVertexIndex = false
-      features.supportsEdgeIndex = false
-      features.supportsTransactions = false
-      features.supportsVertexIteration = true
-      features.supportsEdgeIteration = true
-      features.supportsEdgeRetrieval = true
-      features.supportsVertexProperties = true
-      features.supportsEdgeProperties = true
-      features.supportsThreadedTransactions = false
-    end
-
-    def initialize
-      clear
-    end
-
-    def addVertex(id)
-      if id
-        v_id = id
-      else
-        v_id = next_id
-      end
-      raise Pacer::ElementExists if @vertices.key? v_id
-      @vertices[v_id] = vertex_class.new self, v_id
-    end
-
-    def getVertex(id)
-      @vertices[id]
-    end
-
-    def removeVertex(vertex)
-      vertex.getEdges(Pacer::Pipes::BOTH).each do |e|
-        removeEdge e
-      end
-      @vertices.delete vertex.element_id
-    end
-
-    def getVertices
-      @vertices.values.to_iterable
-    end
-
-    def addEdge(id, outVertex, inVertex, label)
-      id ||= next_id
-      raise Pacer::ElementExists if @edges.key? id
-      @edges[id] = edge_class.new self, id, outVertex, inVertex, label
-    end
-
-    def getEdge(id)
-      @edges[id]
-    end
-
-    def removeEdge(edge)
-      @edges.delete edge.element_id
-    end
-
-    def getEdges
-      @edges.values.to_iterable
-    end
-
-    def clear
-      @vertices = {}
-      @edges = {}
-      @next_id = 0
-    end
-
-    def shutdown
-      clear
-    end
-
-    def ==(other)
-      other.equal? self
-    end
-
-    def features
-      FEATURES
-    end
-
-    protected
-
-    def vertex_class
-      RubyVertex
-    end
-
-    def edge_class
-      RubyEdge
-    end
-
-    def next_id
-      @next_id += 1
-    end
-  end
-
-  class RubyElement
-    include com.tinkerpop.blueprints.Element
-
-    def initialize(raw_graph, element_id)
-      @raw_graph = raw_graph
-      @element_id = element_id
-      @properties = {}
-    end
-
-    def getPropertyKeys
-      @properties.keys.to_hashset
-    end
-
-    def getProperty(key)
-      v = @properties[key.to_s]
-      if v.is_a? String
-        v.dup
-      else
-        v
-      end
-    end
-
-    def setProperty(key, value)
-      @properties[key.to_s] = value
-    end
-
-    def removeProperty(key)
-      @properties.delete key.to_s
-    end
-
-    def getId
-      @element_id
-    end
-
-    protected
-
-    attr_reader :raw_graph
-
-    def extract_varargs_strings(labels)
-      if labels.first.is_a? ArrayJavaProxy
-        labels.first.map { |l| l.to_s }
-      else
-        labels
-      end
-    end
-  end
-
-
-  class RubyVertex < RubyElement
-    include com.tinkerpop.blueprints.Vertex
-    import com.tinkerpop.blueprints.util.VerticesFromEdgesIterable
-
-    def getRawVertex
-      self
-    end
-
-    def getVertices(direction, *labels)
-      VerticesFromEdgesIterable.new self, direction, *labels
-    end
-
-    def getEdges(direction, *labels)
-      labels = extract_varargs_strings(labels)
-      if direction == Pacer::Pipes::BOTH
-        edges = raw_graph.getEdges.select do |e|
-          ( (e.getVertex(Pacer::Pipes::IN) == self or e.getVertex(Pacer::Pipes::OUT) == self) and
-            (labels.empty? or labels.include? e.getLabel) )
-        end
-      else
-        edges = raw_graph.getEdges.select { |e| e.getVertex(direction) == self and (labels.empty? or labels.include? e.getLabel) }
-      end
-      Pacer::Pipes::EnumerablePipe.new edges
-    end
-  end
-
-  class RubyEdge < RubyElement
-    include com.tinkerpop.blueprints.Edge
-
-    def initialize(raw_graph, id, out_vertex, in_vertex, label)
-      super(raw_graph, id)
-      @out_vertex = out_vertex
-      @in_vertex = in_vertex
-      @label = label.to_s
-    end
-
-    def getRawEdge
-      self
-    end
-
-    def getLabel()
-      @label
-    end
-
-    def getVertex(direction)
-      if direction == Pacer::Pipes::OUT
-        @out_vertex
-      else
-        @in_vertex
-      end
-    end
-  end
-end

data/spec/pacer/transform/join_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-Run.tg :read_only do
-  use_pacer_graphml_data :read_only
-
-  describe Pacer::Transform::Join do
-    context 'with no key or value specified' do
-      subject { graph.v.join }
-      its(:count) { should == 7 }
-      specify 'each element should be a node' do
-        subject.each do |group|
-          group[:key].should be_a Pacer::Vertex
-          group.property_keys.to_a.should == ['key']
-        end
-      end
-    end
-
-    context 'with key_route only' do
-      subject { graph.v.join(:key) { |r| r[:type] } }
-
-      its(:count) { should == 7 }
-      its(:to_a) { should_not be_empty }
-      specify 'each result should have one value' do
-        subject.each do |group|
-          group[:key].should be_a String
-          group.property_keys.to_a.should == ['key']
-        end
-      end
-    end
-
-    context 'with key_route and value route' do
-      let(:route) { graph.v.join(:key) { |r| r[:type] }.join }
-      subject { route }
-
-      specify 'each result should reflect an element' do
-        subject.each.zip(graph.v.to_a) do |group, e|
-          group[:key].should == e[:type]
-          group.property_keys.to_set.should == Set['key', 'values']
-          group[:values].last.element_id.should == e.element_id
-        end
-      end
-
-      context '#multigraph' do
-        subject { route.multigraph }
-        it { should be_a Pacer::PacerGraph }
-        its(:blueprints_graph) { should be_a Pacer::MultiGraph }
-
-        its('v.count') { should == 3 }
-
-
-        context 'person' do
-          subject { route.multigraph.vertex 'person' }
-          it 'should hove 2 values' do
-            subject[:values].length.should == 2
-          end
-          it { subject[:values].should == graph.v(:type => 'person').to_a }
-        end
-
-        context 'project' do
-          subject { route.multigraph.vertex 'project' }
-          it 'should hove 2 values' do
-            subject[:values].length.should == 4
-          end
-          it { subject[:values].should == graph.v(:type => 'project').to_a }
-        end
-
-        context 'reduced to a count' do
-          subject do
-            route.multigraph.v.reduce({}) do |h, v|
-              h[v.element_id] = v[:values].count
-              h
-            end
-          end
-          specify 'it should have a count for values' do
-            subject['project'].should == 4
-            subject['person'].should == 2
-            subject['group'].should == 1
-          end
-        end
-
-        context 'reduced to a string' do
-          subject do
-            route.multigraph.v.reduce({}) do |h, v|
-              h[v.element_id] = v[:values].map { |v| v[:name] }.join ', '
-              h
-            end
-          end
-          specify do
-            subject['project'].should == 'blueprints, pipes, pacer, gremlin'
-            subject['person'].should == 'pangloss, okram'
-            subject['group'].should == 'tinkerpop'
-          end
-        end
-      end
-    end
-
-    context 'with a key block that returns a literal value' do
-      subject { graph.v.join { |r| r[:type] }.key { |r| r[:type].length } }
-      its(:count) { should == 7 }
-      specify 'each value should have a numeric key' do
-        subject.each do |v|
-          v[:key].should == v.element_id
-          v[:key].should == v[:values].first.length
-        end
-      end
-    end
-
-    context 'with values_maps' do
-      let(:counted_group) do
-        graph.v.join(:count) { |r| r.out_e.counted.cap }.
-          join(:out_e, &:out_e).
-          key { |r| r[:type] }
-      end
-      subject do
-        counted_group.multigraph
-      end
-      its('v.count') { should == 3 }
-      specify { counted_group.count.should == 7 }
-      specify 'combine(:count) should group the counts in a hash' do
-        hash = Hash[subject.v[[:key, :count]].to_a]
-        hash.should == {"project"=>[0, 1, 3, 2], "person"=>[1, 3], "group"=>[4]}
-      end
-
-      specify 'reduce summarizes edge labels for each type' do
-        result = Hash[subject.v.map { |v| [v.element_id, v[:out_e].group_count { |e| e.label }] }.to_a]
-        result.should == {"project" => {"uses"     => 5, "modelled_on" => 1},
-                          "person"  => {"wrote"    => 4},
-                          "group"   => {"projects" => 3, "member"      => 1}}
-      end
-
-      its(:blueprints_graph) { should be_a Pacer::MultiGraph }
-
-      specify do
-        counted_group.inspect.should ==
-          "#<GraphV -> V-Join(#<V -> Obj(type) -> decode>: {:count=>#<V -> outE -> Obj-Cap(E-Counted)>, :out_e=>#<V -> outE>})>"
-      end
-    end
-  end
-end