pacer 0.9.1.1-java

data/spec/pacer/wrapper/element_wrapper_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'pacer/graph/element_mixin_spec'
+
+Run.all do
+  # This runs about 500 specs, basically it should test all the ways
+  # that wrappers act the same as native elements
+  describe Pacer::Wrappers::ElementWrapper do
+    it_uses Pacer::ElementMixin do
+      let(:v0) { graph.create_vertex(Tackle::SimpleMixin, :name => 'eliza') }
+      let(:v1) { graph.create_vertex(Tackle::SimpleMixin, :name => 'darrick') }
+      let(:e0) { graph.create_edge nil, v0, v1, :links, Tackle::SimpleMixin }
+      let(:e1) { graph.create_edge nil, v0, v1, :relinks, Tackle::SimpleMixin }
+    end
+  end
+end
+
+describe Pacer, '.wrap_vertex' do
+  before { Pacer.edge_wrapper Tackle::SimpleMixin }
+  subject { Pacer.vertex_wrapper Tackle::SimpleMixin }
+  its(:name) { should =~ /^Pacer::Wrap::/ }
+  its(:ancestors) { should include Pacer::Wrappers::VertexWrapper }
+end
+
+describe Pacer, '.wrap_vertex' do
+  before { Pacer.vertex_wrapper Tackle::SimpleMixin }
+  subject { Pacer.edge_wrapper Tackle::SimpleMixin }
+  its(:name) { should =~ /^Pacer::Wrap::/ }
+  its(:ancestors) { should include Pacer::Wrappers::EdgeWrapper }
+end
+
+Run.tg :read_only do
+  use_pacer_graphml_data :read_only
+
+  describe Pacer::Wrappers::ElementWrapper do
+    subject { Pacer.vertex_wrapper Tackle::SimpleMixin }
+
+    its(:name) { should =~ /^Pacer::Wrap::/ }
+    its(:extensions) { should == [Tackle::SimpleMixin] }
+
+    describe '.clear_cache' do
+      before do
+        subject.const_set :ORIGINAL, true
+        Pacer.vertex_wrapper(Tackle::SimpleMixin).const_defined?(:ORIGINAL).should be_true
+        Pacer::Wrappers::ElementWrapper.clear_cache
+      end
+
+      it 'should get rid of the Pacer::Wrap namespace' do
+        Pacer.const_defined?(:Wrap).should be_false
+      end
+
+      it 'should not be the same object if redefined' do
+        # if the wrapper is redefined identically, you can't use a normal
+        # comparison to see if it's actually been redefined.
+        Pacer.vertex_wrapper(Tackle::SimpleMixin).const_defined?(:ORIGINAL).should be_false
+      end
+    end
+
+    describe 'extension ordering' do
+      before do
+        Pacer::Wrappers::ElementWrapper.clear_cache
+      end
+      subject { Pacer.vertex_wrapper TP::Person, Tackle::SimpleMixin, TP::Coder }
+
+      its(:extensions) { should == [TP::Person, Tackle::SimpleMixin, TP::Coder]  }
+      it 'should have the ancestors set in the correct order' do
+        # Ruby searches for methods down this list, so order is
+        # important for method overrides.
+        subject.ancestors[0...6].should == [
+          Pacer::Wrap::VertexWrapperTP_PersonTackle_SimpleMixinTP_Coder,
+          TP::Coder::Route,
+          Tackle::SimpleMixin::Vertex,
+          Tackle::SimpleMixin::Route,
+          TP::Person::Route,
+          Pacer::Wrappers::VertexWrapper,
+        ]
+      end
+
+      it 'should preserve the order once it is established for that combination of extensions' do
+        subject.ancestors.should == Pacer.vertex_wrapper(TP::Coder, TP::Person, Tackle::SimpleMixin).ancestors
+      end
+
+      context 'should preserve extension order if a route uses the wrapper and adds more extensions' do
+        let(:wrapper) { Pacer.vertex_wrapper TP::Person, Tackle::SimpleMixin, TP::Coder }
+        subject do
+          route = graph.v(wrapper, Pacer::Utils::TSort)
+          first = route.first
+          first.should_not be_nil
+          first.class
+        end
+
+        it 'should have ancestors in the correct order' do
+          subject.ancestors[0...9].should == [
+            Pacer::Wrap::VertexWrapperTP_PersonTackle_SimpleMixinTP_CoderPacer_Utils_TSort,
+            Pacer::Utils::TSort::Vertex,
+            Pacer::Utils::TSort::Route,
+            TSort,
+            TP::Coder::Route,
+            Tackle::SimpleMixin::Vertex,
+            Tackle::SimpleMixin::Route,
+            TP::Person::Route,
+            Pacer::Wrappers::VertexWrapper,
+          ]
+        end
+      end
+
+      context 'should preserve extension order in a block filter' do
+        subject do
+          klass = nil
+          route = graph.v(TP::Person, Tackle::SimpleMixin, TP::Coder) { |e| klass = e.class }
+          route.first.should_not be_nil
+          klass
+        end
+
+        it 'should have ancestors in the correct order' do
+          subject.ancestors[0...7].should == [
+            Pacer::Wrap::VertexWrapperTP_PersonTackle_SimpleMixinTP_CoderPacer_Extensions_BlockFilterElement,
+            Pacer::Extensions::BlockFilterElement::Route,
+            TP::Coder::Route,
+            Tackle::SimpleMixin::Vertex,
+            Tackle::SimpleMixin::Route,
+            TP::Person::Route,
+            Pacer::Wrappers::VertexWrapper,
+          ]
+        end
+      end
+
+      context 'should be in a different order if cleared and defined differently' do
+        before { Pacer::Wrappers::ElementWrapper.clear_cache }
+        subject { Pacer.vertex_wrapper Tackle::SimpleMixin, TP::Person, TP::Coder }
+
+        its(:extensions) { should == [Tackle::SimpleMixin, TP::Person, TP::Coder]  }
+        it 'should have the ancestors set in the correct order' do
+          # Ruby searches for methods down this list, so order is
+          # important for method overrides.
+          subject.ancestors[0...6].should == [
+            Pacer::Wrap::VertexWrapperTackle_SimpleMixinTP_PersonTP_Coder,
+            TP::Coder::Route,
+            TP::Person::Route,
+            Tackle::SimpleMixin::Vertex,
+            Tackle::SimpleMixin::Route,
+            Pacer::Wrappers::VertexWrapper,
+          ]
+        end
+
+        context 'should preserve extension order if a route adds more extensions' do
+          subject do
+            klass = nil
+            route = graph.v(Tackle::SimpleMixin, TP::Person, TP::Coder) { |e| klass = e.class }
+            route.first.should_not be_nil
+            klass
+          end
+
+          it { should_not be_nil }
+          it 'should have ancestors in the correct order' do
+            subject.ancestors[0...7].should == [
+              Pacer::Wrap::VertexWrapperTackle_SimpleMixinTP_PersonTP_CoderPacer_Extensions_BlockFilterElement,
+              Pacer::Extensions::BlockFilterElement::Route,
+              TP::Coder::Route,
+              TP::Person::Route,
+              Tackle::SimpleMixin::Vertex,
+              Tackle::SimpleMixin::Route,
+              Pacer::Wrappers::VertexWrapper,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/pacer/wrapper/vertex_wrapper_spec.rb

@@ -0,0 +1,33 @@
+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 }
+    its(:route_conditions) { should == { type: 'project' } }
+    its(:extensions) { should == v_exts }
+
+    describe 'instance' do
+      subject { v_wrapper_class.new pacer }
+      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(pacer).add_extensions([Pacer::Utils::TSort]) }
+        its(:class) { should_not == v_wrapper_class }
+        its(:extensions) { should == v_exts + [Pacer::Utils::TSort] }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :development)
+require 'rspec'
+require 'pacer'
+require 'set'
+
+Dir['./spec/support/**/*.rb'].map {|f| require f}
+Dir['./spec/tackle/*.rb'].map {|f| require f}
+
+include Pacer::Routes
+
+class RSpec::Core::ExampleGroup
+  def self.run_all(reporter=nil)
+    run(reporter || NullObject.new)
+  end
+end
+
+def in_editor?
+  ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
+end
+
+require 'pacer-neo4j'
+# require 'pacer-dex'
+Pacer::DexGraph = Class.new unless defined? Pacer::DexGraph
+
+Run = RSpec::GraphRunner.new ENV['GRAPHS']
+
+def use_simple_graph_data
+  let(:setup_data) { e0; e1 }
+  let(:v0) { graph.create_vertex :name => 'eliza' }
+  let(:v1) { graph.create_vertex :name => 'darrick' }
+  let(:e0) { graph.create_edge nil, v0, v1, :links }
+  let(:e1) { graph.create_edge nil, v0, v1, :relinks }
+end
+
+def use_pacer_graphml_data(usage_style = :read_write)
+  if usage_style == :read_only
+    let(:setup_data) { }
+    before(:all) do
+      graph.import 'spec/data/pacer.graphml' if graph
+    end
+  else
+    let(:setup_data) do
+      graph.import 'spec/data/pacer.graphml' if graph
+    end
+  end
+  let(:pangloss) { graph.v(:name => 'pangloss', :type => 'person').first }
+  let(:pacer) { graph.v(:name => 'pacer', :type => 'project').first }
+  let(:people) { graph.v(:type => 'person') }
+  let(:pangloss_wrote_pacer) { pangloss.out_e(:wrote) { |e| e.in_vertex == pacer }.first }
+end
+
+def use_grateful_dead_data(usage_style = :read_write)
+  if usage_style == :read_only
+    let(:setup_data) { }
+    before(:all) do
+      graph.import 'spec/data/grateful-dead.xml' if graph
+    end
+  else
+    let(:setup_data) do
+      graph.import 'spec/data/grateful-dead.xml' if graph
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.color_enabled = !in_editor?
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+  Pacer.hide_route_elements = true
+  Pacer.verbose = false
+  c.mock_with :rr
+
+  c.alias_it_should_behave_like_to :it_uses, '-'
+
+  puts "Using JRuby #{ JRUBY_VERSION } in #{ RUBY_VERSION } mode."
+  puts Run.inspect
+
+  # Not sure what this does: ...
+  # c.filter_run_excluding :ruby => lambda {|version|
+  #   case version.to_s
+  #   when "!jruby"
+  #     RUBY_ENGINE != "jruby"
+  #   when /^> (.*)/
+  #     !(RUBY_VERSION.to_s > $1)
+  #   else
+  #     !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
+  #   end
+  # }
+end

data/spec/support/contexts.rb

@@ -0,0 +1,14 @@
+module RSpec
+  module Core
+    module SharedExampleGroup
+      def contexts(ctxts, &block)
+        ctxts.each do |name, setup_proc|
+          context(*[*name]) do
+            instance_eval &setup_proc
+            instance_eval &block
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/graph_runner.rb

@@ -0,0 +1,142 @@
+class RSpec::GraphRunner
+  module Tg
+    def all(usage_style = :read_write, indices = true, &block)
+      tg(usage_style, indices, &block)
+    end
+
+    def tg(usage_style = :read_write, indices = true, &block)
+      return unless use_graph? 'tg'
+      describe 'tg' do
+        let(:graph) do
+          g = Pacer.tg
+          unless indices
+            g.drop_index :vertices
+            g.drop_index :edges
+          end
+          g
+        end
+        let(:graph2) { Pacer.tg }
+        instance_eval(&block)
+      end
+    end
+
+    def dex(*args)
+    end
+  end
+
+  module RubyGraph
+    def all(usage_style = :read_write, indices = true, &block)
+      super
+      rg(usage_style, indices, &block)
+    end
+
+    def rg(usage_style = :read_write, indices = true, &block)
+      for_graph('rg', usage_style, indices, false, ruby_graph, ruby_graph2, nil, block)
+    end
+
+    protected
+
+    def ruby_graph
+      Pacer::RubyGraph.new
+    end
+
+    def ruby_graph2
+      Pacer::RubyGraph.new
+    end
+  end
+
+  module MultiGraph
+    def all(usage_style = :read_write, indices = true, &block)
+      super
+      multigraph(usage_style, indices, &block)
+    end
+
+    def multigraph(usage_style = :read_write, indices = true, &block)
+      for_graph('multigraph', usage_style, indices, false, multi_graph, multi_graph2, nil, block)
+    end
+
+    protected
+
+    def multi_graph
+      Pacer::MultiGraph.new
+    end
+
+    def multi_graph2
+      Pacer::MultiGraph.new
+    end
+  end
+
+  include Tg
+  include RubyGraph
+  include MultiGraph
+
+  def initialize(*graphs)
+    @graphs = graphs.map { |s| s.to_s.downcase.split(/\s*,\s*/) }.flatten.map { |s| s.strip }.reject { |s| s == '' }
+  end
+
+  def inspect
+    if @graphs.empty?
+      "Testing all graphs."
+    else
+      "Testing graphs: #{ @graphs.join ', ' }."
+    end
+  end
+
+  def use_graph?(name)
+    if @graphs.empty?
+      true
+    else
+      @graphs.include? name
+    end
+  end
+
+protected
+
+  def for_graph(name, usage_style, indices, transactions, source_graph_1, source_graph_2, unindexed_graph, block)
+    return unless use_graph? name
+    describe name do
+      let(:graph) do
+        if indices
+          source_graph_1
+        else
+          unindexed_graph
+        end
+      end
+      let(:graph2) do
+        source_graph_2
+      end
+      if usage_style == :read_only
+        before(:all) do
+          source_graph_1.v.delete!
+          source_graph_2.v.delete!
+          unindexed_graph.v.delete! if unindexed_graph
+        end
+      end
+      around do |spec|
+        if usage_style == :read_write
+          source_graph_1.v.delete!
+          source_graph_2.v.delete!
+          unindexed_graph.v.delete! if unindexed_graph
+        end
+        if transactions and spec.use_transactions?
+          graph.manual_transactions do
+            graph2.manual_transactions do
+              begin
+                graph.begin_transaction
+                graph2.begin_transaction
+                spec.run
+              ensure
+                graph.rollback_transaction rescue nil
+                graph2.rollback_transaction rescue nil
+              end
+            end
+          end
+        else
+          spec.run
+        end
+      end
+      instance_eval(&block)
+    end
+  end
+end
+

data/spec/support/matchers.rb

@@ -0,0 +1,19 @@
+module RSpec
+  module Core
+    module Matchers
+      def fail
+        raise_error(::RSpec::Expectations::ExpectationNotMetError)
+      end
+
+      def fail_with(message)
+        raise_error(::RSpec::Expectations::ExpectationNotMetError, message)
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :be_one_of do |*list|
+  match do |item|
+    list.include? item
+  end
+end

data/spec/support/use_transactions.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Core
+    class Example
+      module ProcsyTransactions
+        def use_transactions?
+          find_metadata(metadata, :transactions) != false
+        end
+
+        def find_metadata(hash, key)
+          return unless hash.is_a? Hash
+          if hash.key? key
+            hash[key]
+          elsif hash.key? :example_group
+            find_metadata(hash[:example_group], key)
+          end
+        end
+      end
+
+      if not defined? Procsy or Procsy.class == Module
+        # RSpec version >= '2.5.0'
+        module Procsy
+          include ProcsyTransactions
+        end
+      else
+        class Procsy
+          include ProcsyTransactions
+        end
+      end
+    end
+  end
+end

data/spec/tackle/simple_mixin.rb

@@ -0,0 +1,21 @@
+module Tackle
+  module SimpleMixin
+    module Route
+      def route_mixin_method
+        true
+      end
+    end
+
+    module Vertex
+      def vertex_mixin_method
+        true
+      end
+    end
+
+    module Edge
+      def edge_mixin_method
+        true
+      end
+    end
+  end
+end

data/spec/tackle/tinkerpop_graph_mixins.rb

@@ -0,0 +1,60 @@
+module TP
+  module Person
+    def self.route_conditions
+      { :type => 'person' }
+    end
+
+    module Route
+      def projects
+        out_e.in_v(Project)
+      end
+    end
+  end
+
+
+  class Project
+    def self.route_conditions
+      { :type => 'project' }
+    end
+
+    module Route
+      def people
+        in_e.out_v(Person)
+      end
+    end
+  end
+
+  class Pangloss
+    def self.route(base)
+      base.v(:name => 'pangloss')
+    end
+  end
+
+  module Coder
+    module Route
+      def projects
+        out(Project, Software)
+      end
+    end
+  end
+
+  module Software
+    module Route
+      def coders
+        self.in(Coder)
+      end
+    end
+  end
+
+  module Wrote
+    def self.route_conditions
+      { label: 'wrote' }
+    end
+
+    module Edge
+      def writer
+        out_vertex
+      end
+    end
+  end
+end