pacer 0.9.1.1-java → 1.0.0-java

data/spec/pacer/route/mixin/base_spec.rb

@@ -7,7 +7,7 @@ Run.all do
         subject { graph.v.send(:build_pipeline) }
         it { should be_a(Array) }
         its(:count) { should == 2 }
-        its(:first) { should be_a(com.tinkerpop.pipes.transform.VerticesPipe) }
+        its(:first) { should be_a(Pacer::Pipes::VerticesPipe) }
         specify { subject.first.should equal(subject.last) }
       end
 
@@ -29,19 +29,19 @@ Run.all do
       subject { route }
 
       its(:inspect) do
-        should be_one_of "#<V-Index(name: \"gremlin\") -> :grem -> inE(:wrote)>",
-                         "#<GraphV -> V-Property(name==\"gremlin\") -> :grem -> inE(:wrote)>"
+        should be_one_of "#<V-Index(name: \"gremlin\") -> V-Section -> :grem -> inE(:wrote)>",
+                         "#<GraphV -> V-Property(name==\"gremlin\") -> V-Section -> :grem -> inE(:wrote)>"
       end
       its(:out_v) { should_not be_nil }
     end
 
-    context "graph.v(:name => 'gremlin').as(:grem).in_e(:wrote)" do
+    context "graph.v.in_e.out_v(Tackle::SimpleMixin)" do
       let(:route) { graph.v.in_e.out_v(Tackle::SimpleMixin) }
       subject { route }
 
       its(:in_e) { should_not be_nil }
       its(:to_a) { should == [] }
-      its(:extensions) { should == Set[Tackle::SimpleMixin] }
+      its(:extensions) { should == [Tackle::SimpleMixin] }
     end
 
     context "graph.v(:name => 'darrick')" do
@@ -49,7 +49,8 @@ Run.all do
       before { setup_data }
       subject { graph.v(:name => 'darrick') }
 
-      its('iterator.next') { should == v1 }
+      # iterator is a protected method... It is the raw iterator before wrapping stuff is added.
+      its('iterator.next') { should == v1.element }
       its(:to_a) { should == [v1] }
     end
 
@@ -58,7 +59,7 @@ Run.all do
         subject { graph.v.element_ids.send(:build_pipeline) }
         it { should be_a(Array) }
         its(:count) { should == 2 }
-        its(:first) { should be_a(com.tinkerpop.pipes.transform.VerticesPipe) }
+        its(:first) { should be_a(Pacer::Pipes::VerticesPipe) }
         its(:last) { should be_a(Pacer::Pipes::IdPipe) }
       end
 
@@ -74,8 +75,9 @@ Run.all do
           begin
             subject.next
             fail 'expected exception to be raised'
-          rescue NativeException => e
-            e.cause.inspect.should == 'java.util.NoSuchElementException'
+          rescue Pacer::EmptyPipe, java.util.NoSuchElementException
+          else
+            'Got the wrong kind of exception.'.should be_false
           end
         end
       end
@@ -84,7 +86,7 @@ Run.all do
         use_simple_graph_data
         before { setup_data }
         subject { graph.v.element_ids.to_a }
-        its(:sort) { should == [v0.element_id, v1.element_id].sort }
+        its(:sort) { should == [v0, v1].to_route(based_on: graph.v).element_ids.to_a.sort }
       end
     end
   end
@@ -103,16 +105,14 @@ Run.all(:read_only) do
         r = r.out_e(:wrote) { |e| true }
         r = r.in_v
         r = r.is_not(:grem)
-        r.inspect.should be_one_of "#<V-Index(name: \"gremlin\") -> :grem -> inE(:wrote) -> outV -> outE(:wrote) -> E-Property(&block) -> inV -> V-Property(&block)>",
-                                   "#<GraphV -> V-Property(name==\"gremlin\") -> :grem -> inE(:wrote) -> outV -> outE(:wrote) -> E-Property(&block) -> inV -> V-Property(&block)>"
+        r.inspect.should be_one_of "#<V-Index(name: \"gremlin\") -> V-Section -> :grem -> inE(:wrote) -> outV -> outE(:wrote) -> E-Property(&block) -> inV -> V-Property(&block)>",
+                                   "#<GraphV -> V-Property(name==\"gremlin\") -> V-Section -> :grem -> inE(:wrote) -> outV -> outE(:wrote) -> E-Property(&block) -> inV -> V-Property(&block)>"
       end
     end
 
     describe '#to_a' do
-      it { Set[*graph.v].should == Set[*graph.getVertices] }
-      it { Set[*(graph.v.to_a)].should == Set[*graph.getVertices] }
-      it { Set[*graph.e].should == Set[*graph.getEdges] }
-      it { Set[*(graph.e.to_a)].should == Set[*graph.getEdges] }
+      it { Set[*graph.v.collect(&:element)].should == Set[*graph.blueprints_graph.getVertices] }
+      it { Set[*graph.e.collect(&:element)].should == Set[*graph.blueprints_graph.getEdges] }
     end
 
     describe '#root?' do
@@ -131,6 +131,7 @@ Run.all(:read_only) do
     describe 'block filter' do
       it { graph.v { false }.count.should == 0 }
       it { graph.v { true }.count.should == graph.v.count }
+      it { graph.v { |v| v.graph.should == graph }.first }
       it { graph.v { |v| v.out_e.none? }[:name].to_a.should == ['blueprints'] }
 
       it 'should work with paths' do
@@ -185,7 +186,7 @@ shared_examples_for Pacer::Core::Route do
   let(:result_type) { raise 'specify :vertex, :edge, :mixed or :object' }
   let(:back) { nil }
   let(:info) { nil }
-  let(:route_extensions) { Set[] }
+  let(:route_extensions) { [] }
 
   context 'without data' do
     subject { route }
@@ -211,7 +212,10 @@ shared_examples_for Pacer::Core::Route do
     end
 
     describe '#result' do
-      before { graph.checkpoint }
+      before do
+        c = example.metadata[:graph_commit]
+        c.call if c
+      end
       subject { route.result }
       its(:element_type) { should == route.element_type }
     end
@@ -337,33 +341,30 @@ shared_examples_for Pacer::Core::Route do
       its(:element_type) { should == graph.element_type(result_type) }
     end
 
-    describe '#add_extension' do
+    describe '#add_extensions' do
       # Note that this mixin doesn't need to include
       # versions of each test with extensions applied because
       context '(SimpleMixin)' do
-        before do
-          @orig_ancestors = route.class.ancestors
-          r = route.add_extension Tackle::SimpleMixin
-          r.should equal(route)
+        subject do
+          route.add_extensions [Tackle::SimpleMixin]
         end
+        its(:back) { should equal(route) }
         its(:extensions) { should include(Tackle::SimpleMixin) }
         it { should respond_to(:route_mixin_method) }
       end
 
       context '(Object)' do
-        before do
-          @orig_ancestors = route.class.ancestors
-          route.add_extension Object
+        subject do
+          route.add_extensions [Object]
         end
-        its(:extensions) { should_not include(Object) }
+        its(:extensions) { should include(Object) }
       end
 
-      context '(invalid)' do
-        before do
-          @orig_ancestors = route.class.ancestors
-          route.add_extension :invalid
+      context '(:invalid)' do
+        subject do
+          route.add_extensions [:invalid]
         end
-        its(:extensions) { should_not include(:invalid) }
+        its(:extensions) { should include(:invalid) }
       end
     end
 
@@ -388,11 +389,11 @@ Run.all(:read_only) do
   use_pacer_graphml_data(:read_only)
   context 'vertices with extension' do
     it_uses Pacer::Core::Route do
-      let(:back) { nil }
-      let(:route) { graph.v.filter(Tackle::SimpleMixin) }
+      let(:back) { graph.v }
+      let(:route) { back.filter(Tackle::SimpleMixin) }
       let(:number_of_results) { 7 }
       let(:result_type) { :vertex }
-      let(:route_extensions) { Set[Tackle::SimpleMixin] }
+      let(:route_extensions) { [Tackle::SimpleMixin] }
     end
   end
 end

data/spec/pacer/route/mixin/route_operations_spec.rb

@@ -24,7 +24,7 @@ Run.tg(:read_only) do
       context '(0..1)' do
         subject { graph.v[:type].most_frequent(0..1) }
         it { should be_a Pacer::Core::Route }
-        its(:element_type) { should == Object }
+        its(:element_type) { should == :object }
         its(:to_a) { should == ['project', 'person'] }
       end
 
@@ -60,14 +60,14 @@ Run.tg do
           count = 0
           index = graph.v.build_index('new_index', 'k', 'name')
           index.should_not be_nil
-          index.get('k', 'pangloss').count.should == 1
+          index.all('k', 'pangloss').count.should == 1
         end
 
         it 'should build the index with wrapped elements' do
           count = 0
           index = graph.v(TP::Person).build_index('new_index', 'k', 'name')
           index.should_not be_nil
-          index.get('k', 'pangloss').count.should == 1
+          index.all('k', 'pangloss').count.should == 1
         end
 
         it 'should do nothing if there are no elements' do
@@ -77,51 +77,9 @@ Run.tg do
         end
 
         after do
-          graph.dropIndex 'new_index'
+          graph.drop_index 'new_index'
         end
       end
     end
   end
 end
-
-
-# Modernize these old tests:
-describe RouteOperations do
-  before :all do
-    @g = Pacer.tg 'spec/data/pacer.graphml'
-  end
-
-  describe '#as' do
-    it 'should set the variable to the correct node' do
-      vars = Set[]
-      @g.v.as(:a_vertex).in_e(:wrote) { |edge| vars << edge.vars[:a_vertex] }.count
-      vars.should == Set[*@g.e.e(:wrote).in_v]
-    end
-
-    it 'should not break path generation (simple)' do
-      who = nil
-      r = @g.v.as(:who).in_e(:wrote).out_v.v { |v|
-        who = v.vars[:who]
-      }.paths
-      r.each do |path|
-        path.to_a[0].should == @g
-        path.to_a[1].should == who
-        path.length.should == 4
-      end
-    end
-
-    it 'should not break path generation' do
-      who_wrote_what = nil
-      r = @g.v.as(:who).in_e(:wrote).as(:wrote).out_v.as(:what).v { |v|
-        who_wrote_what = [@g, v.vars[:who], v.vars[:wrote], v.vars[:what]]
-      }.paths
-      r.each do |path|
-        path.to_a.should == who_wrote_what
-      end
-    end
-  end
-
-  describe :delete! do
-    it 'should not try to delete an element twice'
-  end
-end

data/spec/pacer/side_effect/as_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+Run.all(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe '#as' do
+    it 'should set the variable to the correct node' do
+      vars = Set[]
+      graph.v.as(:a_vertex).in_e(:wrote) { |edge| vars << edge.vars[:a_vertex] }.count
+      vars.should == Set[*graph.e.e(:wrote).in_v]
+    end
+
+    it 'should not break path generation (simple)' do
+      who = nil
+      r = graph.v.as(:who).in_e(:wrote).out_v.v { |v|
+        who = v.vars[:who]
+      }.paths
+      r.each do |path|
+        path.to_a[0].should == who
+        path.length.should == 3
+      end
+    end
+
+    it 'should not break path generation' do
+      who_wrote_what = nil
+      r = graph.v.as(:who).in_e(:wrote).as(:wrote).out_v.as(:what).v { |v|
+        who_wrote_what = [v.vars[:who], v.vars[:wrote], v.vars[:what]]
+      }.paths
+      r.each do |path|
+        path.to_a.should == who_wrote_what
+      end
+    end
+  end
+end

data/spec/pacer/support/enumerable_spec.rb

@@ -74,22 +74,22 @@ describe Enumerable do
         context 'with no arguments' do
           subject { [1, 'a'].to_route }
           it { should be_a Pacer::Core::Route }
-          its(:element_type) { should == Object }
+          its(:element_type) { should == :object }
           its(:to_a) { should == [1, 'a'] }
         end
 
         context 'based on an object route' do
           subject { [1, 'a'].to_route(:based_on => graph.v[:name]) }
           it { should be_a Pacer::Core::Route }
-          its(:element_type) { should == Object }
+          its(:element_type) { should == :object }
           its(:to_a) { should == [1, 'a'] }
         end
 
         context 'based on an object route with an extension' do
-          subject { [1, 'a'].to_route(:based_on => graph.v[:name].add_extension(Tackle::SimpleMixin)) }
+          subject { [1, 'a'].to_route(:based_on => graph.v[:name].add_extensions([Tackle::SimpleMixin])) }
           it { should be_a Pacer::Core::Route }
-          its(:extensions) { should == Set[Tackle::SimpleMixin] }
-          its(:element_type) { should == Object }
+          its(:extensions) { should == [Tackle::SimpleMixin] }
+          its(:element_type) { should == :object }
           its(:to_a) { should == [1, 'a'] }
         end
       end
@@ -105,7 +105,7 @@ describe Enumerable do
 
         context 'based on an extended element route' do
           subject { elements.to_route(:based_on => graph.v(Tackle::SimpleMixin)) }
-          its(:extensions) { should == Set[Tackle::SimpleMixin] }
+          its(:extensions) { should == [Tackle::SimpleMixin] }
           its(:element_type) { should == graph.element_type(:vertex) }
           its(:to_a) { should == elements }
         end

data/spec/pacer/transform/join_spec.rb

@@ -9,7 +9,7 @@ Run.tg :read_only do
       its(:count) { should == 7 }
       specify 'each element should be a node' do
         subject.each do |group|
-          group[:key].should be_a graph.element_type(:vertex)
+          group[:key].should be_a Pacer::Vertex
           group.property_keys.to_a.should == ['key']
         end
       end
@@ -42,7 +42,8 @@ Run.tg :read_only do
 
       context '#multigraph' do
         subject { route.multigraph }
-        it { should be_a Pacer::MultiGraph }
+        it { should be_a Pacer::PacerGraph }
+        its(:blueprints_graph) { should be_a Pacer::MultiGraph }
 
         its('v.count') { should == 3 }
 
@@ -127,10 +128,11 @@ Run.tg :read_only do
                           "group"   => {"projects" => 3, "member"      => 1}}
       end
 
-      its(:inspect) { should == "#<MultiGraph>" }
-      
+      its(:inspect) { should == "#<PacerGraph>" }
+      its(:blueprints_graph) { should be_a Pacer::MultiGraph }
+
       specify do
-        counted_group.inspect.should == 
+        counted_group.inspect.should ==
           "#<GraphV -> V-Join(#<V -> Obj(type)>: {:count=>#<V -> outE -> Obj-Cap(E-Counted)>, :out_e=>#<V -> outE>})>"
       end
     end

data/spec/pacer/transform/map_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+shared_examples_for '#map' do
+  describe 'simple element route' do
+    subject do
+      c = 0
+      source.map { c += 1 }
+    end
+    its(:first) { should == 1 }
+    its(:element_type) { should == :object }
+  end
+
+  describe 'with extensions' do
+    let(:extended) { source.add_extensions([Tackle::SimpleMixin]) }
+
+    subject { extended.map { |v| v.extensions } }
+
+    its(:first) { should == [Tackle::SimpleMixin, Pacer::Extensions::BlockFilterElement] }
+    its(:element_type) { should == :object }
+
+    context 'with vertex result type' do
+      subject { extended.map(element_type: :vertex) { |v| v } }
+      its(:element_type) { should == :vertex }
+      its(:extensions) { should == [] }
+    end
+
+    context 'with extended vertex result type' do
+      let(:exts) { [] }
+      subject { extended.map(element_type: :vertex, extensions: TP::Person) { |v| exts << v.extensions; v } }
+      its(:element_type) { should == :vertex }
+      its(:extensions) { should == [TP::Person] }
+      it 'should use the source - not the result - extension in the block' do
+        v = subject.first
+        v.extensions.should == [TP::Person]
+        exts.first.should == [Tackle::SimpleMixin, Pacer::Extensions::BlockFilterElement]
+      end
+    end
+  end
+end
+
+Run.tg :read_only do
+  use_pacer_graphml_data :read_only
+
+  context 'on route' do
+    it_uses '#map' do
+      let(:source) { graph.v }
+    end
+  end
+
+  context 'on element' do
+    it_uses '#map' do
+      let(:source) { pangloss }
+    end
+  end
+end

data/spec/pacer/transform/path_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Pacer::Transform::Path do
   before :all do
-    @g = Pacer.tg 'spec/data/pacer.graphml'
+    @g = Pacer.tg
+    Pacer::GraphML.import @g, 'spec/data/pacer.graphml'
   end
 
   describe '#paths' do
@@ -16,11 +17,13 @@ describe Pacer::Transform::Path do
 
     it 'should include all elements traversed' do
       @g.v.out_e.in_v.paths.each do |path|
-        path[0].should == @g
-        path[1].should be_a(Pacer::TinkerVertex)
-        path[2].should be_a(Pacer::TinkerEdge)
-        path[3].should be_a(Pacer::TinkerVertex)
-        path.length.should == 4
+        path[0].should be_a(Pacer::Wrappers::VertexWrapper)
+        path[1].should be_a(Pacer::Wrappers::EdgeWrapper)
+        path[2].should be_a(Pacer::Wrappers::VertexWrapper)
+        path[0].element.should be_a(com.tinkerpop.blueprints.impls.tg.TinkerVertex)
+        path[1].element.should be_a(com.tinkerpop.blueprints.impls.tg.TinkerEdge)
+        path[2].element.should be_a(com.tinkerpop.blueprints.impls.tg.TinkerVertex)
+        path.length.should == 3
       end
     end
 
@@ -37,18 +40,30 @@ describe Pacer::Transform::Path do
   end
 
   describe '#subgraph' do
-    before do
-      @sg = @g.v(:type => 'person').out_e.in_v(:type => 'project').subgraph
+    context 'original' do
+      before do
+        @sg = @g.v(:type => 'person').out_e.in_v(:type => 'project').subgraph
 
-      @vertices = @g.v(:type => 'person').to_a + @g.v(:type => 'project').to_a
-      @edges = @g.v(:type => 'person').out_e(:wrote)
+        @vertices = @g.v(:type => 'person').to_a + @g.v(:type => 'project').to_a
+        @edges = @g.v(:type => 'person').out_e(:wrote)
+      end
+
+      it { Set[*@sg.v.element_ids].should == Set[*@vertices.collect { |v| v.element_id }] }
+      it { Set[*@sg.e.element_ids].should == Set[*@edges.collect { |e| e.element_id }] }
+
+      it { @sg.e.labels.uniq.to_a.should == ['wrote'] }
+      it { Set[*@sg.v.collect { |v| v.properties }].should == Set[*@vertices.collect { |v| v.properties }] }
     end
 
-    it { Set[*@sg.v.element_ids].should == Set[*@vertices.collect { |v| v.element_id }] }
-    it { Set[*@sg.e.element_ids].should == Set[*@edges.collect { |e| e.element_id }] }
+    context 'with both_v' do
+      before do
+        @sg = @g.v(:type => 'person').in_e.both_v.subgraph
+        @vertices = [@g.vertex(5), @g.vertex(6)]
+        @edges = [@g.edge(11)]
+      end
 
-    it { @sg.e.labels.uniq.to_a.should == ['wrote'] }
-    it { Set[*@sg.v.collect { |v| v.properties }].should == Set[*@vertices.collect { |v| v.properties }] }
+      it { Set[*@sg.v.element_ids].should == Set[*@vertices.collect { |v| v.element_id }] }
+      it { Set[*@sg.e.element_ids].should == Set[*@edges.collect { |e| e.element_id }] }
+    end
   end
 end
-

data/spec/pacer/transform/process_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+shared_examples_for '#process' do
+  describe 'simple element route' do
+    subject do
+      c = 0
+      source.process { c += 1 }
+    end
+    its(:first) { should == source.first }
+    its(:element_type) { should == :vertex }
+  end
+
+  describe 'with extensions' do
+    let(:extended) { source.add_extensions([Tackle::SimpleMixin]) }
+    let(:exts) { Set[] }
+
+    subject { extended.process { |v| exts << v.extensions } }
+
+    its('first.extensions') { should == [Tackle::SimpleMixin] }
+
+    it 'should have the right extensions in the block' do
+      subject.first
+      exts.first.should == [Tackle::SimpleMixin, Pacer::Extensions::BlockFilterElement]
+    end
+  end
+end
+
+Run.tg :read_only do
+  use_pacer_graphml_data :read_only
+
+  context 'on route' do
+    it_uses '#process' do
+      let(:source) { graph.v }
+    end
+  end
+
+  context 'on element' do
+    it_uses '#process' do
+      let(:source) { pangloss }
+    end
+  end
+end

data/spec/pacer/transform/sort_section_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+Run.tg :read_only do
+  use_pacer_graphml_data :read_only
+
+  let(:unsorted) { graph.v.out.out }
+
+  describe 'sort by name' do
+    let(:by_name) do
+      graph.v.section(:x).out.out.sort_section(:x) { |v| v[:name] }
+    end
+
+    it 'should have the same elements' do
+      by_name.group_count.should == unsorted.group_count
+    end
+
+    it 'should have 3 elements in the path' do
+      by_name.paths.each do |path|
+        path.length.should == 3
+      end
+    end
+  end
+
+  describe 'sort with more info' do
+    let(:unsorted) { graph.v.out.out }
+    let(:with_path) do
+      graph.v.section(:x).out.out.sort_section(:x) do |v, section, path|
+        [path[-2][:name], v[:name]]
+      end
+    end
+
+    it 'should have the same elements' do
+      with_path.group_count.should == unsorted.group_count
+    end
+
+    it 'should have 3 elements in the path' do
+      with_path.paths.each do |path|
+        path.length.should == 3
+      end
+    end
+
+    it 'should yield' do
+      yielded = false
+      graph.v.section(:x).out_e.in_v.sort_section(:x) do |v, section, path|
+        yielded = true
+        path.should be_a Array
+        path.length.should == 3
+        a, b, c = path
+        path.each { |e| e.graph.should_not be_nil }
+        section.graph.should_not be_nil
+        a.should == section
+        a.should be_a Pacer::Wrappers::VertexWrapper
+        b.should be_a Pacer::Wrappers::EdgeWrapper
+        c.should == v
+        c.should be_a Pacer::Wrappers::VertexWrapper
+      end.first
+      yielded.should be_true
+    end
+  end
+
+  describe 'sort by values' do
+    let :by_value do
+      graph.v.section(:x).out.out.element_ids.sort_section(:x)
+    end
+    it 'should work with no block' do
+      by_value.to_a.should_not be_empty
+    end
+  end
+
+  it 'should put groups into the correct order' do
+    # depends on the order of graph.v(type: 'project') ...
+    route = graph.v(type: 'project').section(:proj).out[:name].sort_section(:proj)
+    route.to_a.should == %w[
+      blueprints
+      blueprints
+      gremlin
+      pipes
+      blueprints
+      pipes
+    ]
+  end
+end