pacer 1.0.3-java → 1.1.0-java

data/lib/pacer/transform/process.rb

@@ -11,6 +11,21 @@ module Pacer
     module Process
       attr_accessor :block
 
+      def help(section = nil)
+        case section
+        when nil
+          puts <<HELP
+The process method executes the given block for each element that is
+passed through the route. After the block is called, the element that
+was passed to it is emitted to be handled by the next step in the route.
+
+It is Pacer's lazy version of the #each method.
+
+HELP
+        else
+          super
+        end
+      end
       protected
 
       def attach_pipe(end_pipe)

data/lib/pacer/transform/wrapped_path.rb

@@ -0,0 +1,23 @@
+module Pacer
+  module Core
+    module Graph
+      module PathRoute
+        def wrapped(*exts)
+          chain_route transform: :wrap_path, element_type: :path
+        end
+      end
+    end
+  end
+
+  module Transform
+    module WrapPath
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = Pacer::Pipes::PathWrappingPipe.new(graph)
+        pipe.setStarts end_pipe
+        pipe
+      end
+    end
+  end
+end

data/lib/pacer/utils/graph_analysis.rb

@@ -8,14 +8,28 @@ module Pacer
         def structure(graph, type_field = :type)
           result = Pacer.tg
           result.vertex_name = proc do |v|
-            if v[:element_type] == 'vertex'
-              "vertex '#{v[:type]}' (#{v[:count]})"
-            elsif v[:element_type] == 'edge'
-              "edge :#{v[:label]} (#{v[:count]})"
-            elsif v[:element_type] == 'property keys'
-              "properties #{v[:number]} keys (#{v[:count]})"
+            case v[:element_type]
+            when 'vertex'
+              "vertex '#{ v[:type] }' (#{ v[:count] })"
+            when 'edge'
+              "edge '#{ v[:label] }' (#{ v[:count] })"
+            when 'property keys'
+              if v[:keys].empty?
+                "has no properties"
+              else
+                "has properties: #{ v[:keys].join ', ' } (#{ v[:count] })"
+              end
+            end
+          end
+          result.edge_name = proc do |e|
+            if e.label == 'properties'
+              "#{ e[:count] }"
+            else
+              "#{ e[:count] } '#{ e.label }' edges to"
             end
           end
+
+
           graph.v[type_field].fast_group_count.to_h.each do |type, count|
             result.create_vertex :element_type => 'vertex', :type_field => type_field, :type => type, :count => count
           end
@@ -28,7 +42,7 @@ module Pacer
           end
           result.v(:element_type => 'edge').each do |edge_node|
             puts "edges with label #{ edge_node[:label] }: #{ edge_node[:count] }"
-            edge_route = graph.e(self, edge_node[:label])
+            edge_route = graph.e(edge_node[:label]).e(self)
             edge_route.property_variations result, edge_node
           end
           result.v.each do |type_node|

data/lib/pacer/version.rb

@@ -1,6 +1,6 @@
 module Pacer
   unless const_defined? :VERSION
-    VERSION = "1.0.3"
+    VERSION = "1.1.0"
 
     JAR = "pacer-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"

data/lib/pacer/wrappers/edge_wrapper.rb

@@ -4,9 +4,12 @@ module Pacer::Wrappers
     include Pacer::Core::Graph::EdgesRoute
 
     def_delegators :@element,
-      :getId, :getLabel, :getPropertyKeys, :getProperty, :setProperty, :removeProperty,
-      :getVertex,
-      :getRawEdge
+      # Object
+      :equals, :toString, :hashCode,
+      # Element
+      :getId, :getPropertyKeys, :getProperty, :setProperty, :removeProperty, :getRawElement,
+      # Edge
+      :getLabel, :getVertex, :getRawEdge
 
     class << self
       def wrappers
@@ -128,7 +131,7 @@ module Pacer::Wrappers
     # @yield [e] Optional block yields the edge after it has been created.
     # @return [Pacer::Wrappers::EdgeWrapper] the new edge
     #
-    # @raise [StandardError] If this the associated vertices don't exist and :create_vertices is not set
+    # @raise [Pacer::ElementNotFound] If this the associated vertices don't exist and :create_vertices is not set
     def clone_into(target_graph, opts = {})
       e_idx = target_graph.temp_index("tmp-e-#{graph.graph_id}", :edge, :create => true)
       e = e_idx.first('id', element_id)
@@ -143,7 +146,7 @@ module Pacer::Wrappers
         if not iv or not ov
           message = "Vertex not found for #{ self.inspect }: #{ iv.inspect } -> #{ ov.inspect }"
           puts message if opts[:show_missing_vertices]
-          raise message unless opts[:ignore_missing_vertices]
+          fail Pacer::ElementNotFound, message unless opts[:ignore_missing_vertices]
           return nil
         end
         e = target_graph.create_edge(element_id, ov, iv, label, properties)
@@ -160,13 +163,13 @@ module Pacer::Wrappers
     # @yield [e] Optional block yields the edge after it has been created.
     # @return [Pacer::Wrappers::EdgeWrapper] the new edge
     #
-    # @raise [StandardError] If this the associated vertices don't exist
+    # @raise [Pacer::ElementNotFound] If this the associated vertices don't exist
     def copy_into(target_graph)
       v_idx = target_graph.temp_index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
       iv = v_idx.first('id', in_vertex.element_id) || target_graph.vertex(in_vertex.element_id)
       ov = v_idx.first('id', out_vertex.element_id) || target_graph.vertex(out_vertex.element_id)
 
-      raise 'vertices not found' if not iv or not ov
+      fail Pacer::ElementNotFound 'vertices not found' if not iv or not ov
       e = target_graph.create_edge nil, ov, iv, label, properties
       yield e if block_given?
       e
@@ -197,5 +200,13 @@ module Pacer::Wrappers
     def hash
       -element.hash
     end
+
+    def element_payload=(data)
+      if element.is_a? Pacer::Payload::Edge
+        element.payload = data
+      else
+        @element = Pacer::Payload::Edge.new element, data
+      end
+    end
   end
 end

data/lib/pacer/wrappers/element_wrapper.rb

@@ -160,6 +160,10 @@ module Pacer::Wrappers
       display_name.to_s <=> other.display_name.to_s
     end
 
+    def element_payload
+      element.payload if element.is_a? Pacer::Payload::Element
+    end
+
     protected
 
     def after_initialize

data/lib/pacer/wrappers/index_wrapper.rb

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

data/lib/pacer/wrappers/path_wrapping_pipe_function.rb

@@ -0,0 +1,85 @@
+module Pacer
+  module Wrappers
+    class PathWrappingPipeFunction
+      include com.tinkerpop.pipes.PipeFunction
+
+      attr_reader :block, :graph, :wrapper
+
+      def initialize(back, block)
+        @block = block
+        if back
+          @graph = back.graph
+        end
+        @wrapper = WrapperSelector.build
+      end
+
+      def arity
+        block.arity
+      end
+
+      def compute(path)
+        if path.first.is_a? Pacer::Wrappers::ElementWrapper
+          block.call path
+        else
+          p = path.map do |element|
+            wrapper.new graph, element
+          end
+          block.call p
+        end
+      end
+
+      alias call compute
+
+      def call_with_args(element, *args)
+        if path.first.is_a? Pacer::Wrappers::ElementWrapper
+          block.call path, *args
+        else
+          p = path.map do |element|
+            wrapper.new graph, element
+          end
+          block.call p, *args
+        end
+      end
+    end
+
+    class PathUnwrappingPipeFunction
+      include com.tinkerpop.pipes.PipeFunction
+
+      attr_reader :block
+
+      def initialize(block)
+        @block = block
+      end
+
+      def arity
+        block.arity
+      end
+
+      def compute(path)
+        unwrap block.call path
+      end
+
+      alias call compute
+
+      def call_with_args(path, *args)
+        unwrap block.call path, *args
+      end
+
+      def unwrap(p)
+        if p.is_a? Array
+          p.map do |e|
+            if e.is_a? ElementWrapper
+              e.element
+            else
+              e
+            end
+          end
+        elsif p.is_a? ElementWrapper
+          p.element
+        else
+          p
+        end
+      end
+    end
+  end
+end

data/lib/pacer/wrappers/vertex_wrapper.rb

@@ -4,9 +4,12 @@ module Pacer::Wrappers
     include Pacer::Core::Graph::VerticesRoute
 
     def_delegators :@element,
-      :getId, :getPropertyKeys, :getProperty, :setProperty, :removeProperty,
-      :getEdges,
-      :getRawVertex
+      # Object
+      :equals, :toString, :hashCode,
+      # Element
+      :getId, :getPropertyKeys, :getProperty, :setProperty, :removeProperty, :getRawElement,
+      # Vertex
+      :getEdges, :getVertices, :query, :getRawVertex
 
     class << self
       def wrappers
@@ -164,6 +167,18 @@ module Pacer::Wrappers
       get_edges_helper Pacer::Pipes::BOTH, *labels_and_extensions
     end
 
+    def out_vertices(*labels_and_extensions)
+      get_vertices_helper Pacer::Pipes::OUT, *labels_and_extensions
+    end
+
+    def in_vertices(*labels_and_extensions)
+      get_vertices_helper Pacer::Pipes::IN, *labels_and_extensions
+    end
+
+    def both_vertices(*labels_and_extensions)
+      get_vertices_helper Pacer::Pipes::BOTH, *labels_and_extensions
+    end
+
     # Test equality to another object.
     #
     # Elements are equal if they are the same type and have the same id
@@ -190,6 +205,14 @@ module Pacer::Wrappers
       element.hash
     end
 
+    def element_payload=(data)
+      if element.is_a? Pacer::Payload::Vertex
+        element.payload = data
+      else
+        @element = Pacer::Payload::Vertex.new element, data
+      end
+    end
+
     protected
 
     def get_edges_helper(direction, *labels_and_extensions)
@@ -199,6 +222,13 @@ module Pacer::Wrappers
       pipe
     end
 
+    def get_vertices_helper(direction, *labels_and_extensions)
+      labels, exts = split_labels_and_extensions(labels_and_extensions)
+      pipe = Pacer::Pipes::WrappingPipe.new graph, :vertex, exts
+      pipe.setStarts element.getVertices(direction, *labels).iterator
+      pipe
+    end
+
     def split_labels_and_extensions(mixed)
       labels = Set[]
       exts = []

data/pom.xml

@@ -7,7 +7,7 @@
     <artifactId>pacer</artifactId>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <properties>
-      <gem.version>1.0.3</gem.version>
+      <gem.version>1.1.0</gem.version>
       <blueprints.version>2.1.0</blueprints.version>
       <pipes.version>2.1.0</pipes.version>
       <gremlin.version>2.1.0</gremlin.version>

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+# edge filters are also tested in filters_spec
+module Pacer::Filter::PropertyFilter
+  Run.tg do
+    describe EdgeFilters do
+      subject { filters }
+
+      context 'symbol label' do
+        let(:filters) { Pacer::Route.edge_filters [:label] }
+
+        its(:any?) { should be_true }
+        its(:labels) { should == ['label'] }
+        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 be_empty }
+      end
+
+      context 'symbol labels' do
+        let(:filters) { Pacer::Route.edge_filters [:label, :label2] }
+
+        its(:any?) { should be_true }
+        its(:labels) { should == ['label', 'label2'] }
+      end
+
+      context 'labels arrays' do
+        let(:filters) { Pacer::Route.edge_filters ["label", [:label2]] }
+
+        its(:any?) { should be_true }
+        its(:labels) { should == ['label', 'label2'] }
+      end
+
+      context 'labels and properties' do
+        let(:filters) { Pacer::Route.edge_filters [:label, { prop: 'value' }] }
+
+        its(:any?) { should be_true }
+        its(:labels) { should == ['label'] }
+        its(:properties) { should == [['prop', 'value']] }
+      end
+
+      context 'labels and extension' do
+        let(:filters) { Pacer::Route.edge_filters [:label, TP::Person] }
+
+        its(:any?) { should be_true }
+        its(:labels) { should == ['label'] }
+        its(:extensions) { should == [TP::Person] }
+        its(:properties) { should == [ %w[ type person ] ] }
+      end
+
+      context 'labels and simple extension' do
+        let(:filters) { Pacer::Route.edge_filters [:label, Tackle::SimpleMixin] }
+
+        its(:any?) { should be_true }
+        its(:labels) { should == ['label'] }
+        its(:extensions) { should == [Tackle::SimpleMixin] }
+        its(:properties) { should be_empty }
+      end
+    end
+  end
+end

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

@@ -3,17 +3,17 @@ require 'spec_helper'
 module Pacer::Filter::PropertyFilter
 
   Run.tg do
-    describe Filters do
+    shared_examples Filters do
       subject { filters }
 
       context 'no properties' do
-        let(:filters) { Pacer::Route.filters [] }
+        let(:filters) { Pacer::Route.send filter_method, [] }
 
         its(:any?) { should be_false }
       end
 
       context 'no properties' do
-        let(:filters) { Pacer::Route.filters [Tackle::SimpleMixin] }
+        let(:filters) { Pacer::Route.send filter_method, [Tackle::SimpleMixin] }
 
         its(:any?) { should be_true }
         its(:extensions_only?) { should be_true }
@@ -25,7 +25,7 @@ module Pacer::Filter::PropertyFilter
       end
 
       context 'simple properties' do
-        let(:filters) { Pacer::Route.filters([name: 'Darrick', nickname: 'pangloss']) }
+        let(:filters) { Pacer::Route.send filter_method, [name: 'Darrick', nickname: 'pangloss'] }
 
         its(:any?) { should be_true }
         its(:extensions_only?) { should be_false }
@@ -37,7 +37,7 @@ module Pacer::Filter::PropertyFilter
       end
 
       context 'with extensions' do
-        let(:filters) { Pacer::Route.filters([TP::Person, name: 'Darrick', nickname: 'pangloss']) }
+        let(:filters) { Pacer::Route.send filter_method, [TP::Person, name: 'Darrick', nickname: 'pangloss'] }
 
         its(:any?) { should be_true }
         its(:extensions) { should == [TP::Person] }
@@ -113,7 +113,7 @@ module Pacer::Filter::PropertyFilter
 
       context 'with route module' do
         # TODO: should this feature be removed?
-        let(:filters) { Pacer::Route.filters [TP::Pangloss] }
+        let(:filters) { Pacer::Route.send filter_method, [TP::Pangloss] }
 
         its(:any?) { should be_true }
         its(:extensions_only?) { should be_false }
@@ -125,7 +125,7 @@ module Pacer::Filter::PropertyFilter
       end
 
       context 'with manual index' do
-        let(:filters) { Pacer::Route.filters [tokens: { short: '555555' }, name: 'Darrick'] }
+        let(:filters) { Pacer::Route.send filter_method, [tokens: { short: '555555' }, name: 'Darrick'] }
 
         its(:any?) { should be_true }
         its(:extensions) { should be_empty }
@@ -165,5 +165,15 @@ module Pacer::Filter::PropertyFilter
         end
       end
     end
+
+    describe 'vertex' do
+      let(:filter_method) { :filters }
+      it_uses Filters
+    end
+
+    describe 'edge' do
+      let(:filter_method) { :edge_filters }
+      it_uses Filters
+    end
   end
 end