pacer 1.2.0-java → 1.3.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 873067a94942616e42ecb659e821bdf1f13c6bd4
+  data.tar.gz: 91c4e71707fa23b969e6205d650a981464d2b4a5
+SHA512:
+  metadata.gz: bacb0e4e165bd10005d090cc7e1cd1fae2954b88901725078729c2fdd62e202c7f42237ed1d62b2d08aa5b1864b061eceb6638bc3900dbf9ccfbedfef32179fa
+  data.tar.gz: 687bc677f5ca3682ef2b012ed278731d2a2963f85f399ef4829b55a4dc35d6e82d504d4470e50a60c6dc5d19f8d2b19e93411801ef6ac60815b0ed22d84ed167

data/README.md

@@ -203,3 +203,17 @@ I'm aiming for 100% test coverage in Pacer and am currently nearly there in the
 ## Style Guide
 
 Please follow Github's [Ruby style guide](https://github.com/styleguide/ruby) when contributing to make your patches more likely to be accepted!
+
+## YourKit Profiler
+
+One of the advantages of building Pacer on JRuby is that we can leverage
+the incredible tools that exist in the JVM ecosystem. YourKit is a tool
+that I found through glowing recommendation, and has been greatly useful
+in profiling the performance of Pacer.
+
+YourKit is kindly supporting the Pacer open source project with its full-featured Java Profiler.
+YourKit, LLC is the creator of innovative and intelligent tools for profiling
+Java and .NET applications. Take a look at YourKit's leading software products:
+
+<a href="http://www.yourkit.com/java/profiler/index.jsp">YourKit Java Profiler</a> and
+<a href="http://www.yourkit.com/.net/profiler/index.jsp">YourKit .NET Profiler</a>.

data/lib/pacer/blueprints/ruby_graph.rb

@@ -23,7 +23,6 @@ module Pacer
 
       features.ignoresSuppliedIds = false
       features.isPersistent = false
-      features.isRDFModel = false
       features.isWrapper = false
 
       features.supportsIndices = false

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

@@ -6,7 +6,7 @@ module Pacer::Core::Graph
     # Returns a new route to all graph vertices. Standard filter options.
     def v(*args, &block)
       filters = Pacer::Route.filters(args)
-      if features.supportsIndices
+      if features.supportsKeyIndices or (search_manual_indices and features.supportsIndices)
         route = indexed_route(:vertex, filters, block)
       end
       if route
@@ -19,7 +19,7 @@ module Pacer::Core::Graph
     # Returns a new route to all graph edges. Standard filter options.
     def e(*args, &block)
       filters = Pacer::Route.edge_filters(args)
-      if features.supportsIndices
+      if features.supportsKeyIndices or (search_manual_indices and features.supportsIndices)
         route = indexed_route(:edge, filters, block)
       end
       if route

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

@@ -55,11 +55,17 @@ HELP
 
     def payloads
       map element_type: :path, route_name: 'payloads' do |path|
-        path.map do |e|
-          if e.is_a? Pacer::Payload::Element
-            e.payload
-          elsif e.is_a? Pacer::Wrappers::ElementWrapper
-            e.element_payload
+        path.flat_map do |e|
+          e = e.element if e.is_a? Pacer::Wrappers::ElementWrapper
+          r = []
+          while e.is_a? Pacer::Payload::Element
+            r.unshift e.payload
+            e = e.element
+          end
+          if r == []
+            [nil]
+          else
+            r
           end
         end
       end

data/lib/pacer/filter/property_filter/filters.rb

@@ -34,6 +34,8 @@ module Pacer
 
     module PropertyFilter
       class Filters
+        NodeVisitor = Pacer::Filter::WhereFilter::NodeVisitor
+
         attr_reader :properties, :extensions, :route_modules, :best_index_value
         attr_accessor :wrapper, :blocks
 
@@ -112,11 +114,20 @@ module Pacer
             pipe = e
           end
           encoded_properties.each do |key, value|
-            new_pipe = PropertyFilterPipe.new(key, value, Pacer::Pipes::EQUAL)
-            new_pipe.set_starts pipe if pipe
-            Pacer.debug_pipes << { :name => key, :start => pipe, :end => new_pipe } if Pacer.debug_pipes
-            pipe = new_pipe
-            start_pipe ||= pipe
+            case value
+            when NodeVisitor::Pipe
+              new_pipe = value.build
+            when NodeVisitor::Value
+              # no op
+            else
+              new_pipe = PropertyFilterPipe.new(key, value, Pacer::Pipes::EQUAL)
+            end
+            if new_pipe
+              new_pipe.set_starts pipe if pipe
+              Pacer.debug_pipes << { :name => key, :start => pipe, :end => new_pipe } if Pacer.debug_pipes
+              pipe = new_pipe
+              start_pipe ||= pipe
+            end
           end
           blocks.each do |block|
             block_pipe = Pacer::Pipes::BlockFilterPipe.new(route, block)
@@ -140,7 +151,13 @@ module Pacer
           strings = []
           strings << [wrapper.name] if wrapper
           strings.concat extensions.map { |e| e.name }
-          strings.concat((non_ext_props - [@best_index_value]).map { |k, v| "#{ k }==#{ v.inspect }" })
+          strings.concat((non_ext_props - [@best_index_value]).map { |k, v|
+            if v.is_a? Set
+              "#{ k } IN (#{ v.sort.map { |s| s.inspect }.join ', ' })"
+            else
+              "#{ k }==#{ v.inspect }"
+            end
+          })
           strings.concat blocks.map { '&block' }
           strings.concat route_modules.map { |mod| mod.name }
           strings.join ', '
@@ -164,6 +181,7 @@ module Pacer
           when Hash
             reset_properties
             filter.each do |k, v|
+              v = v.first if v.is_a? Set and v.length == 1
               self.non_ext_props << [k.to_s, v] unless extension
               self.properties << [k.to_s, v]
             end
@@ -209,14 +227,22 @@ module Pacer
           end
         end
 
-        def encode_value(value)
-          value = graph.encode_property(value)
-          if value.respond_to? :to_java
-            jvalue = value.to_java
-          elsif value.respond_to? :to_java_string
-            jvalue = value.to_java_string
+        def encode_value(key, value)
+          if value.is_a? Set
+            encoded = value.map.with_index { |v, i| graph.encode_property(v) }
+            str = encoded.map { |v| "`#{ key.to_s }` == #{ v.inspect }" }.join " or "
+            parsed = JRuby.parse str
+            visitor = NodeVisitor.new(nil, {})
+            parsed.accept visitor
           else
-            jvalue = value
+            value = graph.encode_property(value)
+            if value.respond_to? :to_java
+              value.to_java
+            elsif value.respond_to? :to_java_string
+              value.to_java_string
+            else
+              value
+            end
           end
         end
 
@@ -259,9 +285,13 @@ module Pacer
         end
 
         def check_index(index_options, idxs, k, v, index_value)
-          if choose_best_index
+          if v.is_a? Set
+            # By default we assume that indices can't do OR type operations, so Set values are ruled out. If
+            # the index can do that (i.e. Neo4j's lucene engine), the adapter needs to do its own index selection.
+            false
+          elsif choose_best_index
             idxs.each do |idx|
-              index_options << [idx.count(k, encode_value(v)), [idx, k, v], index_value]
+              index_options << [idx.count(k, encode_value(k, v)), [idx, k, v], index_value]
             end
             false
           else
@@ -284,7 +314,7 @@ module Pacer
 
         def encoded_properties
           @encoded_properties ||= properties.map do |k, v|
-            [k, encode_value(v)]
+            [k, encode_value(k, v)]
           end
         end
 

data/lib/pacer/filter/where_filter/node_visitor.rb

@@ -1,6 +1,8 @@
 module Pacer
   module Filter
     module WhereFilter
+      # NOTE: the property filter also uses this to build { key: Set[v1, v2] }
+      # filters as or statements.
       class NodeVisitor
         import com.tinkerpop.pipes.filter.OrFilterPipe
         import com.tinkerpop.pipes.filter.FilterPipe

data/lib/pacer/graph/graph_transactions_mixin.rb

@@ -82,6 +82,13 @@ module Pacer
       blueprints_graph.stopTransaction TransactionalGraph::Conclusion::SUCCESS
     end
 
+    attr_reader :on_commit_block
+
+    def on_commit(&block)
+      return unless block
+      @on_commit_block = block
+    end
+
   private
 
     def threadlocal_graph_info
@@ -128,6 +135,7 @@ module Pacer
         end
         puts "transaction committed" if Pacer.verbose == :very
         blueprints_graph.stopTransaction TransactionalGraph::Conclusion::SUCCESS
+        on_commit_block.call if on_commit_block
       end
       rollback = ->(message = nil) do
         puts ["transaction rolled back", message].compact.join(': ') if Pacer.verbose == :very
@@ -153,6 +161,7 @@ module Pacer
     def mock_base_tx_finalizers
       commit = -> do
         puts "mock transaction committed" if Pacer.verbose == :very
+        on_commit_block.call if on_commit_block
       end
       rollback = ->(message = nil) do
         puts ["mock transaction rolled back", message].compact.join(': ') if Pacer.verbose == :very

data/lib/pacer/graph/pacer_graph.rb

@@ -1,4 +1,6 @@
 module Pacer
+  import com.tinkerpop.blueprints.Parameter
+
   class PacerGraph
     include GraphTransactionsMixin
 
@@ -6,9 +8,9 @@ module Pacer
     include Pacer::Core::Graph::GraphRoute
     include Pacer::Core::Graph::GraphIndexRoute
 
-    attr_reader :blueprints_graph, :encoder
+    attr_reader :blueprints_graph
 
-    attr_accessor :base_vertex_wrapper, :base_edge_wrapper
+    attr_accessor :encoder, :base_vertex_wrapper, :base_edge_wrapper
 
     def initialize(encoder, open, shutdown = nil, graph_id = nil)
       self.base_vertex_wrapper = Pacer::Wrappers::VertexWrapper
@@ -52,10 +54,6 @@ module Pacer
       self
     end
 
-    def copy_object
-      self.class.new @encoder, @reopen, @shutdown, graph_id
-    end
-
     def use_wrapper(klass)
       reopen = proc do
         klass.new unwrap_graph(@reopen.call)
@@ -88,18 +86,7 @@ module Pacer
         v = blueprints_graph.getVertex(id)
       rescue java.lang.RuntimeException
       end
-      if v
-        wrapper = modules.detect { |obj| obj.ancestors.include? Pacer::Wrappers::VertexWrapper }
-        if wrapper
-          v = wrapper.new graph, v
-          modules.delete wrapper
-        else
-          v = base_vertex_wrapper.new graph, v
-        end
-        v.add_extensions modules
-      else
-        v
-      end
+      wrap_element v, base_vertex_wrapper, Pacer::Wrappers::VertexWrapper, modules
     end
 
     # Get an edge by id.
@@ -115,15 +102,23 @@ module Pacer
         v = blueprints_graph.getEdge(id)
       rescue Java::JavaLang::RuntimeException
       end
+      wrap_element v, base_edge_wrapper, Pacer::Wrappers::EdgeWrapper, modules
+    end
+
+    def wrap_element(v, base, klass, modules)
       if v
-        wrapper = modules.detect { |obj| obj.ancestors.include? Pacer::Wrappers::EdgeWrapper }
-        if wrapper
-          v = wrapper.new graph, v
-          modules.delete wrapper
+        if modules
+          wrapper = modules.detect { |obj| obj.ancestors.include? klass }
+          if wrapper
+            v = wrapper.new graph, v
+            modules.delete wrapper
+          else
+            v = base.new graph, v
+          end
+          v.add_extensions modules
         else
-          v = base_edge_wrapper.new graph, v
+          base.new graph, v
         end
-        v.add_extensions modules
       end
     end
 
@@ -371,10 +366,21 @@ module Pacer
     include Indices
 
     module KeyIndices
-      def create_key_index(name, type)
+      def create_key_index(name, type = :vertex, opts = {})
+        params = build_key_index_parameters_from opts
         if features.supportsKeyIndices
           if element_type(type) == :vertex and features.supportsVertexKeyIndex
-            blueprints_graph.createKeyIndex name.to_s, index_class(:vertex)
+            blueprints_graph.createKeyIndex name.to_s, index_class(:vertex), *params
+          elsif element_type(type) == :edge and features.supportsEdgeKeyIndex
+            blueprints_graph.createKeyIndex name.to_s, index_class(:edge), *params
+          end
+        end
+      end
+
+      def drop_key_index(name, type = :vertex)
+        if features.supportsKeyIndices
+          if element_type(type) == :vertex and features.supportsVertexKeyIndex
+            blueprints_graph.dropKeyIndex name.to_s, index_class(:vertex)
           elsif element_type(type) == :edge and features.supportsEdgeKeyIndex
             blueprints_graph.createKeyIndex name.to_s, index_class(:edge)
           end
@@ -413,7 +419,14 @@ module Pacer
           fail ClientError, "The key #{ key } is not indexed"
         end
       end
+
+      def build_key_index_parameters_from(option_hash)
+        option_hash.each_with_object([]) do |(key, value), params|
+          params << Pacer::Parameter.new(key, value)
+        end
+      end
     end
+
     include KeyIndices
 
     module ElementType

data/lib/pacer/graph/simple_encoder.rb

@@ -1,6 +1,7 @@
 module Pacer
   class SimpleEncoder
     JBoolean = java.lang.Boolean
+    JDate = java.util.Date
     JFalse = false.to_java
 
     def self.encode_property(value)
@@ -17,6 +18,8 @@ module Pacer
     def self.decode_property(value)
       if value.is_a? JBoolean and value == JFalse
         false
+      elsif value.is_a? JDate
+        Time.at value.getTime() / 1000.0
       else
         value
       end

data/lib/pacer/loader.rb

@@ -70,6 +70,7 @@ require 'pacer/visitors/section'
 require 'pacer/filter/collection_filter'
 require 'pacer/filter/empty_filter'
 require 'pacer/filter/future_filter'
+require 'pacer/filter/where_filter'
 require 'pacer/filter/property_filter'
 require 'pacer/filter/range_filter'
 require 'pacer/filter/uniq_filter'
@@ -77,7 +78,6 @@ require 'pacer/filter/index_filter'
 require 'pacer/filter/loop_filter'
 require 'pacer/filter/block_filter'
 require 'pacer/filter/object_filter'
-require 'pacer/filter/where_filter'
 require 'pacer/filter/random_filter'
 
 require 'pacer/transform/cap'

data/lib/pacer/pipes.rb

@@ -3,7 +3,7 @@ module Pacer
   module Pipes
     # TODO: move pipe imports to the modules that actually use them.
     import com.tinkerpop.pipes.AbstractPipe
-    import com.tinkerpop.pipes.transform.IdentityPipe
+    import com.tinkerpop.pipes.IdentityPipe
     import com.tinkerpop.pipes.util.Pipeline
     import com.tinkerpop.pipes.util.PipeHelper
 

data/lib/pacer/transform/sort_section.rb

@@ -2,7 +2,11 @@ module Pacer
   module Routes
     module RouteOperations
       def sort_section(section = nil, &block)
-        chain_route transform: :sort_section, block: block, section: section
+        chain_route transform: :sort_section, sort_by_block: block, section: section
+      end
+
+      def custom_sort_section(section = nil, &block)
+        chain_route transform: :sort_section, custom_sort_block: block, section: section
       end
     end
   end
@@ -15,26 +19,32 @@ module Pacer
       #  section_visitor
       include Pacer::Visitors::VisitsSection
 
-      attr_accessor :block
+      attr_accessor :sort_by_block
+      attr_accessor :custom_sort_block
 
       protected
 
       def attach_pipe(end_pipe)
-        pf = Pacer::Wrappers::WrappingPipeFunction.new self, block if block
-        pipe = SortSectionPipe.new(self, section_visitor, pf)
+        if custom_sort_block
+          wrapper = Pacer::Wrappers::WrapperSelector.build graph, element_type, extensions
+          pipe = CustomSortPipe.new(self, section_visitor, custom_sort_block, graph, wrapper)
+        else # sort_by_block
+          pf = Pacer::Wrappers::WrappingPipeFunction.new self, sort_by_block if sort_by_block
+          pipe = SortBySectionPipe.new(self, section_visitor, pf)
+        end
         pipe.setStarts end_pipe if end_pipe
         pipe
       end
 
-
-      class SortSectionPipe < Pacer::Pipes::RubyPipe
-        attr_reader :pf_1, :pf_2, :to_sort, :to_emit, :section
+      class SortBySectionPipe < Pacer::Pipes::RubyPipe
+        attr_reader :pf_1, :pf_2, :to_sort, :to_emit, :section, :route
         attr_reader :getPathToHere
 
         def initialize(route, section, pipe_function)
           super()
           @to_emit = []
           @section = section
+          @route = route
           @to_sort = []
           @paths = []
           if section
@@ -105,6 +115,30 @@ module Pacer
           end
         end
       end
+
+      class CustomSortPipe < SortBySectionPipe
+        attr_reader :sort_block
+
+        def initialize(route, section, sort_block, graph, wrapper)
+          super route, section, nil
+          @sort_block = sort_block
+          @graph = graph
+          @wrapper = wrapper
+        end
+
+        def after_element
+          if to_sort.any?
+            to_sort.map! { |e| [ @wrapper.new(@graph, e.first), e.last ] }
+            sorted = to_sort.sort { |a, b| @sort_block.call a.first, b.first }
+            if route.element_type == :vertex || route.element_type == :edge
+              to_emit.concat sorted.map { |e| [ e.first.element, e.last ] }
+            else
+              to_emit.concat sorted
+            end
+            @to_sort.clear
+          end
+        end
+      end
     end
   end
 end

data/lib/pacer/version.rb

@@ -1,14 +1,14 @@
 module Pacer
   unless const_defined? :VERSION
-    VERSION = "1.2.0"
+    VERSION = "1.3.1"
 
     JAR = "pacer-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"
 
     START_TIME = Time.now
 
-    BLUEPRINTS_VERSION = "2.2.0"
-    PIPES_VERSION = "2.2.0"
-    GREMLIN_VERSION = "2.2.0"
+    BLUEPRINTS_VERSION = "2.3.0"
+    PIPES_VERSION = "2.3.0"
+    GREMLIN_VERSION = "2.3.0"
   end
 end

data/lib/pacer/wrappers/edge_wrapper.rb

@@ -119,6 +119,19 @@ module Pacer::Wrappers
       graph.remove_edge element
     end
 
+    # Creates a new edge between the same elements with the same
+    # properties, but in the opposite direction and optionally with a
+    # new label. Attempts to reuse the edge id.
+    def reverse!(opts = {})
+      iv = out_vertex
+      ov = in_vertex
+      id = element_id if opts[:reuse_id]
+      new_label = opts.fetch(:label, label)
+      props = properties
+      delete!
+      graph.create_edge id, ov, iv, new_label, props
+    end
+
     # Clones this edge into the target graph.
     #
     # This differs from the {#copy_into} in that it tries to set

data/lib/pacer/wrappers/element_wrapper.rb

@@ -113,12 +113,12 @@ module Pacer::Wrappers
       value = graph.encode_property(value)
       key = key.to_s
       if value
-        if value != element.getProperty(key)
-          element.setProperty(key, value)
-        end
+        element.setProperty(key, value)
       else
-        element.removeProperty(key) if element.getPropertyKeys.include? key
+        element.removeProperty(key)
       end
+    rescue Exception => e
+      throw Pacer::ClientError.new "Unable to serialize #{ key }: #{ value.class }"
     end
 
     # Specialize result to return self for elements.

data/lib/pacer/wrappers/index_wrapper.rb

@@ -40,7 +40,16 @@ module Pacer::Wrappers
       if element.is_a? ElementWrapper
         element = element.element
       end
+
       index.put key.to_s, value, element
     end
+
+    def remove(key, value, element)
+      if element.is_a? ElementWrapper
+        element = element.element
+      end
+
+      index.remove key.to_s, value, element
+    end
   end
 end

data/pom.xml

@@ -7,10 +7,10 @@
     <artifactId>pacer</artifactId>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <properties>
-      <blueprints.version>2.2.0</blueprints.version>
-      <gem.version>1.2.0</gem.version>
-      <pipes.version>2.2.0</pipes.version>
-      <gremlin.version>2.2.0</gremlin.version>
+      <blueprints.version>2.3.0</blueprints.version>
+      <gem.version>1.3.1</gem.version>
+      <pipes.version>2.3.0</pipes.version>
+      <gremlin.version>2.3.0</gremlin.version>
     </properties>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <version>${gem.version}</version>

data/spec/pacer/blueprints/neo4j_spec.rb

@@ -39,7 +39,7 @@ module NeoSpec
 
         # sanity checks
         it { should be_a Pacer::Filter::LuceneFilter }
-        its(:query) { should == 'type:person' }
+        its(:query) { should == 'type:"person"' }
         its(:count) { should == 2 }
 
         its(:wrapper) { should == Person }

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

@@ -36,6 +36,27 @@ module Pacer::Filter::PropertyFilter
         its(:properties) { should == [ %w[ name Darrick ], %w[ nickname pangloss ] ] }
       end
 
+      context 'With a Set of properties' do
+        let(:filters) { Pacer::Route.send filter_method, [nickname: Set['pangloss', 'someone']] }
+
+        before { subject.graph = graph }
+
+        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 == [ ['nickname', Set['pangloss', 'someone'] ] ] }
+        its(:to_s) { should == 'nickname IN ("pangloss", "someone")' }
+        it 'should encode the Set property as an Or pipe' do
+          props = subject.send :encoded_properties
+          pipe = props.assoc('nickname').last
+          pipe.should be_a Pacer::Filter::WhereFilter::NodeVisitor::Pipe
+          pipe.build.should be_a Java::ComTinkerpopPipesFilter::OrFilterPipe
+        end
+      end
+
       context 'with extensions' do
         let(:filters) { Pacer::Route.send filter_method, [TP::Person, name: 'Darrick', nickname: 'pangloss'] }
 

data/spec/pacer/filter/property_filter_spec.rb

@@ -34,6 +34,20 @@ Run.tg(:read_only) do
       end
     end
 
+    context 'v(:type => "person", :name => Set["pangloss", "someone"])' do
+      subject { graph.v(:type => 'person', :name => Set['pangloss', 'someone']) }
+      its(:to_a) { should == graph.v('type' => 'person', 'name' => 'pangloss').to_a }
+      its(:to_a) { should == graph.v.where('type = "person" and (name == "pangloss" or name == "someone")').to_a }
+      its(:count) { should == 1 }
+      its(:extensions) { should == [] }
+      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 }

data/spec/pacer/graph/pacer_graph_spec.rb

@@ -94,6 +94,11 @@ Run.all :read_write do
     describe '#create_vertex' do
       let(:use_id) { rand 1000000 }
 
+      before do
+        c = example.metadata[:graph_commit]
+        c.call if c
+      end
+
       context 'existing' do
         it 'should raise an exception' do
           unless graph.features.ignoresSuppliedIds
@@ -168,6 +173,11 @@ Run.all :read_write do
       let(:from) { graph.vertex v0.element_id }
       let(:to) { graph.vertex v1.element_id }
 
+      before do
+        c = example.metadata[:graph_commit]
+        c.call if c
+      end
+
       context 'existing' do
         it 'should raise an exception' do
           if not graph.features.ignoresSuppliedIds
@@ -341,6 +351,8 @@ Run.all :read_write do
       it 'should not load the data into a graph with conflicting vertex ids' do
         unless graph.features.ignoresSuppliedIds
           graph.create_vertex '0' unless graph.vertex '0'
+          c = example.metadata[:graph_commit]
+          c.call if c
           expect { Pacer::GraphML.import graph, 'spec/data/pacer.graphml' }.to raise_error(Pacer::ElementExists)
         end
       end

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

@@ -30,7 +30,7 @@ Run.all do
 
       its(:inspect) do
         should be_one_of "#<V-Index(name: \"gremlin\") -> V-Section -> :grem -> inE(:wrote)>",
-                         /#<V-Lucene\(name:gremlin\) ~ \d+ -> V-Section -> :grem -> inE\(:wrote\)>/,
+                         /#<V-Lucene\(name:"gremlin"\) ~ \d+ -> V-Section -> :grem -> inE\(:wrote\)>/,
                          "#<GraphV -> V-Property(name==\"gremlin\") -> V-Section -> :grem -> inE(:wrote)>"
       end
       its(:out_v) { should_not be_nil }
@@ -87,7 +87,7 @@ Run.all do
         use_simple_graph_data
         before { setup_data }
         subject { graph.v.element_ids.to_a }
-        its(:sort) { should == [v0, v1].to_route(based_on: graph.v).element_ids.to_a.sort }
+        its(:to_set) { should == [v0, v1].to_route(based_on: graph.v).element_ids.to_set }
       end
     end
   end
@@ -107,7 +107,7 @@ Run.all(:read_only) do
         r = r.in_v
         r = r.is_not(:grem)
         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)>",
-                                   /#<V-Lucene\(name:gremlin\) ~ \d+ -> V-Section -> :grem -> inE\(:wrote\) -> outV -> outE\(:wrote\) -> E-Property\(&block\) -> inV -> V-Property\(&block\)>/,
+                                   /#<V-Lucene\(name:"gremlin"\) ~ \d+ -> 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

data/spec/pacer/transform/sort_section_spec.rb

@@ -5,6 +5,35 @@ Run.tg :read_only do
 
   let(:unsorted) { graph.v.out.out }
 
+  describe 'sort by custom sort' do
+    let(:by_custom) do
+      graph.v.section(:x).out.out.sort_section(:x) { |a, b| a[:name] <=> b[:name] }
+    end
+
+    it 'should have the same elements' do
+      by_custom.group_count.should == unsorted.group_count
+    end
+
+    it 'should have 3 elements in the path' do
+      by_custom.paths.each do |path|
+        path.length.should == 3
+      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].custom_sort_section(:proj) { |a, b| a <=> b }
+      route.to_a.should == %w[
+        blueprints
+        blueprints
+        gremlin
+        pipes
+        blueprints
+        pipes
+      ]
+    end
+  end
+
   describe 'sort by name' do
     let(:by_name) do
       graph.v.section(:x).out.out.sort_section(:x) { |v| v[:name] }

data/spec/pacer/wrapper/edge_wrapper_spec.rb

@@ -100,6 +100,52 @@ describe Pacer::Wrappers::EdgeWrapper do
     end
   end
 
+  describe '#reverse!' do
+    it 'should remove the old element' do
+      id = e0.element_id
+      e0.reverse!
+      c = example.metadata[:graph_commit]
+      c.call if c
+      graph.edge(id).should be_nil
+    end
+
+    it 'should create a new element with the same label' do
+      label = e0.label
+      new_e = e0.reverse!
+      new_e.label.should == label
+    end
+
+    it 'should not have the same element_id' do
+      id = e0.element_id
+      new_e = e0.reverse!
+      new_e.element_id.should_not == id
+    end
+
+    it 'should reverse the direction' do
+      iv = e0.in_vertex
+      ov = e0.out_vertex
+      new_e = e0.reverse!
+      new_e.in_vertex.should == ov
+      new_e.out_vertex.should == iv
+    end
+
+    it 'should change the label' do
+      new_e = e0.reverse! label: 'hello!!'
+      new_e.label.should == 'hello!!'
+    end
+
+    it 'should reuse the element id' do
+      unless graph.features.ignoresSuppliedIds
+        e0
+        c = example.metadata[:graph_commit]
+        c.call if c
+        id = e0.element_id
+        new_e = e0.reverse! reuse_id: true
+        new_e.element_id.should == id.to_s
+      end
+    end
+  end
+
   contexts(
   'into new tg' => proc {
     let(:dest) { Pacer.tg }
@@ -115,7 +161,12 @@ describe Pacer::Wrappers::EdgeWrapper do
   }) do
     describe '#clone_into' do
       context 'including vertices' do
-        subject { e0.clone_into(dest, :create_vertices => true) }
+        subject do
+          e0
+          c = example.metadata[:graph_commit]
+          c.call if c
+          e0.clone_into(dest, :create_vertices => true)
+        end
 
         its('element_id.to_s') { should == e0.element_id.to_s unless graph.features.ignoresSuppliedIds }
         its(:label) { should == 'links' }
@@ -132,6 +183,9 @@ describe Pacer::Wrappers::EdgeWrapper do
 
         context 'existing' do
           before do
+            v0; v1; e0
+            c = example.metadata[:graph_commit]
+            c.call if c
             v0.clone_into(dest)
             v1.clone_into(dest)
           end
@@ -146,7 +200,16 @@ describe Pacer::Wrappers::EdgeWrapper do
     end
 
     describe '#copy_into' do
-      subject { v0.clone_into(dest); v1.clone_into(dest); e0.copy_into(dest) }
+      before do
+        v0; v1; e0
+        c = example.metadata[:graph_commit]
+        c.call if c
+      end
+      subject do
+        v0.clone_into(dest)
+        v1.clone_into(dest)
+        e0.copy_into(dest)
+      end
       its(:label) { should == 'links' }
       its(:graph) { should equal(dest) }
       its('in_vertex.properties') { should == e0.in_vertex.properties }

data/spec/pacer/wrapper/vertex_wrapper_spec.rb

@@ -195,13 +195,13 @@ shared_examples_for Pacer::Wrappers::VertexWrapper do
   subject { v0 }
   its(:graph) { should equal(graph) }
   its(:display_name) { should be_nil }
-  its(:inspect) { should =~ /#<[VM]\[#{v0.element_id}\]>/ }
+  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]\[#{ v0.element_id }\] some name>/ }
+    its(:inspect) { should =~ /#<[VM]\[#{ Regexp.quote v0.element_id.to_s }\] some name>/ }
   end
   it { should_not == v1 }
   it { should == v0 }

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pacer
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 1.2.0
+  version: 1.3.1
 platform: java
 authors:
 - Darrick Wiebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-02-04 00:00:00.000000000 Z
+date: 2013-07-04 00:00:00.000000000 Z
 dependencies: []
 description: Pacer defines routes through a graph and then traverses them very quickly.
 email: darrick@innatesoftware.com
@@ -218,39 +217,30 @@ files:
 - spec/support/use_transactions.rb
 - spec/tackle/simple_mixin.rb
 - spec/tackle/tinkerpop_graph_mixins.rb
-- lib/pacer-1.2.0-standalone.jar
+- lib/pacer-1.3.1-standalone.jar
 homepage: http://github.com/pangloss/pacer
 licenses:
 - MIT
+metadata: {}
 post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 2
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 2
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: A very efficient and easy to use graph traversal engine.
 test_files:
 - spec/data/grateful-dead.xml
@@ -307,3 +297,4 @@ test_files:
 - spec/support/use_transactions.rb
 - spec/tackle/simple_mixin.rb
 - spec/tackle/tinkerpop_graph_mixins.rb
+has_rdoc: