pacer 0.9.1.1-java → 1.0.0-java

data/spec/pacer/core/route_spec.rb

@@ -101,68 +101,45 @@ describe Pacer::Core::Route do
     [].to_route.should be_empty
   end
 
-  describe '#add_extension' do
-    context 'Object' do
-      subject { base_route.add_extension Object }
-      its(:extensions) { should be_empty }
-    end
+  its(:extensions) { should == [] }
 
-    context 'SimpleMixin' do
-      subject { base_route.add_extension Tackle::SimpleMixin }
-      its(:extensions) { should include(Tackle::SimpleMixin) }
-      its('extensions.count') { should == 1 }
-      it 'should have extension method' do
-        subject.route_mixin_method.should be_true
-      end
-      it { should be_a Tackle::SimpleMixin::Route }
-      its(:first) { should == 1 }
-    end
-  end
+  context 'mocked' do
+    before(:all) { JRuby.objectspace = true }
+    after(:all) { JRuby.objectspace = false }
 
-  its(:extensions) { should == Set[] }
+    subject { base_route.add_extensions([TP::Person]) }
 
-  describe '#extensions=' do
-    before :all do
-      JRuby.objectspace = true
-    end
-    after :all do
-      JRuby.objectspace = false
-    end
-    it 'should add one extension' do
-      mock(subject).add_extension(Tackle::SimpleMixin)
-      subject.extensions = Tackle::SimpleMixin
-    end
-    it 'should add multiple extensions' do
-      mock(subject).add_extension(Tackle::SimpleMixin)
-      mock(subject).add_extension(TP::Person)
-      subject.extensions = [Tackle::SimpleMixin, TP::Person]
-    end
-    it 'should accumulate extensions' do
-      subject.add_extension TP::Person
-      subject.extensions.should == Set[TP::Person]
-      subject.extensions = Tackle::SimpleMixin
-      subject.extensions.should == Set[TP::Person, Tackle::SimpleMixin]
+    describe '#extensions=' do
+      it 'should add multiple extensions' do
+        subject.add_extensions [Tackle::SimpleMixin, TP::Person]
+      end
     end
-  end
 
-  describe '#add_extensions' do
-    before :all do
-      JRuby.objectspace = true
-    end
-    after :all do
-      JRuby.objectspace = false
-    end
-    it 'should add use add_extension' do
-      mock(subject).add_extension(Tackle::SimpleMixin)
-      mock(subject).add_extension(TP::Person)
-      result = subject.add_extensions [Tackle::SimpleMixin, TP::Person]
-    end
-    it 'should add multiple extensions' do
-      subject.add_extensions [Tackle::SimpleMixin, TP::Person]
-      subject.extensions.should == Set[Tackle::SimpleMixin, TP::Person]
+    describe '#add_extensions' do
+      it 'should add multiple extensions' do
+        mock(subject).chain_route(extensions: [Tackle::SimpleMixin, TP::Person])
+        subject.add_extensions [Tackle::SimpleMixin, TP::Person]
+      end
+      it 'should be chainable' do
+        subject.add_extensions([Tackle::SimpleMixin]).should be_a Pacer::Route
+      end
+      it 'should accumulate extensions' do
+        subject.extensions.should == [TP::Person]
+        r = subject.add_extensions [Tackle::SimpleMixin]
+        subject.extensions.should == [TP::Person]
+        r.extensions.should == [TP::Person, Tackle::SimpleMixin]
+      end
     end
-    it 'should be chainable' do
-      subject.add_extensions([Tackle::SimpleMixin]).should be subject
+
+    describe '#set_extensions' do
+      it 'should be chainable' do
+        subject.set_extensions([Tackle::SimpleMixin]).should be_a Pacer::Route
+      end
+      it 'should replace extensions' do
+        r = subject.set_extensions Tackle::SimpleMixin
+        subject.extensions.should == [TP::Person]
+        r.extensions.should == [Tackle::SimpleMixin]
+      end
     end
   end
 
@@ -178,14 +155,14 @@ describe Pacer::Core::Route do
     end
   end
 
-  its(:element_type) { should == Object }
+  its(:element_type) { should == :object }
 
   describe 'custom pipe' do
     context 'with pipe args' do
       let(:mock_type) { Pacer::Pipes::EnumerablePipe }
       let(:pipe_args) { [['a', 1]] }
 
-      subject { Pacer::Route.new :element_type => :object,
+      subject { Pacer::RouteBuilder.current.chain nil, :element_type => :object,
                   :pipe_class => mock_type, :pipe_args => pipe_args }
 
       it 'should create the pipe' do

data/spec/pacer/filter/empty_filter_spec.rb

@@ -5,24 +5,23 @@ Run.tg(:read_only) do
 
   describe Pacer::Filter::EmptyFilter do
     let(:origin) { graph.v(Tackle::SimpleMixin) }
-    let(:empty) { Pacer::Route.empty(origin) }
-    subject { empty }
+    subject { Pacer::Route.empty(origin) }
 
     its(:graph) { should == graph }
     its(:element_type) { should == graph.element_type(:vertex) }
-    its(:extensions) { should == Set[Tackle::SimpleMixin] }
+    its(:extensions) { should == [Tackle::SimpleMixin] }
     its(:build_pipeline) { should be_nil }
 
     context 'with route built on it' do
-      subject { empty.filter(name: 'joe') }
+      subject { Pacer::Route.empty(origin).filter(name: 'joe') }
       its(:graph) { should == graph }
       its(:element_type) { should == graph.element_type(:vertex) }
-      its(:extensions) { should == Set[Tackle::SimpleMixin] }
+      its(:extensions) { should == [Tackle::SimpleMixin] }
       its(:inspect) { should == '#<V -> V-Property(name=="joe")>' }
       it 'should create a pipeline with only the pipe added to it' do
         start_pipe, end_pipe = subject.send :build_pipeline
         start_pipe.should == end_pipe
-        start_pipe.should be_a Java::ComTinkerpopPipesFilter::PropertyFilterPipe
+        start_pipe.should be_a Java::ComTinkerpopGremlinPipesFilter::PropertyFilterPipe
       end
     end
   end

data/spec/pacer/filter/future_filter_spec.rb

@@ -48,10 +48,7 @@ Run.tg(:read_only) do
   describe Pacer::Filter::FutureFilter, '(negative)' do
     context 'artists who did not write songs' do
       def people
-        [ "Daryl_Hall",
-          "Hall_and_Oates",
-          "Peter_Krug"
-        ].to_route.map(:graph => graph, :element_type => :vertex) { |name| graph.v(:name => name).first }
+        graph.v.lookahead { |v| v[:name].only [ "Daryl_Hall", "Hall_and_Oates", "Peter_Krug" ]  }
       end
       def wrote_songs
         people.lookahead { |v| v.in_e(:written_by) }
@@ -67,9 +64,12 @@ Run.tg(:read_only) do
       it 'should have 3 people' do
         people.count.should == 3
       end
-      
+
       it 'should have 2 songwriters' do
         wrote_songs.count.should == 2
+        wrote_songs[:name].to_set.should == Set[
+          "Daryl_Hall",
+          "Peter_Krug"]
       end
 
       it 'should combine the two types of artists to get the full list' do
@@ -85,12 +85,12 @@ Run.tg(:read_only) do
     let!(:x) { graph.create_vertex :type => 'b' }
     let!(:y) { graph.create_vertex :type => 'b' }
     before do
-      x.add_edges_to :has, [a,b,c] 
-      y.add_edges_to :has, c 
+      x.add_edges_to :has, [a,b,c]
+      y.add_edges_to :has, c
     end
 
     subject do
-      graph.v(type:'b').lookahead { |r| r.out(:has).only([a,b]) } 
+      graph.v(type:'b').lookahead { |r| r.out(:has).only([a,b]) }
     end
     its(:to_a) { should == [x] }
   end

data/spec/pacer/filter/loop_filter_spec.rb

@@ -4,6 +4,121 @@ Run.tg(:read_only) do
   use_pacer_graphml_data(:read_only)
 
   describe Pacer::Filter::LoopFilter do
+    describe '#loop' do
+      it 'is a ClientError if no control block is specified' do
+        lambda do
+          graph.v.loop { |v| v.out }.in.to_a
+        end.should raise_error Pacer::ClientError
+      end
+
+      it 'is a ClientError if no control block is specified' do
+        lambda do
+          graph.v.loop { |v| v.out }.to_a
+        end.should raise_error Pacer::ClientError
+      end
+
+      describe 'control block' do
+        it 'should wrap elements' do
+          yielded = false
+          graph.v.loop { |v| v.out }.while do |el|
+            el.should be_a Pacer::Wrappers::VertexWrapper
+            yielded = true
+          end.first
+          yielded.should be_true
+        end
+
+        it 'should wrap path elements' do
+          yielded = false
+          graph.v.loop { |v| v.out }.while do |el, depth, path|
+            el.should be_a Pacer::Wrappers::VertexWrapper
+            depth.should == 0
+            path.should be_a Array
+            path.length.should == 1
+            path.each do |e|
+              e.should be_a Pacer::Wrappers::VertexWrapper
+            end
+            yielded = true
+          end.first
+          yielded.should be_true
+        end
+
+        context 'project tree' do
+          let(:depths) do
+            [ 0,       # pangloss
+              1,       # pacer
+              2, 2, 2, # gremlin, pipes, blueprints
+              3, 3, 3, # gremlin>blueprints, gremlin>pipes, pipes>blueprints
+              4        # gremlin>pipes>blueprints
+            ]
+          end
+
+          let(:route) do
+            pangloss.loop { |v| v.out }.while do |el, depth, path|
+              depth.should == depths.shift
+              path.length.should == depth + 1
+              true
+            end
+          end
+
+          it 'should exhaust the depths list' do
+            route.to_a
+            depths.should be_empty
+          end
+
+          it 'should have the right results' do
+            route[:name].to_a.should == %w[
+              pangloss
+              pacer
+              gremlin pipes blueprints
+              blueprints pipes blueprints
+              blueprints
+            ]
+          end
+        end
+
+        let(:paths) do
+          [ %w[ pangloss ],
+            %w[ pangloss pacer ],
+            %w[ pangloss pacer gremlin ],
+            %w[ pangloss pacer pipes ],
+            %w[ pangloss pacer blueprints ],
+            %w[ pangloss pacer gremlin blueprints ],
+            %w[ pangloss pacer gremlin pipes ],
+            %w[ pangloss pacer pipes blueprints ],
+            %w[ pangloss pacer gremlin pipes blueprints ] ]
+        end
+
+        it 'should have correct paths with control block paths' do
+          route = pangloss.
+            loop { |v| v.out }.
+            while { |el, depth, path| true }.
+            paths
+          route.collect { |p| p.map { |e| e[:name] } }.should == paths
+        end
+
+        it 'should have correct paths without control block paths' do
+          route = pangloss.
+            loop { |v| v.out }.
+            while { |el| true }.
+            paths
+          route.collect { |p| p.map { |e| e[:name] } }.should == paths
+        end
+
+        it 'should loop or emit or loop_and_emit as needed' do
+          route = pangloss.loop { |v| v.out }.while do |el, depth|
+            if el[:name] == 'pacer'
+              :loop_and_emit
+            elsif depth == 4
+              :emit
+            else
+              :loop
+            end
+          end
+          route[:name].to_a.should == %w[ pacer blueprints ]
+        end
+      end
+    end
+
     describe '#repeat' do
       it 'should apply the route part twice' do
         route = graph.v.repeat(2) { |tail| tail.out_e.in_v }.inspect
@@ -16,14 +131,13 @@ Run.tg(:read_only) do
       end
 
       describe 'with a range' do
-        let(:start) { graph.vertex(0).v }
-        subject { start.repeat(1..3) { |tail| tail.out_e.in_v[0] } }
+        let(:start) { graph.vertex(0) }
+        subject { start.repeat(1..3) { |tail| tail.out_e.in_v }[:name] }
 
         it 'should be equivalent to executing each path separately' do
-          pending
-          subject.to_a.should == [start.out_e.in_v.first,
-                                  start.out_e.in_v.out_e.in_v.first,
-                                  start.out_e.in_v.out_e.in_v.out_e.in_v.first]
+          subject.to_a.should == [start.out_e.in_v[:name].to_a,
+                                  start.out_e.in_v.out_e.in_v[:name].to_a,
+                                  start.out_e.in_v.out_e.in_v.out_e.in_v[:name].to_a].flatten
         end
       end
     end

data/spec/pacer/filter/object_filter_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Pacer::Filter::ObjectFilter do
+  it '#is' do
+    [1, 2, 3, 2, 3].to_route.is(2).to_a.should == [2, 2]
+  end
+
+  it '#is_not' do
+    [1, 2, 3, 2, 3].to_route.is_not(2).to_a.should == [1, 3, 3]
+  end
+
+  it '#compact' do
+    [1, nil, 2, 3].to_route.compact.to_a.should == [1, 2, 3]
+  end
+end

data/spec/pacer/filter/property_filter/filters_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+module Pacer::Filter::PropertyFilter
+
+  Run.tg do
+    describe Filters do
+      subject { filters }
+
+      context 'no properties' do
+        let(:filters) { Pacer::Route.filters [] }
+
+        its(:any?) { should be_false }
+      end
+
+      context 'no properties' do
+        let(:filters) { Pacer::Route.filters [Tackle::SimpleMixin] }
+
+        its(:any?) { should be_true }
+        its(:extensions_only?) { should be_true }
+        its(:extensions) { should == [Tackle::SimpleMixin] }
+        its(:route_modules) { should be_empty }
+        its(:wrapper) { should be_nil }
+        its(:blocks) { should be_empty }
+        its(:properties) { should be_empty }
+      end
+
+      context 'simple properties' do
+        let(:filters) { Pacer::Route.filters([name: 'Darrick', nickname: 'pangloss']) }
+
+        its(:any?) { should be_true }
+        its(:extensions_only?) { should be_false }
+        its(:extensions) { should be_empty }
+        its(:route_modules) { should be_empty }
+        its(:wrapper) { should be_nil }
+        its(:blocks) { should be_empty }
+        its(:properties) { should == [ %w[ name Darrick ], %w[ nickname pangloss ] ] }
+      end
+
+      context 'with extensions' do
+        let(:filters) { Pacer::Route.filters([TP::Person, name: 'Darrick', nickname: 'pangloss']) }
+
+        its(:any?) { should be_true }
+        its(:extensions) { should == [TP::Person] }
+        its(:extensions_only?) { should be_false }
+        its(:route_modules) { should be_empty }
+        its(:wrapper) { should be_nil }
+        its(:blocks) { should be_empty }
+        its(:properties) { should == [ %w[ type person ], %w[ name Darrick ], %w[ nickname pangloss ] ] }
+
+        context '+ indices' do
+          before do
+            graph.create_key_index 'name', :vertex
+            graph.create_key_index 'type', :vertex
+            graph.create_key_index 'nickname', :vertex
+            filters.graph = graph
+            filters.indices = graph.indices
+            filters.choose_best_index = true
+            filters.search_manual_indices = true
+          end
+
+          def find_index
+            @idx, @key, @value = filters.best_index(:vertex)
+          end
+
+          it 'should use the automatic index' do
+            find_index
+            @idx.should be_a Pacer::Filter::KeyIndex
+          end
+
+          it 'should use the first key and value' do
+            find_index
+            @key.should == 'type'
+            @value.should == 'person'
+          end
+
+          context '+ data' do
+            before do
+              5.times { graph.create_vertex type: 'person', name: 'Someone', nickname: nil }
+              graph.create_vertex type: 'person', name: 'Darrick', nickname: 'therealdarrick'
+            end
+
+            it 'should use the non-empty key when searching manual indices' do
+              find_index
+              @key.should == 'name'
+              @value.should == 'Darrick'
+            end
+
+            it 'should use the empty key' do
+              filters.search_manual_indices = false
+              find_index
+              @key.should == 'nickname'
+              @value.should == 'pangloss'
+            end
+
+            context '+ match' do
+              before do
+                3.times { graph.create_vertex type: 'person', name: 'Immitator', nickname: 'pangloss' }
+              end
+
+              let!(:match) do
+                graph.create_vertex type: 'person', name: 'Darrick', nickname: 'pangloss'
+              end
+
+              it 'should use the smallest key' do
+                find_index
+                @key.should == 'name'
+                @value.should == 'Darrick'
+              end
+            end
+          end
+        end
+      end
+
+      context 'with route module' do
+        # TODO: should this feature be removed?
+        let(:filters) { Pacer::Route.filters [TP::Pangloss] }
+
+        its(:any?) { should be_true }
+        its(:extensions_only?) { should be_false }
+        its(:extensions) { should == [TP::Pangloss] }
+        its(:route_modules) { should == [TP::Pangloss] }
+        its(:wrapper) { should be_nil }
+        its(:blocks) { should be_empty }
+        its(:properties) { should be_empty }
+      end
+
+      context 'with manual index' do
+        let(:filters) { Pacer::Route.filters [tokens: { short: '555555' }, name: 'Darrick'] }
+
+        its(:any?) { should be_true }
+        its(:extensions) { should be_empty }
+        its(:route_modules) { should be_empty }
+        its(:wrapper) { should be_nil }
+        its(:blocks) { should be_empty }
+        its(:properties) { should == [['tokens', short: '555555'], %w[ name Darrick ]] }
+
+        context '+ indices' do
+          let!(:token_index) { graph.index 'tokens', :vertex, create: true }
+          before do
+            filters.graph = graph
+            filters.indices = graph.indices
+            filters.choose_best_index = true
+            filters.search_manual_indices = true
+          end
+
+          def find_index
+            @idx, @key, @value = filters.best_index(:vertex)
+          end
+
+          it 'should use the automatic index' do
+            find_index
+            @idx.should be token_index.index
+          end
+
+          it 'should use the first key and value' do
+            find_index
+            @key.should == 'short'
+            @value.should == '555555'
+          end
+
+          it 'should store the best_index_value' do
+            find_index
+            filters.best_index_value.should == ['tokens', short: '555555']
+          end
+        end
+      end
+    end
+  end
+end

data/spec/pacer/filter/property_filter_spec.rb

@@ -14,7 +14,7 @@ Run.tg(:read_only) do
       its(:to_a) { should == graph.v('type' => 'person').to_a }
       its(:to_a) { should == graph.v.where('type = "person"').to_a }
       its(:count) { should == 2 }
-      its(:extensions) { should == Set[] }
+      its(:extensions) { should == [] }
       it 'should have the correct type' do
         subject[:type].uniq.to_a.should == ['person']
       end
@@ -25,7 +25,7 @@ Run.tg(:read_only) do
       its(:to_a) { should == graph.v('type' => 'person', 'name' => 'pangloss').to_a }
       its(:to_a) { should == graph.v.where('type = "person" and name = "pangloss"').to_a }
       its(:count) { should == 1 }
-      its(:extensions) { should == Set[] }
+      its(:extensions) { should == [] }
       it 'should have the correct type' do
         subject[:type].first.should == 'person'
       end
@@ -37,7 +37,7 @@ Run.tg(:read_only) do
     context 'v(TP::Person)' do
       subject { graph.v(TP::Person) }
       its(:count) { should == 2 }
-      its(:extensions) { should == Set[TP::Person] }
+      its(:extensions) { should == [TP::Person] }
       its(:to_a) { should == graph.v(:type => 'person').to_a }
       its(:to_a) { should_not == graph.v(:type => 'project').to_a }
     end
@@ -45,26 +45,26 @@ Run.tg(:read_only) do
     context 'v(TP::Project)' do
       subject { graph.v(TP::Project) }
       its(:count) { should == 4 }
-      its(:extensions) { should == Set[TP::Project] }
+      its(:extensions) { should == [TP::Project] }
       its(:to_a) { should == graph.v(:type => 'project').to_a }
     end
 
     context 'v(TP::Person, TP::Project)' do
       subject { graph.v(TP::Person, TP::Project) }
       its(:count) { should == 0 }
-      its(:extensions) { should == Set[TP::Person, TP::Project] }
+      its(:extensions) { should == [TP::Person, TP::Project] }
     end
 
     context 'v(Tackle::SimpleMixin)' do
       subject { graph.v(Tackle::SimpleMixin) }
       its(:count) { should == 7 }
-      its(:extensions) { should == Set[Tackle::SimpleMixin] }
+      its(:extensions) { should == [Tackle::SimpleMixin] }
     end
 
     context 'v(:Tackle::SimpleMixin, :name => "pangloss")' do
       subject { graph.v(Tackle::SimpleMixin, :name => 'pangloss') }
       its(:count) { should == 1 }
-      its(:extensions) { should == Set[Tackle::SimpleMixin] }
+      its(:extensions) { should == [Tackle::SimpleMixin] }
     end
 
     context 'reversed params' do
@@ -78,30 +78,33 @@ Run.tg(:read_only) do
     end
 
     context 'with wrapper' do
-      let(:exts) { Set[Tackle::SimpleMixin, TP::Project] }
+      let(:exts) { [Tackle::SimpleMixin, TP::Project] }
       let(:wrapper_class) { Pacer::Wrappers::VertexWrapper.wrapper_for exts }
 
       describe 'v(wrapper_class)' do
         subject { graph.v(wrapper_class) }
         its(:wrapper) { should == wrapper_class }
-        its(:extensions) { should == exts.to_a }
+        its(:extensions) { should == [] }
+        its(:all_extensions) { should ==  exts }
         its(:first) { should be_a wrapper_class }
       end
 
       describe 'v(wrapper_class, Pacer::Utils::TSort)' do
         subject { graph.v(wrapper_class, Pacer::Utils::TSort) }
         its(:wrapper) { should == wrapper_class }
-        its(:extensions) { should == (exts.to_a + [Pacer::Utils::TSort]) }
+        its(:extensions) { should == [Pacer::Utils::TSort] }
+        its(:all_extensions) { should == (exts + [Pacer::Utils::TSort]) }
         it { should_not be_empty }
         its('first.class') { should_not == wrapper_class }
-        its('first.class.extensions') { should == exts.to_a + [Pacer::Utils::TSort] }
+        its('first.class.extensions') { should == exts + [Pacer::Utils::TSort] }
       end
 
       describe 'v(wrapper_class, :name => "pacer")' do
         subject { graph.v(wrapper_class, :name => 'pacer') }
         its(:count) { should == 1 }
         its(:wrapper) { should == wrapper_class }
-        its(:extensions) { should == exts.to_a }
+        its(:all_extensions) { should == exts }
+        its(:extensions) { should == [] }
         its(:first) { should be_a wrapper_class }
         its(:filters) { should_not be_nil }
         its('filters.wrapper') { should == wrapper_class }

data/spec/pacer/filter/uniq_filter_spec.rb

@@ -6,7 +6,7 @@ Run.tg(:read_only) do
   describe 'UniqFilter' do
     describe '#uniq' do
       it 'should be a route' do
-        graph.v.uniq.should be_an_instance_of(Pacer::Route)
+        graph.v.uniq.should be_a(Pacer::Route)
       end
 
       it 'results should be unique' do