pacer 0.9.1.1-java

data/lib/pacer/blueprints/ruby_graph.rb

@@ -0,0 +1,199 @@
+module Pacer
+  class RubyGraph
+    import com.tinkerpop.blueprints.pgm.Element
+    import com.tinkerpop.blueprints.pgm.Graph
+
+    include Graph
+
+    def initialize
+      clear
+    end
+
+    def element_class
+      RubyElement
+    end
+
+    def vertex_class
+      RubyVertex
+    end
+
+    def edge_class
+      RubyEdge
+    end
+
+    def addVertex(id)
+      if id
+        v_id = id
+      else
+        v_id = next_id
+      end
+      raise Pacer::ElementExists if @vertices.key? v_id
+      @vertices[v_id] = vertex_class.new self, v_id
+    end
+
+    def getVertex(id)
+      @vertices[id]
+    end
+
+    def removeVertex(vertex)
+      @vertices.delete vertex.element_id
+    end
+
+    def getVertices
+      Pacer::Pipes::EnumerablePipe.new @vertices.values
+    end
+
+    def addEdge(id, outVertex, inVertex, label)
+      id ||= next_id
+      raise Pacer::ElementExists if @edges.key? id
+      @edges[id] = edge_class.new self, id, outVertex, inVertex, label
+    end
+
+    def getEdge(id)
+      @edges[id]
+    end
+
+    def removeEdge(edge)
+      @edges.delete edge.element_id
+    end
+
+    def getEdges
+      Pacer::Pipes::EnumerablePipe.new @edges.values
+    end
+
+    def clear
+      @vertices = {}
+      @edges = {}
+      @next_id = 0
+    end
+
+    def shutdown
+      clear
+    end
+
+    def ==(other)
+      other.equal? self
+    end
+
+    def supports_custom_element_ids?
+      true
+    end
+
+    def supports_automatic_indices?
+      false
+    end
+
+    def supports_manual_indices?
+      false
+    end
+
+    def supports_edge_indices?
+      false
+    end
+    
+    include GraphExtensions
+
+    protected
+
+    def next_id
+      @next_id += 1
+    end
+  end
+
+  class RubyElement
+    include com.tinkerpop.blueprints.pgm.Element
+
+    def initialize(graph, element_id)
+      @graph = graph
+      @element_id = element_id
+      @properties = {}
+    end
+
+    def getPropertyKeys
+      @properties.keys.to_hashset
+    end
+
+    def getProperty(key)
+      v = @properties[key.to_s]
+      if v.is_a? String
+        v.dup
+      else
+        v
+      end
+    end
+
+    def setProperty(key, value)
+      @properties[key.to_s] = value
+    end
+
+    def removeProperty(key)
+      @properties.delete key.to_s
+    end
+
+    def getId
+      @element_id
+    end
+
+    protected
+
+    def extract_varargs_strings(labels)
+      if labels.first.is_a? ArrayJavaProxy
+        labels.first.map { |l| l.to_s }
+      else
+        labels
+      end
+    end
+  end
+
+
+  class RubyVertex < RubyElement
+    include com.tinkerpop.blueprints.pgm.Vertex
+
+    def getRawVertex
+      self
+    end
+
+    def getInEdges(*labels)
+      labels = extract_varargs_strings(labels)
+      edges = graph.getEdges.select { |e| e.getInVertex == self and (labels.empty? or labels.include? e.getLabel) }
+      Pacer::Pipes::EnumerablePipe.new edges
+    end
+
+    def getOutEdges(*labels)
+      labels = extract_varargs_strings(labels)
+      edges = graph.getEdges.select { |e| e.getOutVertex == self and (labels.empty? or labels.include? e.getLabel) }
+      Pacer::Pipes::EnumerablePipe.new edges
+    end
+
+    include VertexExtensions
+  end
+
+  class RubyEdge < RubyElement
+    include com.tinkerpop.blueprints.pgm.Edge
+
+    def initialize(graph, id, out_vertex, in_vertex, label)
+      super(graph, id)
+      @out_vertex = out_vertex
+      @in_vertex = in_vertex
+      @label = label.to_s
+    end
+
+    def getRawEdge
+      self
+    end
+
+    def getLabel()
+      @label
+    end
+
+    def getOutVertex()
+      @out_vertex
+    end
+
+    def getInVertex()
+      @in_vertex
+    end
+
+    include EdgeExtensions
+  end
+end

data/lib/pacer/blueprints/tg.rb

@@ -0,0 +1,100 @@
+module Pacer
+  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerGraph
+  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerVertex
+  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerEdge
+  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerElement
+  import com.tinkerpop.blueprints.pgm.impls.tg.TinkerIndex
+
+  # Create a new TinkerGraph. If path is given, import the GraphML data from
+  # the file specified.
+  def self.tg(path = nil)
+    graph = TinkerGraph.new
+    if path
+      graph.import(path)
+    end
+    graph
+  end
+
+
+  # Extend the java class imported from blueprints.
+  class TinkerGraph
+    include GraphMixin
+    include GraphIndicesMixin
+    include GraphTransactionsStub
+    include ManagedTransactionsMixin
+    include Pacer::Core::Route
+    include Pacer::Core::Graph::GraphRoute
+    include Pacer::Core::Graph::GraphIndexRoute
+
+    def element_class
+      TinkerElement
+    end
+
+    def vertex_class
+      TinkerVertex
+    end
+
+    def edge_class
+      TinkerEdge
+    end
+
+    # Override to return an enumeration-friendly array of vertices.
+    def get_vertices
+      getVertices.iterator.to_route(:graph => self, :element_type => :vertex)
+    end
+
+    # Override to return an enumeration-friendly array of edges.
+    def get_edges
+      getEdges.iterator.to_route(:graph => self, :element_type => :edge)
+    end
+
+    def ==(other)
+      other.class == self.class and other.object_id == self.object_id
+    end
+  end
+
+
+  class TinkerIndex
+    include IndexMixin
+  end
+
+
+  # Extend the java class imported from blueprints.
+  class TinkerVertex
+    include Pacer::Core::Graph::VerticesRoute
+    include ElementMixin
+    include VertexMixin
+  end
+
+
+  # Extend the java class imported from blueprints.
+  class TinkerEdge
+    include Pacer::Core::Graph::EdgesRoute
+    include ElementMixin
+    include EdgeMixin
+
+    def in_vertex(extensions = nil)
+      v = inVertex
+      v.graph = graph
+      if extensions.is_a? Enumerable
+        v.add_extensions extensions
+      elsif extensions
+        v.add_extensions [extensions]
+      else
+        v
+      end
+    end
+
+    def out_vertex(extensions = nil)
+      v = outVertex
+      v.graph = graph
+      if extensions.is_a? Enumerable
+        v.add_extensions extensions
+      elsif extensions
+        v.add_extensions [extensions]
+      else
+        v
+      end
+    end
+  end
+end

data/lib/pacer/blueprints.rb

@@ -0,0 +1,4 @@
+require 'pacer/blueprints/extensions'
+require 'pacer/blueprints/tg'
+require 'pacer/blueprints/ruby_graph'
+require 'pacer/blueprints/multi_graph'

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

@@ -0,0 +1,92 @@
+module Pacer::Core::Graph
+
+  # Basic methods for routes that contain only edges.
+  module EdgesRoute
+    import com.tinkerpop.pipes.transform.OutVertexPipe
+    import com.tinkerpop.pipes.transform.InVertexPipe
+    import com.tinkerpop.pipes.transform.BothVerticesPipe
+
+    include ElementRoute
+
+    # Extends the route with out vertices from this route's matching edges.
+    #
+    # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
+    # @yield [VertexMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @return [VerticesRoute]
+    def out_v(*filters, &block)
+      Pacer::Route.property_filter(chain_route(:element_type => :vertex,
+                                               :pipe_class => OutVertexPipe,
+                                               :route_name => 'outV'),
+                                  filters, block)
+    end
+
+    # Extends the route with in vertices from this route's matching edges.
+    #
+    # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
+    # @yield [VertexMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @return [VerticesRoute]
+    def in_v(*filters, &block)
+      Pacer::Route.property_filter(chain_route(:element_type => :vertex,
+                                               :pipe_class => InVertexPipe,
+                                               :route_name => 'inV'),
+                                  filters, block)
+    end
+
+    # Extends the route with both in and oud vertices from this route's matching edges.
+    #
+    # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
+    # @yield [VertexMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @return [VerticesRoute]
+    def both_v(*filters, &block)
+      Pacer::Route.property_filter(chain_route(:element_type => :vertex,
+                                               :pipe_class => BothVerticesPipe,
+                                               :route_name => 'bothV'),
+                                  filters, block)
+    end
+
+    # Extend route with the additional edge label, property and block filters.
+    #
+    # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
+    # @yield [EdgeMixin(Extensions::BlockFilterElement)] filter proc, see {Pacer::Route#property_filter}
+    # @return [EdgesRoute]
+    def e(*filters, &block)
+      filter(*filters, &block)
+    end
+
+    # Return an route to all edge labels for edges emitted from this
+    # route.
+    #
+    # @return [Core::Route]
+    def labels
+      chain_route(:pipe_class => com.tinkerpop.pipes.transform.LabelPipe,
+                  :route_name => 'labels',
+                  :element_type => :object)
+    end
+
+    # Returns a hash of in vertices with an array of associated out vertices.
+    #
+    # See #subgraph for a more useful method.
+    #
+    # @return [Hash]
+    def to_h
+      inject(Hash.new { |h,k| h[k]=[] }) do |h, edge|
+        h[edge.out_vertex] << edge.in_vertex
+        h
+      end
+    end
+
+    # The element type of this route for this graph implementation.
+    #
+    # @return [element_type(:edge)] The actual type varies based on
+    # which graph is in use.
+    def element_type
+      graph.element_type(:edge)
+    end
+
+    protected
+
+    def id_pipe_class
+      com.tinkerpop.pipes.transform.IdEdgePipe
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+module Pacer::Core::Graph
+
+  # Basic methods for routes shared between all route types that emit
+  # routes: {VerticesRoute}, {EdgesRoute} and {MixedRoute}
+  module ElementRoute
+
+    # Attach a filter to the current route.
+    #
+    # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
+    # @yield [ElementMixin(Extensions::BlockFilterElement)] 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)
+    end
+
+    # v is undefined for edge routes.
+    # @see VerticesRoute
+    # @see GraphRoute
+    def v(*filters)
+      raise Pacer::UnsupportedOperation, "Can't get vertices for this route type."
+    end
+
+    # Undefined for vertex routes.
+    # @see EdgesRoute
+    # @see GraphRoute
+    def e(*filters, &block)
+      raise Pacer::UnsupportedOperation, "Can't get edges for this route type."
+    end
+
+    # Attach a transform that emits the properties of the elements
+    # rather than the elements themselves.
+    # @return [Core::Route]
+    def properties
+      map { |v| v.properties }
+    end
+
+    # Create a new TinkerGraph based on the paths of all matching elements.
+    #
+    # @return [TinkerGraph] the subgraph
+    def subgraph
+      paths.subgraph
+    end
+
+    # Delete all matching elements.
+    def delete!
+      uniq.bulk_job { |e| e.delete! }
+    end
+
+    # Stores the result of the current route in a new route so it will not need
+    # to be recalculated.
+    # @return [ElementRoute] with the same type and extensions as the
+    #   source route
+    def result(name = nil)
+      element_ids.to_a.id_to_element_route(:based_on => self, :name => name)
+    end
+
+    # Accepts a string or symbol to return an array of matching properties, or
+    # an integer to return the element at the given offset, or a range to
+    # return all elements between the offsets within the range.
+    # @overload [](prop)
+    #   @param [String, Symbol] prop map each element to a single property
+    #   @return [Core::Route]
+    # @overload [](properties)
+    #   @param [Array<String, Symbol>] properties map each element to a set of properties
+    #   @return [Core::Route]
+    # @overload [](offset)
+    #   @param [Fixnum] offset narrow the result to a single element at the given position in the results
+    #   @return [ElementRoute] with the same type and extensions as the source route
+    # @overload [](range)
+    #   @param [Range] range narrow the result to a subset of elements in positions corresponding to the range
+    #   @return [ElementRoute] with the same type and extensions as the source route
+    def [](prop_or_subset)
+      case prop_or_subset
+      when String, Symbol
+        chain_route(:element_type => :object,
+                    :pipe_class => Pacer::Pipes::PropertyPipe,
+                    :pipe_args => [prop_or_subset.to_s])
+      when Fixnum
+        range(prop_or_subset, prop_or_subset)
+      when Range
+        range(prop_or_subset.begin, prop_or_subset.end)
+      when Array
+        if prop_or_subset.all? { |i| i.is_a? String or i.is_a? Symbol }
+          map do |element|
+            prop_or_subset.collect { |i| element.getProperty(i.to_s) }
+          end
+        end
+      end
+    end
+
+    # Map each element to a property but filter out elements that do not
+    # have the given property.
+    # @param [#to_s] name the property name
+    # @return [Core::Route]
+    def property?(name)
+      chain_route(:element_type => :object,
+                  :pipe_class => Pacer::Pipes::PropertyPipe,
+                  :pipe_args => [name.to_s, true])
+    end
+
+    # Attach a route to the element id for each element emitted by the
+    # route.
+    #
+    # @return [Core::Route]
+    def element_ids
+      chain_route :element_type => :object, :pipe_class => Pacer::Pipes::IdPipe
+    end
+
+    def clone_into(target_graph, opts = {})
+      bulk_job(nil, target_graph) do |element|
+        element.clone_into(target_graph, opts)
+      end
+    end
+
+    def copy_into(target_graph, opts = {})
+      bulk_job(nil, target_graph) { |element| element.copy_into(target_graph, opts) }
+    end
+
+    def build_index(index, index_key = nil, property = nil, create = true)
+      index_name = index
+      unless index.is_a? com.tinkerpop.blueprints.pgm.Index
+        index = graph.index_name index.to_s
+      end
+      sample_element = first
+      unless index
+        if sample_element
+          if create
+            index = graph.createManualIndex index_name, graph.element_type(sample_element)
+          else
+            raise "No index found for #{ index } on #{ graph }" unless index
+          end
+        else
+          return nil
+        end
+      end
+      index_key ||= index.index_name
+      property ||= index_key
+      if block_given?
+        bulk_job do |element|
+          value = yield(element)
+          index.put(index_key, value, element.element) if value
+        end
+      else
+        bulk_job do |element|
+          value = element[property]
+          index.put(index_key, value, element.element) if value
+        end
+      end
+      index
+    end
+
+    protected
+
+    # Determines which iterator mixin is applied to the iterator when #each is called
+    def configure_iterator(iter)
+      if wrapper
+        iter.extend Pacer::Core::Route::IteratorWrapperMixin
+        iter.wrapper = wrapper
+        iter.extensions = @extensions if @extensions.any?
+        iter.graph = graph
+      elsif extensions and extensions.any?
+        iter.extend Pacer::Core::Route::IteratorExtensionsMixin
+        iter.extensions = extensions 
+        iter.graph = graph
+      else
+        iter.extend Pacer::Core::Route::IteratorMixin
+        iter.graph = graph
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Pacer::Core::Graph
+
+  # This module adds indexed route methods to the basic graph classes returned from the
+  # blueprints library.
+  module GraphIndexRoute
+    # Returns a new route to all graph vertices. Standard filter options.
+    def v(*filters, &block)
+      filters = Pacer::Route.filters(filters)
+      route = indexed_route(:vertex, filters, block)
+      if route
+        route
+      else
+        super(filters, &block)
+      end
+    end
+
+    # Returns a new route to all graph edges. Standard filter options.
+    def e(*filters, &block)
+      filters = Pacer::Route.edge_filters(filters)
+      route = indexed_route(:edge, filters, block)
+      if route
+        route
+      else
+        super(filters, &block)
+      end
+    end
+
+    attr_accessor :choose_best_index
+    attr_accessor :search_manual_indices
+
+    protected
+
+    def indexed_route(element_type, filters, block)
+      filters.graph = self
+      filters.indices = graph.getIndices
+      filters.choose_best_index = choose_best_index != false
+      filters.search_manual_indices = search_manual_indices
+      idx, key, value = filters.best_index(element_type)
+      if idx and key
+        route = chain_route :back => self, :element_type => element_type, :filter => :index, :index => idx, :key => key, :value => value
+        Pacer::Route.property_filter(route, filters, block)
+      elsif filters.route_modules.any?
+        mod = filters.route_modules.shift
+        Pacer::Route.property_filter(mod.route(self), filters, block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Pacer::Core::Graph
+
+  # This module adds route methods to the basic graph classes returned from the
+  # blueprints library.
+  module GraphRoute
+    import com.tinkerpop.pipes.transform.VerticesPipe
+    import com.tinkerpop.pipes.transform.EdgesPipe
+
+    # Returns a new route to all graph vertices. Standard filter options.
+    def v(*filters, &block)
+      filters = Pacer::Route.filters(filters)
+      route = chain_route :element_type => :vertex,
+        :pipe_class => VerticesPipe,
+        :route_name => 'GraphV'
+      Pacer::Route.property_filter(route, filters, block)
+    end
+
+    # Returns a new route to all graph edges. Standard filter options.
+    def e(*filters, &block)
+      filters = Pacer::Route.edge_filters(filters)
+      route = chain_route :element_type => :edge,
+        :pipe_class => EdgesPipe,
+        :route_name => 'GraphE'
+      Pacer::Route.property_filter(route, filters, block)
+    end
+
+    def filter(*args)
+      raise 'Not implemented'
+    end
+
+    # Specialization of result simply returns self.
+    def result
+      self
+    end
+
+    # The graph itself is as root as you can get.
+    def root?
+      true
+    end
+
+    def graph
+      # This must be defined here to overwrite the #graph method in Route.
+      self
+    end
+
+    def ==(other)
+      equal?(other)
+    end
+
+    # Don't try to inspect the graph data when inspecting.
+    def hide_elements
+      true
+    end
+  end
+end