pacer 0.9.1.1-java

data/spec/pacer/core/route_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe Pacer::Core::Route do
+  let(:base_route) { [1, 2, 3].to_route }
+  subject { base_route }
+
+  its(:back) { should be_nil }
+
+  # TODO: move graph-specific stuff to Pacer::Core::Graph::(something)
+
+  it { should be_root }
+
+  its(:hide_elements) { should_not be_true }
+
+  describe '#route' do
+    subject { base_route.route }
+    it { should equal(base_route) }
+    its(:hide_elements) { should be_true }
+  end
+
+  its(:vars) { should == {} }
+
+
+  describe '#each' do
+    context 'without block' do
+      subject { base_route.each }
+      it { should be_a com.tinkerpop.pipes.Pipe }
+    end
+  end
+
+  describe '#inspect' do
+    subject { base_route.inspect }
+    it { should == '#<Obj>' }
+
+    describe 'with route elements visible' do
+      before :all do
+        # objectspace is required for rr mocks.
+        @cols = Pacer.columns
+        @limit = Pacer.inspect_limit
+        JRuby.objectspace = true
+        Pacer.hide_route_elements = false
+      end
+      after :all do
+        Pacer.columns = @cols
+        Pacer.inspect_limit = @limit
+        JRuby.objectspace = false
+        Pacer.hide_route_elements = true
+      end
+      specify 'default setting' do
+        mock(base_route).puts '1 2 3'
+        mock(base_route).puts 'Total: 3'
+        base_route.inspect.should == '#<Obj>'
+      end
+      specify '4 column display' do
+        Pacer.columns = 4
+        mock(base_route).puts '1 2'
+        mock(base_route).puts '3'
+        mock(base_route).puts 'Total: 3'
+        base_route.inspect.should == '#<Obj>'
+      end
+      specify 'aligned columns' do
+        Pacer.columns = 6
+        route = [-1, 0, 1, 2].to_route
+        mock(route).puts '-1 0 '
+        mock(route).puts '1  2 '
+        mock(route).puts 'Total: 4'
+        route.inspect.should == '#<Obj>'
+      end
+      specify '2 item limit' do
+        Pacer.inspect_limit = 2
+        dont_allow(base_route).puts(anything)
+        base_route.inspect.should == '#<Obj>'
+      end
+    end
+
+    describe 'with pipe with no args' do
+      subject do
+        r = base_route.uniq
+        r.route_name = nil
+        r.inspect
+      end
+      it { should == "#<Obj -> Obj(Duplicate)>" }
+    end
+  end
+
+  describe '#==' do
+    it { should == subject }
+    it { should_not == [].to_route }
+    it { should == [1, 2, 3].to_route }
+    it { should_not == [1, 3, 2].to_route }
+    it { should_not == subject.select { true } }
+    # TODO: consider technique to compare blocks?
+    #it { subject.select { true }.should == subject.select { true } }
+    it { subject.select { true }.should_not == subject.select { false } }
+    it { subject.select { true }.should_not == subject.reject { false } }
+    it { r = subject.select { true }; r.should == r }
+  end
+
+  it { should_not be_empty }
+  it 'should be empty' 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
+
+    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
+
+  its(:extensions) { should == Set[] }
+
+  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]
+    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]
+    end
+    it 'should be chainable' do
+      subject.add_extensions([Tackle::SimpleMixin]).should be subject
+    end
+  end
+
+  describe '#set_pipe_source' do
+    before { base_route.set_pipe_source [:a, :b] }
+    its(:to_a) { should == [:a, :b] }
+
+    it 'should not change the structure' do
+      route = base_route.select { |o| o == 1 or o == :a }.select { true }
+      route.to_a.should == [:a]
+      route.set_pipe_source [1, 2, 3]
+      route.to_a.should == [1]
+    end
+  end
+
+  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,
+                  :pipe_class => mock_type, :pipe_args => pipe_args }
+
+      it 'should create the pipe' do
+        subject.send(:build_pipeline).last.to_a.should == ['a', 1]
+      end
+      its(:pipe_args) { should == [['a', 1]] }
+    end
+  end
+end

data/spec/pacer/filter/collection_filter_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Pacer::Filter::CollectionFilter do
+  context 'on an array of objects' do
+    let(:route) { [1,2,3].to_route }
+
+    it 'should filter out an element' do
+      route.except(2).to_a.should == [1,3]
+    end
+
+    it 'should filter out an array of elements' do
+      route.except([2,3]).to_a.should == [1]
+    end
+
+    it 'should filter out the elements from another route' do
+      route.except([2,3].to_route).to_a.should == [1]
+    end
+  end
+end

data/spec/pacer/filter/empty_filter_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+Run.tg(:read_only) do
+  use_pacer_graphml_data :read_only
+
+  describe Pacer::Filter::EmptyFilter do
+    let(:origin) { graph.v(Tackle::SimpleMixin) }
+    let(:empty) { Pacer::Route.empty(origin) }
+    subject { empty }
+
+    its(:graph) { should == graph }
+    its(:element_type) { should == graph.element_type(:vertex) }
+    its(:extensions) { should == Set[Tackle::SimpleMixin] }
+    its(:build_pipeline) { should be_nil }
+
+    context 'with route built on it' do
+      subject { empty.filter(name: 'joe') }
+      its(:graph) { should == graph }
+      its(:element_type) { should == graph.element_type(:vertex) }
+      its(:extensions) { should == Set[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
+      end
+    end
+  end
+end

data/spec/pacer/filter/future_filter_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+Run.tg(:read_only) do
+  use_grateful_dead_data :read_only
+
+  describe Pacer::Filter::FutureFilter do
+    let(:artists) { graph.v(:type => 'artist') }
+
+    context 'artists who wrote songs' do
+      let(:writers) { artists.lookahead { |v| v.in_e(:written_by) } }
+
+      it 'should have less writers than artists' do
+        writers.count.should < artists.count
+      end
+
+      it 'should not be duplicated' do
+        writers.uniq.to_a.should == writers.to_a
+      end
+    end
+
+    context 'prolific songwriters' do
+      let(:names) { artists.lookahead { |v| v.in_e(:written_by)[30] }[:name].to_set }
+
+      let(:names_over_30) do
+        # this is a bit slow...it's how I got the list
+        # hash = Hash.new 0
+        # graph.v(:type => 'song').each { |v| v.out_e(:written_by).in_v[:name].each { |name| hash[name] += 1 } }
+        # hash.select { |name, count| count > 30 }.map { |name, _| name }.to_set
+        Set['Traditional', 'Hunter', 'Bob_Dylan']
+      end
+
+      it 'should only include writers who have written at least 31 songs' do
+        names.should == names_over_30
+      end
+    end
+
+    context 'multi-step traversal' do
+      # Artists who wrote both covers and original songs...???...
+
+      subject do
+        artists.lookahead { |v| v.in(:written_by, :song_type => 'cover').out(:written_by).in(:written_by).where('song_type != "cover"') }
+      end
+
+      it { subject.count.should == 5 }
+    end
+  end
+
+  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 }
+      end
+      def wrote_songs
+        people.lookahead { |v| v.in_e(:written_by) }
+      end
+      def no_songs
+        people.neg_lookahead { |v| v.in_e(:written_by) }
+      end
+
+      it 'should have a non songwriting artist' do
+        no_songs.count.should == 1
+      end
+
+      it 'should have 3 people' do
+        people.count.should == 3
+      end
+      
+      it 'should have 2 songwriters' do
+        wrote_songs.count.should == 2
+      end
+
+      it 'should combine the two types of artists to get the full list' do
+        (wrote_songs.element_ids.to_a + no_songs.element_ids.to_a).sort.should == people.element_ids.to_a.sort
+      end
+    end
+  end
+
+  describe 'bug: ruby pipe was not calling reset on the next pipe in the chain' do
+    let!(:a) { graph.create_vertex :type => 'a' }
+    let!(:b) { graph.create_vertex :type => 'a' }
+    let!(:c) { graph.create_vertex :type => 'a' }
+    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 
+    end
+
+    subject do
+      graph.v(type:'b').lookahead { |r| r.out(:has).only([a,b]) } 
+    end
+    its(:to_a) { should == [x] }
+  end
+end

data/spec/pacer/filter/loop_filter_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+Run.tg(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe Pacer::Filter::LoopFilter do
+    describe '#repeat' do
+      it 'should apply the route part twice' do
+        route = graph.v.repeat(2) { |tail| tail.out_e.in_v }.inspect
+        route.should == graph.v.out_e.in_v.out_e.in_v.inspect
+      end
+
+      it 'should apply the route part 3 times' do
+        route = graph.v.repeat(3) { |tail| tail.out_e.in_v }.inspect
+        route.should == graph.v.out_e.in_v.out_e.in_v.out_e.in_v.inspect
+      end
+
+      describe 'with a range' do
+        let(:start) { graph.vertex(0).v }
+        subject { start.repeat(1..3) { |tail| tail.out_e.in_v[0] } }
+
+        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]
+        end
+      end
+    end
+  end
+end

data/spec/pacer/filter/property_filter_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+Run.tg(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe Pacer::Filter::PropertyFilter do
+    context 'v()' do
+      subject { graph.v }
+      its(:count) { should == 7 }
+    end
+
+    context 'v(:type => "person")' do
+      subject { graph.v(:type => 'person') }
+      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[] }
+      it 'should have the correct type' do
+        subject[:type].uniq.to_a.should == ['person']
+      end
+    end
+
+    context 'v(:type => "person", :name => "pangloss")' do
+      subject { graph.v(:type => 'person', :name => 'pangloss') }
+      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[] }
+      it 'should have the correct type' do
+        subject[:type].first.should == 'person'
+      end
+      it 'should have the correct name' do
+        subject[:name].first.should == 'pangloss'
+      end
+    end
+
+    context 'v(TP::Person)' do
+      subject { graph.v(TP::Person) }
+      its(:count) { should == 2 }
+      its(:extensions) { should == Set[TP::Person] }
+      its(:to_a) { should == graph.v(:type => 'person').to_a }
+      its(:to_a) { should_not == graph.v(:type => 'project').to_a }
+    end
+
+    context 'v(TP::Project)' do
+      subject { graph.v(TP::Project) }
+      its(:count) { should == 4 }
+      its(:extensions) { should == Set[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] }
+    end
+
+    context 'v(Tackle::SimpleMixin)' do
+      subject { graph.v(Tackle::SimpleMixin) }
+      its(:count) { should == 7 }
+      its(:extensions) { should == Set[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] }
+    end
+
+    context 'reversed params' do
+      subject { graph.v.v(TP::Pangloss, Tackle::SimpleMixin) }
+      its(:count) { should == 1 }
+    end
+
+    context 'reversed params' do
+      subject { graph.v.v(TP::Pangloss) }
+      its(:count) { should == 1 }
+    end
+
+    context 'with wrapper' do
+      let(:exts) { Set[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(: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]) }
+        it { should_not be_empty }
+        its('first.class') { should_not == wrapper_class }
+        its('first.class.extensions') { should == exts.to_a + [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(:first) { should be_a wrapper_class }
+        its(:filters) { should_not be_nil }
+        its('filters.wrapper') { should == wrapper_class }
+      end
+    end
+  end
+end

data/spec/pacer/filter/random_filter_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+Run.tg(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe 'RandomFilter' do
+    describe '#random' do
+      it { Set[*graph.v.random(1)].should == Set[*graph.v] }
+      it { graph.v.random(0).to_a.should == [] }
+      it 'should usually have some number of elements more than 1 and less than all' do
+        range = 1..(graph.v.count - 1)
+        best2of3 = (0...3).map { graph.v.random(0.5).count }
+        best2of3.select { |num| range.include? num }.length.should >= 2
+      end
+    end
+  end
+end

data/spec/pacer/filter/uniq_filter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+Run.tg(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe 'UniqFilter' do
+    describe '#uniq' do
+      it 'should be a route' do
+        graph.v.uniq.should be_an_instance_of(Pacer::Route)
+      end
+
+      it 'results should be unique' do
+        graph.e.in_v.group_count(:name).values.sort.last.should > 1
+        graph.e.in_v.uniq.group_count(:name).values.sort.last.should == 1
+      end
+    end
+  end
+end

data/spec/pacer/filter/where_filter_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+
+Run.tg(:read_only) do
+  use_pacer_graphml_data(:read_only)
+
+  describe Pacer::Filter::WhereFilter do
+    context "name = 'blueprints'" do
+      subject { graph.v.where("name = 'blueprints'")[:name] }
+      its(:count) { should == 1 }
+      its(:first) { should == 'blueprints' }
+    end
+
+    context "name != nil" do
+      subject { graph.v.where("name != nil") }
+      its(:count) { should == 7 }
+    end
+
+    context "name = nil" do
+      subject { graph.v.where("name = nil") }
+      its(:count) { should == 0 }
+    end
+
+    context 'with number' do
+      before do
+        n = 0
+        graph.v.each { |v| v[:number] = n += 1 }
+      end
+
+      context "number = 1" do
+        subject { graph.v.where("number = 1") }
+        its(:count) { should == 1 }
+      end
+
+      context "number >= 1" do
+        subject { graph.v.where("number >= 2") }
+        its(:count) { should == 6 }
+      end
+
+      context "number % 2 == 0" do
+        subject { graph.v.where("number % 2 == 0") }
+        its(:count) { should == 3 }
+      end
+
+      context "number % 2 == 1" do
+        subject { graph.v.where("number % 2 == 0 + 1") }
+        its(:count) { should == 4 }
+      end
+    end
+
+    context "name = 'blueprints' or name = 'pipes'" do
+      subject { graph.v.where("name = 'blueprints' or name = 'pipes'")[:name] }
+      its(:count) { should == 2 }
+      its(:to_a) { should == ['blueprints', 'pipes'] }
+    end
+
+    context "type = 'person' and (name = 'blueprints' or name = 'pipes')" do
+      subject { graph.v.where("type = 'person' and (name = 'blueprints' or name = 'pipes')") }
+      its(:count) { should == 0 }
+    end
+
+    context "type = 'project' and (name = 'blueprints' or name = 'pipes') or true" do
+      subject { graph.v.where("type = 'project' and (name = 'blueprints' or name = 'pipes') or true") }
+      its(:count) { should == 7 }
+    end
+
+    context "type = :type and (name = 'blueprints' or name = 'pipes') with 'person'" do
+      subject { graph.v.where("type = :type and (name = 'blueprints' or name = 'pipes')", :type => 'person') }
+      its(:count) { should == 0 }
+    end
+
+    context "type = :type and (name = 'blueprints' or name = 'pipes') with 'project'" do
+      subject { graph.v.where("type = :type and (name = 'blueprints' or name = 'pipes')", :type => 'project') }
+      its(:count) { should == 2 }
+    end
+
+    context ":type == type and (name = 'blueprints' or name = 'pipes') with 'project'" do
+      subject { graph.v.where(":type == type and (name = 'blueprints' or name = 'pipes')", :type => 'project') }
+      its(:count) { should == 2 }
+    end
+
+    context "yield :fun" do
+      subject { graph.v.where("yield :fun", :fun => proc { |v| v[:name] == 'blueprints' }) }
+      its(:count) { should == 1 }
+    end
+
+    context "type = :type and (yield(:fun) or name = :name1) with 'person'" do
+      subject { graph.v.where("type = :type and (yield(:fun) or name = :name2)",
+                              :type => 'project', :fun => proc { |v| v[:name] == 'blueprints' }, :name2 => 'pipes') }
+      its(:count) { should == 2 }
+    end
+  end
+end