pacer 0.9.1.1-java → 1.0.0-java

data/lib/pacer/graph/pacer_graph.rb

@@ -0,0 +1,438 @@
+module Pacer
+  class PacerGraph
+    include GraphTransactionsMixin
+
+    include Pacer::Core::Route
+    include Pacer::Core::Graph::GraphRoute
+    include Pacer::Core::Graph::GraphIndexRoute
+
+    attr_reader :blueprints_graph, :encoder
+
+    def initialize(encoder, open, shutdown = nil)
+      @reopen = open
+      @shutdown = shutdown
+      reopen
+      @encoder = encoder
+    end
+
+    # The current graph
+    #
+    # @return [PacerGraph] returns self
+    def graph
+      self
+    end
+
+    def reopen
+      graph = @reopen.call
+      if graph.is_a? PacerGraph
+        @blueprints_graph = graph.blueprints_graph
+      else
+        @blueprints_graph = graph
+      end
+      self
+    end
+
+    def shutdown
+      @shutdown.call self if @shutdown
+      @blueprints_graph = nil
+      self
+    end
+
+    def graph_id
+      blueprints_graph.object_id
+    end
+
+    def equals(other)
+      other.class == self.class and graph_id == other.graph_id
+    end
+
+    # Get a vertex by id.
+    #
+    # @overload vertex(id)
+    #   @param [element id] id
+    # @overload vertex(id, *modules)
+    #   @param [element id] id
+    #   @param [Module, Class] *modules extensions to add to the returned
+    #     vertex.
+    def vertex(id, *modules)
+      begin
+        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 v
+          modules.delete wrapper
+        else
+          v = Pacer::Wrappers::VertexWrapper.new v
+        end
+        v.graph = self
+        v.add_extensions modules
+      else
+        v
+      end
+    end
+
+    # Get an edge by id.
+    #
+    # @overload edge(id)
+    #   @param [element id] id
+    # @overload edge(id, *modules)
+    #   @param [element id] id
+    #   @param [Module, Class] *modules extensions to add to the returned
+    #     edge.
+    def edge(id, *modules)
+      begin
+        v = blueprints_graph.getEdge(id)
+      rescue Java::JavaLang::RuntimeException
+      end
+      if v
+        wrapper = modules.detect { |obj| obj.ancestors.include? Pacer::Wrappers::EdgeWrapper }
+        if wrapper
+          v = wrapper.new v
+          modules.delete wrapper
+        else
+          v = Pacer::Wrappers::EdgeWrapper.new v
+        end
+        v.graph = self
+        v.add_extensions modules
+      end
+    end
+
+    # Create a vertex in the graph.
+    #
+    # @overload create_vertex(*args)
+    #   @param [extension, Hash] *args extension (Module/Class) arguments will be
+    #     added to the current vertex. A Hash will be
+    #     treated as element properties.
+    # @overload create_vertex(id, *args)
+    #   @param [element id] id the desired element id. Some graphs
+    #     ignore this.
+    #   @param [extension, Hash] *args extension (Module/Class) arguments will be
+    #     added to the current vertex. A Hash will be
+    #     treated as element properties.
+    def create_vertex(*args)
+      id, wrapper, modules, props = id_modules_properties(args)
+      raw_vertex = creating_elements { blueprints_graph.addVertex(id) }
+      if wrapper
+        vertex = wrapper.new raw_vertex
+      else
+        vertex = Pacer::Wrappers::VertexWrapper.new raw_vertex
+      end
+      if modules.any?
+        vertex = vertex.add_extensions modules
+      end
+      vertex.graph = self
+      props.each { |k, v| vertex[k.to_s] = v } if props
+      vertex
+    end
+
+    # Create an edge in the graph.
+    #
+    # @param [element id] id some graphs allow you to specify your own edge id.
+    # @param [Pacer::Wrappers::VertexWrapper] from_v the new edge's out_vertex
+    # @param [Pacer::Wrappers::VertexWrapper] to_v the new edge's in_vertex
+    # @param [#to_s] label the edge label
+    # @param [extension, Hash] *args extension (Module/Class) arguments will be
+    #   added to the returned edge. A Hash will be
+    #   treated as element properties.
+    #
+    # @todo make id param optional
+    def create_edge(id, from_v, to_v, label, *args)
+      _, wrapper, modules, props = id_modules_properties(args)
+      raw_edge = creating_elements { blueprints_graph.addEdge(id, from_v.element, to_v.element, label.to_s) }
+      if wrapper
+        edge = wrapper.new raw_edge
+      else
+        edge = Pacer::Wrappers::EdgeWrapper.new raw_edge
+      end
+      if modules.any?
+        edge = edge.add_extensions modules
+      end
+      edge.graph = self
+      props.each { |k, v| edge[k.to_s] = v } if props
+      edge
+    end
+
+    def remove_vertex(vertex)
+      blueprints_graph.removeVertex vertex
+    end
+
+    def remove_edge(edge)
+      blueprints_graph.removeEdge edge
+    end
+
+    # Directly loads an array of vertices by id.
+    #
+    # @param [[vertex ids]] ids
+    # @return [[Pacer::Wrappers::VertexWrapper]]
+    def load_vertices(ids)
+      ids.map do |id|
+        vertex id
+      end.compact
+    end
+
+    # Directly loads an array of edges by id.
+    #
+    # @param [[edge ids]] ids
+    # @return [[Pacer::Wrappers::EdgeWrapper]]
+    def load_edges(ids)
+      ids.map do |id|
+        edge id
+      end.compact
+    end
+
+    def features
+      blueprints_graph.features
+    end
+
+    module Encoding
+      def sanitize_properties(props)
+        encoder.sanitize_properties props
+      end
+
+      def encode_property(value)
+        encoder.encode_property value
+      end
+
+      def decode_property(value)
+        encoder.decode_property value
+      end
+    end
+    include Encoding
+
+    module Naming
+      # The proc used to name vertices.
+      #
+      # @return [Proc]
+      def vertex_name
+        @vertex_name if defined? @vertex_name
+      end
+
+      # Set the proc used to name vertices.
+      #
+      # @param [Proc(vertex)] a_proc returns a string given a vertex
+      def vertex_name=(a_proc)
+        @vertex_name = a_proc
+      end
+
+      # The proc used to name edges.
+      #
+      # @return [Proc]
+      def edge_name
+        @edge_name if defined? @edge_name
+      end
+
+      # Set the proc used to name edges.
+      #
+      # @param [Proc(edge)] a_proc returns a string given an edge
+      def edge_name=(a_proc)
+        @edge_name = a_proc
+      end
+    end
+    include Naming
+
+
+    module BulkJob
+      attr_accessor :in_bulk_job
+
+      # Set how many elements should go into each transaction in a bulk
+      # job.
+      #
+      # @param [Fixnum] size number of elements
+      def bulk_job_size=(size)
+        @bulk_job_size = size
+      end
+
+      # The currently configured bulk job size.
+      def bulk_job_size
+        if defined? @bulk_job_size
+          @bulk_job_size
+        else
+          5000
+        end
+      end
+
+      # Are we currently in the midst of a bulk job?
+      def in_bulk_job?
+        @in_bulk_job if defined? @in_bulk_job
+      end
+    end
+    include BulkJob
+
+    module Indices
+      # Return an index by name.
+      #
+      # @param [#to_s] name of the index
+      # @param [:vertex, :edge, element type] type guarantees that the index returned is of the type specified.
+      # @param [Hash] opts
+      # @option opts [true] :create create the index if it doesn't exist
+      # @return [Pacer::IndexMixin]
+      def index(name, type = nil, opts = {})
+        return unless features.supportsIndices
+        name = name.to_s
+        if type
+          type = index_class element_type type
+          idx = blueprints_graph.getIndices.detect { |i| i.index_name == name }
+          if idx.nil? and opts[:create]
+            idx = blueprints_graph.createIndex name, type
+          end
+        else
+          idx = blueprints_graph.getIndices.detect { |i| i.index_name == name }
+        end
+        Pacer::Wrappers::IndexWrapper.new self, idx, type if idx
+      end
+
+      def drop_index(idx)
+        return unless features.supportsIndices
+        if idx.is_a? String or idx.is_a? Symbol
+          blueprints_graph.dropIndex idx
+        else
+          blueprints_graph.dropIndex idx.indexName
+        end
+      end
+
+      # Return an object that can be compared to the return value of
+      # Index#index_class.
+      def index_class(et)
+        type = case et
+               when :vertex
+                 Pacer::Vertex
+               when :edge
+                 Pacer::Edge
+               else
+                 fail InternalError, "Unable to determine index class from #{ et.inspect }"
+               end
+        type.java_class.to_java
+      end
+
+      def index_class?(et, thing)
+        if thing.interface?
+          index_class(et) == thing
+        else
+          thing.interfaces.include? index_class(et)
+        end
+      end
+
+      def indices
+        if features.supportsIndices
+          blueprints_graph.getIndices
+        else
+          []
+        end
+      end
+    end
+    include Indices
+
+    module KeyIndices
+      def create_key_index(name, type)
+        if features.supportsKeyIndices
+          if element_type(type) == :vertex and features.supportsVertexKeyIndex
+            blueprints_graph.createKeyIndex name, index_class(:vertex)
+          elsif element_type(type) == :edge and features.supportsEdgeKeyIndex
+            blueprints_graph.createKeyIndex name, index_class(:edge)
+          end
+        end
+      end
+
+      def key_indices(type = nil)
+        if features.supportsKeyIndices
+          if type
+            blueprints_graph.getIndexedKeys(index_class(type)).to_set
+          else
+            blueprints_graph.getIndexedKeys(index_class(:vertex)).to_set +
+              blueprints_graph.getIndexedKeys(index_class(:vertex))
+          end
+        else
+          []
+        end
+      end
+    end
+    include KeyIndices
+
+    module ElementType
+      # Is the element type given supported by this graph?
+      #
+      # @param [:edge, :vertex, :mixed, element_type, Object] et the
+      #   object we're testing
+      def element_type?(et)
+        [:vertex, :edge, :mixed].include?  element_type(et)
+      end
+
+      def element_type(et = nil)
+        return nil unless et
+        result = case et
+                 when :vertex, Pacer::Vertex
+                   :vertex
+                 when :edge, Pacer::Edge
+                   :edge
+                 when :mixed, Pacer::Element
+                   :mixed
+                 when :object
+                   :object
+                 else
+                   if et == Object
+                     :object
+                   elsif et == index_class(:vertex)
+                     :vertex
+                   elsif et == index_class(:edge)
+                     :edge
+                   end
+                 end
+        if result
+          result
+        else
+          raise ArgumentError, 'Element type may be one of :vertex, :edge, :mixed or :object'
+        end
+      end
+    end
+    include ElementType
+
+    private
+
+    def id_modules_properties(args)
+      props = args.last if args.last.is_a? Hash
+      modules = args.select { |obj| obj.is_a? Module or obj.is_a? Class }
+      wrapper = modules.detect { |obj| obj.is_a? Class and obj.ancestors.include? Pacer::Wrappers::ElementWrapper }
+      id = args.first
+      if not wrapper and modules.empty?
+        args.each do |obj|
+          if obj.respond_to? :wrapper
+            wrapper = obj.wrapper
+            id = nil if id == obj
+            break
+          elsif obj.respond_to? :parts
+            modules = obj.parts
+            id = nil if id == obj
+            break
+          end
+        end
+      end
+      modules.delete wrapper
+      begin
+        id = nil if id == props or modules.include? id or id == wrapper
+      rescue Exception
+        # Orient uses an ID type that can't be compared with things?
+      end
+      [id, wrapper, modules, props]
+    end
+
+    # Helper method to wrap element creation in exception handling.
+    def creating_elements
+      begin
+        yield
+      rescue NativeException => e
+        if e.message =~ /already exists/
+          raise ElementExists, e.message
+        else
+          raise
+        end
+      end
+    end
+
+    def source_iterator
+      [blueprints_graph]
+    end
+  end
+end

data/lib/pacer/graph/simple_encoder.rb

@@ -0,0 +1,20 @@
+module Pacer
+  class SimpleEncoder
+    def self.sanitize_properties(props)
+      props
+    end
+
+    def self.encode_property(value)
+      if value.is_a? String
+        value = value.strip
+        value unless value == ''
+      else
+        value
+      end
+    end
+
+    def self.decode_property(value)
+      value
+    end
+  end
+end

data/lib/pacer/graph/yaml_encoder.rb

@@ -0,0 +1,81 @@
+module Pacer
+  # This encoder was originally part of pacer-neo4j. It uses native data where
+  # Neo4j could and for everything else it uses (slow (but easy))
+  # human-readable YAML encoding.
+  class YamlEncoder
+    def self.sanitize_properties(props)
+      pairs = props.map do |name, value|
+        [name, encode_property(value)]
+      end
+      Hash[pairs]
+    end
+
+    def self.encode_property(value)
+      case value
+      when nil
+        nil
+      when String
+        value = value.strip
+        value = nil if value == ''
+        value
+      when Numeric
+        if value.is_a? Bignum
+          value.to_yaml
+        else
+          value
+        end
+      when true, false
+        value
+      when Array
+        if value.length == 0
+          value_type = Fixnum
+        else
+          value_type = value.first.class
+          value_type = TrueClass if value_type == FalseClass
+          value.each do |v|
+            if value_type != v.class or (value == true or value == false and value_type == TrueClass)
+              value_type = nil
+              break
+            end
+          end
+        end
+        case value_type
+        when Fixnum
+          value.to_java :long
+        when Float
+          value.to_java :double
+        when TrueClass
+          value.to_java :boolean
+        when String
+          value.to_java :string
+        else
+          value.to_yaml
+        end
+      else
+        value.to_yaml
+      end
+    end
+
+    if 'x'.to_yaml[0, 5] == '%YAML'
+      def self.decode_property(value)
+        if value.is_a? String and value[0, 5] == '%YAML'
+          YAML.load(value)
+        elsif value.is_a? ArrayJavaProxy
+          value.to_a
+        else
+          value
+        end
+      end
+    else
+      def self.decode_property(value)
+        if value.is_a? String and value[0, 3] == '---'
+          YAML.load(value)
+        elsif value.is_a? ArrayJavaProxy
+          value.to_a
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/pacer/graph.rb

@@ -1,14 +1,12 @@
 module Pacer
-  import com.tinkerpop.blueprints.pgm.Graph
-  import com.tinkerpop.blueprints.pgm.Element
-  import com.tinkerpop.blueprints.pgm.Vertex
-  import com.tinkerpop.blueprints.pgm.Edge
+  import com.tinkerpop.blueprints.Graph
+  import com.tinkerpop.blueprints.Element
+  import com.tinkerpop.blueprints.Vertex
+  import com.tinkerpop.blueprints.Edge
 end
 
-require 'pacer/graph/graph_mixin'
-require 'pacer/graph/element_mixin'
-require 'pacer/graph/vertex_mixin'
-require 'pacer/graph/edge_mixin'
-require 'pacer/graph/index_mixin'
-require 'pacer/graph/graph_indices_mixin'
 require 'pacer/graph/graph_transactions_mixin'
+require 'pacer/graph/pacer_graph.rb'
+require 'pacer/graph/simple_encoder.rb'
+require 'pacer/graph/yaml_encoder.rb'
+require 'pacer/graph/graph_ml'

data/lib/pacer/pipe/blackbox_pipeline.rb

@@ -6,8 +6,10 @@ module Pacer::Pipes
   # pass it on to a pipe like FutureFilterPipe that only
   # knows how to act on a single pipe.
   class BlackboxPipeline
-    include com.tinkerpop.pipes.Pipe 
-    
+    include com.tinkerpop.pipes.Pipe
+
+    attr_reader :pathEnabled
+
     def initialize(start_pipe, end_pipe)
       @start_pipe = start_pipe
       @end_pipe = end_pipe
@@ -33,8 +35,13 @@ module Pacer::Pipes
       @end_pipe.reset
     end
 
-    def getPath
-      @end_pipe.getPath
+    def enablePath(b)
+      @pathEnabled = b
+      @end_pipe.enablePath b
+    end
+
+    def getCurrentPath
+      @end_pipe.getCurrentPath
     end
 
     def iterator

data/lib/pacer/pipe/block_filter_pipe.rb

@@ -2,37 +2,20 @@ module Pacer::Pipes
   class BlockFilterPipe < AbstractPipe
     field_reader :starts
 
+    attr_reader :block
+
     def initialize(back, block, invert = false)
       super()
-      @back = back
-      @block = block
-      @graph = back.graph
-      @invert = invert
-
-      @exts = @back.extensions + [Pacer::Extensions::BlockFilterElement]
-      @is_element = @graph.element_type?(back.element_type) if @graph
+      @block = Pacer::Wrappers::WrappingPipeFunction.new back, block
     end
 
     def processNextStart()
       while raw_element = starts.next
-        if @is_element
-          extended_element = raw_element.add_extensions(@exts)
-          extended_element.back = @back
-          extended_element.graph = @back.graph
-          ok = @block.call extended_element
-        else
-          ok = @block.call raw_element
-        end
+        ok = block.call raw_element
         ok = !ok if @invert
         return raw_element if ok
       end
-      raise Pacer::NoSuchElementException
-    rescue NativeException => e
-      if e.cause.getClass == Pacer::NoSuchElementException.getClass
-        raise e.cause
-      else
-        raise e
-      end
+      raise EmptyPipe.instance
     end
   end
 end

data/lib/pacer/pipe/cross_product_transform_pipe.rb

@@ -15,12 +15,6 @@ module Pacer::Pipes
     def processNextStart
       next_pair
       a.send method, b rescue nil if a.respond_to? method
-    rescue NativeException => e
-      if e.cause.getClass == Pacer::NoSuchElementException.getClass
-        raise e.cause
-      else
-        raise e
-      end
     end
 
     protected
@@ -31,8 +25,12 @@ module Pacer::Pipes
       if branch_b
         begin
           self.b = branch_b.next
+        rescue Pacer::EmptyPipe, java.util.NoSuchElementException
+          next_a
+          branch_b.setStarts SingleIterator.new(element)
+          retry
         rescue NativeException => e
-          if e.cause.getClass == Pacer::NoSuchElementException.getClass or @first
+          if @first
             next_a
             branch_b.setStarts SingleIterator.new(element)
             retry

data/lib/pacer/pipe/edges_pipe.rb

@@ -0,0 +1,22 @@
+module Pacer::Pipes
+  class EdgesPipe < AbstractPipe
+    attr_reader :starts
+
+    def setStarts(starts)
+      @starts = starts.first
+      self.iter = @starts.getEdges.iterator
+    end
+
+    def processNextStart
+      iter.next
+    end
+
+    def reset
+      self.iter = @starts.getEdges.iterator
+    end
+
+    private
+
+    attr_accessor :iter
+  end
+end

data/lib/pacer/pipe/enumerable_pipe.rb

@@ -5,8 +5,8 @@ module Pacer::Pipes
       case enumerable
       when Enumerator
         starts = enumerable
-      when Pacer::ElementMixin
-        starts = [enumerable].to_enum
+      when Pacer::Wrappers::ElementWrapper
+        starts = [enumerable.element].to_enum
       when Enumerable
         starts = enumerable.to_enum
       else
@@ -18,13 +18,7 @@ module Pacer::Pipes
     def processNextStart()
       @starts.next
     rescue StopIteration
-      raise Pacer::NoSuchElementException
-    rescue NativeException => e
-      if e.cause.getClass == Pacer::NoSuchElementException.getClass
-        raise e.cause
-      else
-        raise e
-      end
+      raise EmptyPipe.instance
     end
   end
 end