pacer 2.0.13-java → 2.0.14-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13555fbf36509b247945a23559f60d2b5eddb0e4
-  data.tar.gz: 258b4dd295d67b91dfbb8aa29969b7bef809fb2b
+  metadata.gz: 516ac17e78965aa3d2e83cd8abcdd698a6a65df2
+  data.tar.gz: 42d4eec909e091059251f379296f5b4c118f008f
 SHA512:
-  metadata.gz: 7ed67f63063e560b02926a116fcace7dd285d7522d2f8165ccc659b34df9a66756c6bb31013e37a540844781a58fad4ebb6a2eb99dbec68ab772ed9d75e341a2
-  data.tar.gz: d1b69243930b7906702a5c67f5b2359b2dbf9f3b61bcf26c68a3b8bfe9b2cf51ab0a060277c9a13faee0efc5732279e9f70ba15a647e384f021ada7603bf2bdf
+  metadata.gz: 1e2ed8eb71d0e19d61adc9e324b6405c75b0aa710944f4e4fa41e542075673584ec63f618149c93f973325a8bc5b04ff8751b4e19de3fe457a65e61e745e5e1d
+  data.tar.gz: 6c6ecde3e79970241e660108de1bb4bdb8055df7f94a84a152902273ed4f36521e7dd861e98510875b5de4cc95088e691a49f12b04a84f257e3316ecb28d6266

data/lib/pacer/core/graph/element_route.rb

@@ -9,7 +9,7 @@ module Pacer::Core::Graph
     # @yield [ElementWrapper] filter proc, see {Pacer::Route#property_filter}
     # @return [ElementRoute] the same type and extensions as the source route.
     def filter(*filters, &block)
-      Pacer::Route.property_filter(self, filters, block)
+      Pacer::Route.property_filter(self, filters, block, true)
     end
 
     # v is undefined for edge routes.

data/lib/pacer/core/graph/graph_route.rb

@@ -9,7 +9,7 @@ module Pacer::Core::Graph
       route = chain_route :element_type => :vertex,
         :pipe_class => Pacer::Pipes::VerticesPipe,
         :route_name => 'GraphV'
-      Pacer::Route.property_filter(route, filters, block)
+      Pacer::Route.property_filter(route, filters, block, true)
     end
 
     # Returns a new route to all graph edges. Standard filter options.
@@ -18,7 +18,7 @@ module Pacer::Core::Graph
       route = chain_route :element_type => :edge,
         :pipe_class => Pacer::Pipes::EdgesPipe,
         :route_name => 'GraphE'
-      Pacer::Route.property_filter(route, filters, block)
+      Pacer::Route.property_filter(route, filters, block, true)
     end
 
     def filter(*args)

data/lib/pacer/core/graph/mixed_route.rb

@@ -10,7 +10,7 @@ module Pacer::Core::Graph
         :pipe_args => Pacer::Vertex,
         :wrapper => wrapper,
         :extensions => extensions
-      Pacer::Route.property_filter(route, args, block)
+      Pacer::Route.property_filter(route, args, block, true)
     end
 
     # Pass through only edges.
@@ -20,7 +20,7 @@ module Pacer::Core::Graph
         :pipe_args => Pacer::Edge,
         :wrapper => wrapper,
         :extensions => extensions
-      Pacer::Route.property_filter(route, args, block)
+      Pacer::Route.property_filter(route, args, block, true)
     end
 
     def filter(*args, &block)
@@ -29,7 +29,7 @@ module Pacer::Core::Graph
 
     def mixed(*args, &block)
       route = chain_route :pipe_class => Pacer::Pipes::IdentityPipe
-      Pacer::Route.property_filter(route, args, block)
+      Pacer::Route.property_filter(route, args, block, true)
     end
 
     # Out edges from matching vertices.

data/lib/pacer/filter/property_filter.rb

@@ -28,21 +28,9 @@ module Pacer
         filters.is_a? Pacer::Filter::PropertyFilter::Filters
       end
 
-      def property_filter_before(base, args, block)
-        filters = Pacer::Route.edge_filters(base.graph, args)
-        filters.blocks = [block] if block
-        args = chain_args(filters)
-        if filters.extensions_only? and base.is_a? Route
-          yield base.chain_route(args)
-        elsif filters and filters.any?
-          yield base.chain_route(args.merge!(filter: :property, filters: filters))
-        else
-          yield base
-        end
-      end
-
-      def property_filter(base, args, block)
+      def property_filter(base, args, block, strict = false)
         filters = Pacer::Route.edge_filters(base.graph, args)
+        filters.use_lookup! if strict
         filters.blocks = [block] if block
         args = chain_args(filters)
         if filters.extensions_only? and base.is_a? Route

data/lib/pacer/version.rb

@@ -1,5 +1,5 @@
 module Pacer
-  VERSION = "2.0.13"
+  VERSION = "2.0.14"
   # Clients may optionally define the following constants in the Pacer namespace:
   # - LOAD_JARS : set to false to manage jar loading in the client. Be sure to load the jars defined in JARFILES.
   # - LOCKJAR_LOCK_OPTS : set some options to be passed to LockJar.lock (ie. :lockfile, :download_artifacts, :local_repo)

data/spec/pacer/blueprints/neo4j2_spec.rb

@@ -7,6 +7,12 @@ module Neo2Spec
     end
   end
 
+  class FastPerson < Pacer::Wrappers::VertexWrapper
+    def self.route_conditions(graph)
+      { type: 'person' }
+    end
+  end
+
   class Frog < Pacer::Wrappers::VertexWrapper
     def self.route_conditions(graph)
       { frog: 'yes' }
@@ -48,6 +54,18 @@ module Neo2Spec
         its(:wrapper) { should == Person }
       end
 
+      describe FastPerson do
+        subject { graph2.v(FastPerson) }
+
+        # sanity checks
+        it { should be_a Pacer::Filter::LuceneFilter }
+        its(:query) { should == 'type:"person"' }
+        # This doesn't work because neo indices are out of sync before the transaction finalizes
+        #its(:count) { should == 2 }
+
+        its(:wrapper) { should == FastPerson }
+      end
+
       describe Frog do
         subject { graph2.v(Frog) }
 

data/spec/pacer/blueprints/neo4j_spec.rb

@@ -7,6 +7,12 @@ module NeoSpec
     end
   end
 
+  class FastPerson < Pacer::Wrappers::VertexWrapper
+    def self.lookup(graph)
+      { type: 'person' }
+    end
+  end
+
   class Frog < Pacer::Wrappers::VertexWrapper
     def self.route_conditions(graph)
       { frog: 'yes' }
@@ -48,6 +54,18 @@ module NeoSpec
         its(:wrapper) { should == Person }
       end
 
+      describe FastPerson do
+        subject { graph2.v(FastPerson) }
+
+        # sanity checks
+        it { should be_a Pacer::Filter::LuceneFilter }
+        its(:query) { should == 'type:"person"' }
+        # This doesn't work because neo indices are out of sync before the transaction finalizes
+        #its(:count) { should == 2 }
+
+        its(:wrapper) { should == FastPerson }
+      end
+
       describe Frog do
         subject { graph2.v(Frog) }
 

data/spec/pacer/wrapper/vertex_wrapper_spec.rb

@@ -1,39 +1,5 @@
 require 'spec_helper'
 
-Run.all :read_only do
-  use_pacer_graphml_data :read_only
-
-  describe Pacer::Wrappers::VertexWrapper do
-
-    let(:v_exts) { [Tackle::SimpleMixin, TP::Project] }
-    let(:v_wrapper_class) { Pacer::Wrappers::VertexWrapper.wrapper_for v_exts }
-
-    subject { v_wrapper_class }
-
-    it { should_not be_nil }
-    it { subject.route_conditions(graph).should == { type: 'project' } }
-    its(:extensions) { should == v_exts }
-
-    describe 'instance' do
-      subject do
-        v_wrapper_class.new graph, pacer.element
-      end
-      it               { should_not be_nil }
-      its(:element)    { should_not be_nil }
-      it               { should == pacer }
-      it               { should_not equal pacer }
-      its(:element_id) { should == pacer.element_id }
-      its(:extensions) { should == v_exts }
-
-      describe 'with more extensions added' do
-        subject { v_wrapper_class.new(graph, pacer.element).add_extensions([Pacer::Utils::TSort]) }
-        its(:class) { should_not == v_wrapper_class }
-        its(:extensions) { should == v_exts + [Pacer::Utils::TSort] }
-      end
-    end
-  end
-end
-
 module VertexWrapperSpec
   module Project
     def self.route_conditions(graph)
@@ -45,277 +11,361 @@ module VertexWrapperSpec
   end
 
   module IsRuby
-    def self.route_conditions(graph)
+    def self.lookup(graph)
       { :language => 'ruby' }
     end
 
     module Vertex
     end
   end
-end
 
-shared_examples_for Pacer::Wrappers::VertexWrapper do
-  use_simple_graph_data
+  Run.all :read_only do
+    use_pacer_graphml_data :read_only
 
-  describe '#v' do
-    subject { v0.v }
-    it { should be_a_vertices_route }
-    its(:element_type) { should == :vertex }
-  end
+    describe Pacer::Wrappers::VertexWrapper do
 
-  describe '#add_extensions' do
-    context 'no extensions' do
-      subject { v0.add_extensions([]) }
-      its('extensions.to_a') { should == [] }
-      its(:class) { should == graph.base_vertex_wrapper }
-    end
+      let(:v_exts) { [Tackle::SimpleMixin, TP::Project] }
+      let(:v_wrapper_class) { Pacer::Wrappers::VertexWrapper.wrapper_for v_exts }
 
-    context 'with extensions' do
-      subject { v0.add_extensions([Tackle::SimpleMixin]) }
-      its('extensions.to_a') { should == [Tackle::SimpleMixin] }
-      it { should be_a(Pacer::Wrappers::ElementWrapper) }
-      it { should be_a(Pacer::Wrappers::VertexWrapper) }
-      it { should_not be_a(Pacer::Wrappers::EdgeWrapper) }
+      subject { v_wrapper_class }
 
-      describe '#v' do
-        subject { v0.add_extensions([Tackle::SimpleMixin]).v }
-        its('extensions.to_a') { should == [Tackle::SimpleMixin] }
-        it { should be_a_vertices_route }
-        it { should be_a(Tackle::SimpleMixin::Route) }
-      end
-    end
-  end
+      it { should_not be_nil }
+      it { subject.route_conditions(graph).should == { type: 'project' } }
+      its(:extensions) { should == v_exts }
 
-  describe '#as?' do
-    let(:v) { graph.create_vertex type: 'project' }
-    context 'Project' do
-      subject { v.as?(VertexWrapperSpec::Project) }
-      it { should be_true }
-    end
-    context 'IsRuby' do
-      subject { v.as?(VertexWrapperSpec::IsRuby) }
-      it { should_not be_true }
-    end
-    context 'Project, IsRuby' do
-      subject { v.as?(VertexWrapperSpec::Project, VertexWrapperSpec::IsRuby) }
-      it { should_not be_true }
+      describe 'instance' do
+        subject do
+          v_wrapper_class.new graph, pacer.element
+        end
+        it               { should_not be_nil }
+        its(:element)    { should_not be_nil }
+        it               { should == pacer }
+        it               { should_not equal pacer }
+        its(:element_id) { should == pacer.element_id }
+        its(:extensions) { should == v_exts }
+
+        describe 'with more extensions added' do
+          subject { v_wrapper_class.new(graph, pacer.element).add_extensions([Pacer::Utils::TSort]) }
+          its(:class) { should_not == v_wrapper_class }
+          its(:extensions) { should == v_exts + [Pacer::Utils::TSort] }
+        end
+      end
     end
   end
 
-  describe '#as' do
-    context 'vertex is a Project' do
-      let(:v) { graph.create_vertex type: 'project' }
+  Run.all :read_only do
+    describe 'type filtering' do
+      before :all do
+        graph.tx do
+          graph.create_vertex type: 'project'
+          graph.create_vertex type: 'project'
+          graph.create_vertex type: 'file'
+          graph.create_vertex language: 'ruby'
+          graph.create_vertex language: 'perl'
+        end
+      end
 
-      it 'should yield a Project' do
-        yielded = false
-        v.as(VertexWrapperSpec::Project) do |v2|
-          yielded = true
-          v2.should == v
-          v2.extensions.should include VertexWrapperSpec::Project
-          v2.should be_a VertexWrapperSpec::Project::Vertex
+      context Project, 'using route_conditions' do
+        specify 'initial lookup' do
+          graph.v(Project).count.should == 2
+        end
+        specify 'filter route' do
+          graph.v.v(Project).count.should == 2
         end
-        yielded.should be_true
       end
 
-      it 'should not yield a IsRuby' do
-        yielded = false
-        v.as(VertexWrapperSpec::IsRuby) do |v2|
-          yielded = true
+      context IsRuby, 'using lookup' do
+        specify 'initial lookup' do
+          graph.v(IsRuby).count.should == 1
+        end
+        specify 'filter route' do
+          graph.v.v(IsRuby).count.should == 1
         end
-        yielded.should be_false
       end
     end
   end
 
-  describe '#only_as' do
-    context 'able' do
-      subject { graph.create_vertex VertexWrapperSpec::IsRuby, type: 'project', language: 'ruby' }
-
-      its(:extensions) { should include VertexWrapperSpec::IsRuby }
+  shared_examples_for Pacer::Wrappers::VertexWrapper do
+    use_simple_graph_data
 
-      it 'should yield a Project' do
-        yielded = false
-        subject.only_as(VertexWrapperSpec::Project) do |v2|
-          yielded = true
-          v2.should == subject
-          v2.extensions.should == [VertexWrapperSpec::Project]
-          v2.should be_a VertexWrapperSpec::Project::Vertex
-        end
-        yielded.should be_true
-      end
+    describe '#v' do
+      subject { v0.v }
+      it { should be_a_vertices_route }
+      its(:element_type) { should == :vertex }
     end
 
-    context 'unable' do
-      subject { graph.create_vertex VertexWrapperSpec::IsRuby, language: 'ruby' }
+    describe '#add_extensions' do
+      context 'no extensions' do
+        subject { v0.add_extensions([]) }
+        its('extensions.to_a') { should == [] }
+        its(:class) { should == graph.base_vertex_wrapper }
+      end
 
-      it 'should not yield a Project' do
-        yielded = false
-        subject.only_as(VertexWrapperSpec::Project) do |v2|
-          yielded = true
+      context 'with extensions' do
+        subject { v0.add_extensions([Tackle::SimpleMixin]) }
+        its('extensions.to_a') { should == [Tackle::SimpleMixin] }
+        it { should be_a(Pacer::Wrappers::ElementWrapper) }
+        it { should be_a(Pacer::Wrappers::VertexWrapper) }
+        it { should_not be_a(Pacer::Wrappers::EdgeWrapper) }
+
+        describe '#v' do
+          subject { v0.add_extensions([Tackle::SimpleMixin]).v }
+          its('extensions.to_a') { should == [Tackle::SimpleMixin] }
+          it { should be_a_vertices_route }
+          it { should be_a(Tackle::SimpleMixin::Route) }
         end
-        yielded.should be_false
       end
     end
-  end
 
-  describe '#delete!' do
-    before do
-      @vertex_id = v0.element_id
-      v0.delete!
-      c = example.metadata[:graph_commit]
-      c.call if c
-    end
-    it 'should be removed' do
-      graph.vertex(@vertex_id).should be_nil
+    describe '#as?' do
+      context 'project' do
+        let(:v) { graph.create_vertex type: 'project' }
+        context 'Project' do
+          subject { v.as?(Project) }
+          it { should be_true }
+        end
+        context 'IsRuby' do
+          subject { v.as?(IsRuby) }
+          it { should_not be_true }
+        end
+        context 'Project, IsRuby' do
+          subject { v.as?(Project, IsRuby) }
+          it { should_not be_true }
+        end
+      end
+      context 'language' do
+        let(:v) { graph.create_vertex language: 'ruby' }
+        context 'Project' do
+          subject { v.as?(Project) }
+          it { should_not be_true }
+        end
+        context 'IsRuby' do
+          subject { v.as?(IsRuby) }
+          it { should be_true }
+        end
+        context 'Project, IsRuby' do
+          subject { v.as?(Project, IsRuby) }
+          it { should_not be_true }
+        end
+      end
     end
-  end
 
-  contexts(
-  'into new tg' => proc {
-    let(:dest) { Pacer.tg }
-  },
-  'into graph2' => proc {
-    before { pending 'support temporary hash indices for clone/copy' unless graph.features.supportsIndices }
-    let(:dest) { graph2 }
-  }) do
-    before do
-      graph.transaction(nesting: true) { setup_data }
-    end
-    describe '#clone_into', :transactions => false, read_transaction: true do
-      subject { dest.transaction { v0.clone_into(dest) } }
-      its(:properties) { should == { 'name' => 'eliza' } }
-      its(:graph) { should equal(dest) }
-      its('element_id.to_s') { should == v0.element_id.to_s unless graph.features.ignoresSuppliedIds }
-    end
+    describe '#as' do
+      context 'vertex is a Project' do
+        let(:v) { graph.create_vertex type: 'project' }
+
+        it 'should yield a Project' do
+          yielded = false
+          v.as(Project) do |v2|
+            yielded = true
+            v2.should == v
+            v2.extensions.should include Project
+            v2.should be_a Project::Vertex
+          end
+          yielded.should be_true
+        end
 
-    describe '#copy_into', :transaction => false, read_transaction: true do
-      subject { v1.copy_into(dest) }
-      its(:properties) { should == { 'name' => 'darrick' } }
-      its(:graph) { should equal(dest) }
+        it 'should not yield a IsRuby' do
+          yielded = false
+          v.as(IsRuby) do |v2|
+            yielded = true
+          end
+          yielded.should be_false
+        end
+      end
     end
-  end
 
-  subject { graph.transaction(nesting: true) { setup_data; v0 } }
-  its(:graph) { should equal(graph) }
-  its(:display_name) { should be_nil }
-  its(:inspect) { should =~ /#<[VM]\[#{Regexp.quote v0.element_id.to_s }\]>/ }
-  context 'with label proc' do
-    before do
-      graph.vertex_name = proc { |e| "some name" }
-    end
-    its(:display_name) { should == "some name" }
-    its(:inspect) { should =~ /#<[VM]\[#{ Regexp.quote v0.element_id.to_s }\] some name>/ }
-  end
-  it { should_not == v1 }
-  it { should == v0 }
-  context 'edge with same element id', :transactions => false, read_transaction: true do
-    it { should_not == e0 }
-  end
+    describe '#only_as' do
+      context 'able' do
+        subject { graph.create_vertex IsRuby, type: 'project', language: 'ruby' }
+
+        its(:extensions) { should include IsRuby }
+
+        it 'should yield a Project' do
+          yielded = false
+          subject.only_as(Project) do |v2|
+            yielded = true
+            v2.should == subject
+            v2.extensions.should == [Project]
+            v2.should be_a Project::Vertex
+          end
+          yielded.should be_true
+        end
+      end
 
-  context 'with more data' do
-    let(:from_v) { graph.create_vertex }
-    let(:to_v) { graph.create_vertex }
+      context 'unable' do
+        subject { graph.create_vertex IsRuby, language: 'ruby' }
 
-    before do
-      %w[ a a a b b c ].each do |label|
-        v = graph.create_vertex
-        graph.create_edge nil, from_v, v, label
-        graph.create_edge nil, v, to_v, label
+        it 'should not yield a Project' do
+          yielded = false
+          subject.only_as(Project) do |v2|
+            yielded = true
+          end
+          yielded.should be_false
+        end
       end
     end
 
-    describe '#in_edges' do
-      specify 'to_v should have 6 in edges' do
-        to_v.in_edges.count.should == 6
+    describe '#delete!' do
+      before do
+        @vertex_id = v0.element_id
+        v0.delete!
+        c = example.metadata[:graph_commit]
+        c.call if c
       end
-
-      specify 'to_v should have 3 in edges with label a' do
-        to_v.in_edges('a').count.should == 3
+      it 'should be removed' do
+        graph.vertex(@vertex_id).should be_nil
       end
+    end
 
-      specify 'to_v should have 4 in edges with label a or c' do
-        to_v.in_edges('a', 'c').count.should == 4
+    contexts(
+      'into new tg' => proc {
+        let(:dest) { Pacer.tg }
+      },
+      'into graph2' => proc {
+        before { pending 'support temporary hash indices for clone/copy' unless graph.features.supportsIndices }
+        let(:dest) { graph2 }
+      }
+    ) do
+      before do
+        graph.transaction(nesting: true) { setup_data }
       end
-
-      it 'should add an extension' do
-        edge = to_v.in_edges(Tackle::SimpleMixin).first
-        edge.should be_a(Pacer::Wrappers::EdgeWrapper)
-        edge.extensions.should include(Tackle::SimpleMixin)
+      describe '#clone_into', :transactions => false, read_transaction: true do
+        subject { dest.transaction { v0.clone_into(dest) } }
+        its(:properties) { should == { 'name' => 'eliza' } }
+        its(:graph) { should equal(dest) }
+        its('element_id.to_s') { should == v0.element_id.to_s unless graph.features.ignoresSuppliedIds }
       end
 
-      it 'should be able to mix labels and mixins as arguments' do
-        edge = to_v.in_edges('a', Tackle::SimpleMixin, 'b').first
-        edge.should be_a(Pacer::Wrappers::EdgeWrapper)
-        edge.extensions.should include(Tackle::SimpleMixin)
+      describe '#copy_into', :transaction => false, read_transaction: true do
+        subject { v1.copy_into(dest) }
+        its(:properties) { should == { 'name' => 'darrick' } }
+        its(:graph) { should equal(dest) }
       end
+    end
 
-      it 'should filter correctly with a mix of labels and mixins as arguments' do
-        to_v.in_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+    subject { graph.transaction(nesting: true) { setup_data; v0 } }
+    its(:graph) { should equal(graph) }
+    its(:display_name) { should be_nil }
+    its(:inspect) { should =~ /#<[VM]\[#{Regexp.quote v0.element_id.to_s }\]>/ }
+    context 'with label proc' do
+      before do
+        graph.vertex_name = proc { |e| "some name" }
       end
+      its(:display_name) { should == "some name" }
+      its(:inspect) { should =~ /#<[VM]\[#{ Regexp.quote v0.element_id.to_s }\] some name>/ }
+    end
+    it { should_not == v1 }
+    it { should == v0 }
+    context 'edge with same element id', :transactions => false, read_transaction: true do
+      it { should_not == e0 }
     end
 
-    describe '#out_edges' do
-      specify 'from_v should have 6 out edges' do
-        from_v.out_edges.count.should == 6
-      end
+    context 'with more data' do
+      let(:from_v) { graph.create_vertex }
+      let(:to_v) { graph.create_vertex }
 
-      specify 'from_v should have 3 out edges with label a' do
-        from_v.out_edges('a').count.should == 3
+      before do
+        %w[ a a a b b c ].each do |label|
+          v = graph.create_vertex
+          graph.create_edge nil, from_v, v, label
+          graph.create_edge nil, v, to_v, label
+        end
       end
 
-      specify 'from_v should have 4 out edges with label a or c' do
-        from_v.out_edges('a', 'c').count.should == 4
-      end
+      describe '#in_edges' do
+        specify 'to_v should have 6 in edges' do
+          to_v.in_edges.count.should == 6
+        end
 
-      it 'should add an extension' do
-        edge = from_v.out_edges(Tackle::SimpleMixin).first
-        edge.should be_a(Pacer::Wrappers::EdgeWrapper)
-        edge.extensions.should include(Tackle::SimpleMixin)
-      end
+        specify 'to_v should have 3 in edges with label a' do
+          to_v.in_edges('a').count.should == 3
+        end
 
-      it 'should be able to mix labels and mixins as arguments' do
-        edge = from_v.out_edges('a', Tackle::SimpleMixin, 'b').first
-        edge.should be_a(Pacer::Wrappers::EdgeWrapper)
-        edge.extensions.should include(Tackle::SimpleMixin)
-      end
+        specify 'to_v should have 4 in edges with label a or c' do
+          to_v.in_edges('a', 'c').count.should == 4
+        end
 
-      it 'should filter correctly with a mix of labels and mixins as arguments' do
-        from_v.out_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
-      end
-    end
+        it 'should add an extension' do
+          edge = to_v.in_edges(Tackle::SimpleMixin).first
+          edge.should be_a(Pacer::Wrappers::EdgeWrapper)
+          edge.extensions.should include(Tackle::SimpleMixin)
+        end
 
-    describe '#both_edges' do
-      specify 'from_v should have 6 edges' do
-        from_v.both_edges.count.should == 6
-      end
+        it 'should be able to mix labels and mixins as arguments' do
+          edge = to_v.in_edges('a', Tackle::SimpleMixin, 'b').first
+          edge.should be_a(Pacer::Wrappers::EdgeWrapper)
+          edge.extensions.should include(Tackle::SimpleMixin)
+        end
 
-      specify 'from_v should have 3 edges with label a' do
-        from_v.both_edges('a').count.should == 3
+        it 'should filter correctly with a mix of labels and mixins as arguments' do
+          to_v.in_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+        end
       end
 
-      specify 'from_v should have 4 edges with label a or c' do
-        from_v.both_edges('a', 'c').count.should == 4
-      end
+      describe '#out_edges' do
+        specify 'from_v should have 6 out edges' do
+          from_v.out_edges.count.should == 6
+        end
 
-      it 'should add an extension' do
-        edge = from_v.both_edges(Tackle::SimpleMixin).first
-        edge.should be_a(Pacer::Wrappers::EdgeWrapper)
-        edge.extensions.should include(Tackle::SimpleMixin)
-      end
+        specify 'from_v should have 3 out edges with label a' do
+          from_v.out_edges('a').count.should == 3
+        end
+
+        specify 'from_v should have 4 out edges with label a or c' do
+          from_v.out_edges('a', 'c').count.should == 4
+        end
 
-      it 'should be able to mix labels and mixins as arguments' do
-        edge = from_v.both_edges('a', Tackle::SimpleMixin, 'b').first
-        edge.should be_a(Pacer::Wrappers::EdgeWrapper)
-        edge.extensions.should include(Tackle::SimpleMixin)
+        it 'should add an extension' do
+          edge = from_v.out_edges(Tackle::SimpleMixin).first
+          edge.should be_a(Pacer::Wrappers::EdgeWrapper)
+          edge.extensions.should include(Tackle::SimpleMixin)
+        end
+
+        it 'should be able to mix labels and mixins as arguments' do
+          edge = from_v.out_edges('a', Tackle::SimpleMixin, 'b').first
+          edge.should be_a(Pacer::Wrappers::EdgeWrapper)
+          edge.extensions.should include(Tackle::SimpleMixin)
+        end
+
+        it 'should filter correctly with a mix of labels and mixins as arguments' do
+          from_v.out_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+        end
       end
 
-      it 'should filter correctly with a mix of labels and mixins as arguments' do
-        from_v.both_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+      describe '#both_edges' do
+        specify 'from_v should have 6 edges' do
+          from_v.both_edges.count.should == 6
+        end
+
+        specify 'from_v should have 3 edges with label a' do
+          from_v.both_edges('a').count.should == 3
+        end
+
+        specify 'from_v should have 4 edges with label a or c' do
+          from_v.both_edges('a', 'c').count.should == 4
+        end
+
+        it 'should add an extension' do
+          edge = from_v.both_edges(Tackle::SimpleMixin).first
+          edge.should be_a(Pacer::Wrappers::EdgeWrapper)
+          edge.extensions.should include(Tackle::SimpleMixin)
+        end
+
+        it 'should be able to mix labels and mixins as arguments' do
+          edge = from_v.both_edges('a', Tackle::SimpleMixin, 'b').first
+          edge.should be_a(Pacer::Wrappers::EdgeWrapper)
+          edge.extensions.should include(Tackle::SimpleMixin)
+        end
+
+        it 'should filter correctly with a mix of labels and mixins as arguments' do
+          from_v.both_edges('a', Tackle::SimpleMixin, 'b').count.should == 5
+        end
       end
     end
   end
-end
 
-Run.all do
-  it_uses Pacer::Wrappers::VertexWrapper
+  Run.all do
+    it_uses Pacer::Wrappers::VertexWrapper
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pacer
 version: !ruby/object:Gem::Version
-  version: 2.0.13
+  version: 2.0.14
 platform: java
 authors:
 - Darrick Wiebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2015-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lock_jar