pacer 0.9.1.1-java

data/lib/pacer/graph/graph_mixin.rb

@@ -0,0 +1,361 @@
+module Pacer
+  # Methods to be mixed into Blueprints Graph objects from any
+  # implementation.
+  #
+  # Adds more convenient/rubyish methods and adds support for extensions
+  # to some methods where needed.
+  module GraphMixin
+    def self.included(target)
+      target.class_eval do
+        protected :addVertex, :addEdge
+        protected :add_vertex, :add_edge rescue nil
+        protected :getVertex, :getEdge
+        protected :get_vertex, :get_edge rescue nil
+      end
+    end
+
+    attr_accessor :in_bulk_job
+
+    def graph_id
+      @graph_id = Pacer.next_graph_id unless defined? @graph_id
+      @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)
+      v = getVertex(id) rescue nil
+      if v
+        wrapper = modules.detect { |obj| obj.ancestors.include? Pacer::Wrappers::VertexWrapper }
+        if wrapper
+          v = wrapper.new v
+          modules.delete wrapper
+        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)
+      v = getEdge(id) rescue nil
+      if v
+        wrapper = modules.detect { |obj| obj.ancestors.include? Pacer::Wrappers::EdgeWrapper }
+        if wrapper
+          v = wrapper.new v
+          modules.delete wrapper
+        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)
+      vertex = creating_elements { addVertex(id) }
+      vertex = wrapper.new vertex if wrapper
+      vertex.graph = self
+      props.each { |k, v| vertex[k.to_s] = v } if props
+      if modules.any?
+        vertex.add_extensions modules
+      else
+        vertex
+      end
+    end
+
+    # Create an edge in the graph.
+    #
+    # @param [element id] id some graphs allow you to specify your own edge id.
+    # @param [Pacer::VertexMixin] from_v the new edge's out_vertex
+    # @param [Pacer::VertexMixin] 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)
+      edge = creating_elements { addEdge(id, from_v.element, to_v.element, label) }
+      edge = wrapper.new edge if wrapper
+      edge.graph = self
+      props.each { |k, v| edge[k.to_s] = v } if props
+      if modules.any?
+        edge.add_extensions modules
+      else
+        edge
+      end
+    end
+
+    # Import the data in a GraphML file.
+    #
+    # Will fail if the data already exsts in the current graph.
+    #
+    # @param [String] path
+    def import(path)
+      path = File.expand_path path
+      begin
+        stream = java.net.URL.new(path).open_stream
+      rescue java.net.MalformedURLException
+        stream = java.io.FileInputStream.new path
+      end
+      creating_elements do
+        com.tinkerpop.blueprints.pgm.util.graphml.GraphMLReader.input_graph self, stream
+      end
+      true
+    ensure
+      stream.close if stream
+    end
+
+    # Export the graph to GraphML
+    #
+    # @param [String] path will be replaced if it exists
+    def export(path)
+      path = File.expand_path path
+      stream = java.io.FileOutputStream.new path
+      com.tinkerpop.blueprints.pgm.util.graphml.GraphMLWriter.outputGraph self, stream
+    ensure
+      stream.close if stream
+    end
+
+    # 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
+
+    # Directly loads an array of vertices by id.
+    #
+    # @param [[vertex ids]] ids
+    # @return [[Pacer::VertexMixin]]
+    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::EdgeMixin]]
+    def load_edges(ids)
+      ids.map do |id|
+        edge id
+      end.compact
+    end
+
+    # The current graph
+    #
+    # @return [Graph] returns self
+    def graph
+      self
+    end
+
+    def equals(other)
+      self == other
+    end
+
+    # 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
+
+    # 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)
+      if [element_type(:vertex), element_type(:edge), element_type(:mixed)].include?  element_type(et)
+        true
+      else
+        false
+      end
+    end
+
+    # Does this graph support edges where the in_vertex and the
+    # out_vertex are the same?
+    #
+    # Specific graphs may override this method to return false.
+    def supports_circular_edges?
+      true
+    end
+
+    # When creating an element, does this graph allow me to specify the
+    # element_id?
+    #
+    # Specific graphs may override this method to return false.
+    def supports_custom_element_ids?
+      true
+    end
+
+    # Does this graph allow me to create or modify automatic indices?
+    #
+    # Specific graphs may override this method to return false.
+    def supports_automatic_indices?
+      false
+    end
+
+    # Does this graph allow me to create or modify manual indices?
+    #
+    # Specific graphs may override this method to return false.
+    def supports_manual_indices?
+      false
+    end
+
+    # Does this graph support indices on edges?
+    #
+    # Specific graphs may override this method to return false.
+    def supports_edge_indices?
+      false
+    end
+
+    def element_type(et = nil)
+      return nil unless et
+      result = if et == vertex_class or et == edge_class or et == element_class
+        et
+      else
+        case et
+        when :vertex, Pacer::Vertex, VertexMixin
+          vertex_class
+        when :edge, Pacer::Edge, EdgeMixin
+          edge_class
+        when :mixed, Pacer::Element, ElementMixin
+          element_class
+        when :object
+          Object
+        else
+          if et == Object
+            Object
+          elsif vertex_class.respond_to? :java_class
+            if et == vertex_class.java_class.to_java
+              vertex_class
+            elsif et == edge_class.java_class.to_java
+              edge_class
+            elsif et == Pacer::Vertex.java_class.to_java
+              vertex_class
+            elsif et == Pacer::Edge.java_class.to_java
+              edge_class
+            end
+          end
+        end
+      end
+      if result
+        result
+      else
+        raise ArgumentError, 'Element type may be one of :vertex, :edge, :mixed or :object' 
+      end
+    end
+
+    def sanitize_properties(props)
+      props
+    end
+
+    def encode_property(value)
+      if value.is_a? String
+        value = value.strip
+        value unless value == ''
+      else
+        value
+      end
+    end
+
+    def decode_property(value)
+      value
+    end
+
+    def edges
+      getEdges
+    end
+
+    protected
+
+    # 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 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 }
+      modules.delete wrapper
+      id = args.first
+      id = nil if id == props or modules.include? id or id == wrapper
+      [id, wrapper, modules, props]
+    end
+  end
+end

data/lib/pacer/graph/graph_transactions_mixin.rb

@@ -0,0 +1,207 @@
+module Pacer
+  import com.tinkerpop.blueprints.pgm.TransactionalGraph
+
+  # Collect a global set of graphs that are currently in a transaction.
+  #
+  # @return [Set] graphs with an open transaction
+  def self.graphs_in_transaction
+    @graphs = Set[] unless defined? @graphs
+    @graphs
+  end
+
+  # Methods used internally to do 'managed transactions' which I define
+  # as transactions that are started and committed automatically
+  # internally, typically on operations that potentially touch a large
+  # number of elements.
+  #
+  # The reason for keeping track of these separately is to prevent them
+  # from being confused with manual transactions. Although when this was
+  # written, I had made manual transactions nestable. That has been
+  # since explicitly disallowed by Blueprints. I am not sure if this
+  # code is actually needed anymore (if it was refactored out).
+  #
+  # TODO: the method names in this module need to be cleaned up.
+  # TODO: some methods may be able to be eliminated.
+  module ManagedTransactionsMixin
+    def manage_transactions=(v)
+      @manage_transactions = v
+    end
+
+    def manage_transactions?
+      @manage_transactions = true unless defined? @manage_transactions
+      @manage_transactions
+    end
+    alias manage_transactions manage_transactions?
+
+    def unmanaged_transactions
+      old_value = manage_transactions
+      @manage_transactions = false
+      yield
+    ensure
+      @manage_transactions = old_value
+    end
+
+    def managed_transactions
+      if manage_transactions?
+        manual_transactions { yield }
+      else
+        yield
+      end
+    end
+
+    def managed_manual_transaction
+      if manage_transactions?
+        manual_transaction { yield }
+      else
+        yield
+      end
+    end
+
+    def managed_transaction
+      if manage_transactions?
+        transaction { yield }
+      else
+        yield
+      end
+    end
+
+    def managed_start_transaction
+      begin_transaction if manage_transactions?
+    end
+
+    def managed_commit_transaction
+      commit_transaction if manage_transactions?
+    end
+
+    def managed_checkpoint
+      checkpoint if manage_transactions?
+    end
+  end
+
+  # This is included into graphs that don't support transactions so that
+  # their interface is the same as for graphs that do support them.
+  #
+  # All methods in this module do nothing but yield or return values
+  # that match those in {GraphTransactionsMixin}
+  module GraphTransactionsStub
+    def in_transaction?
+      false
+    end
+
+    def manual_transaction
+      yield
+    end
+
+    def manual_transactions
+      yield
+    end
+
+    def transaction
+      yield
+    end
+
+    def begin_transaction
+    end
+
+    def commit_transaction
+    end
+
+    def rollback_transaction
+    end
+
+    def checkpoint
+    end
+  end
+
+  # Add features to transactions to allow them to be more rubyish and
+  # more convenient to use.
+  #
+  # TODO: the method names in this module need to be cleaned up.
+  # TODO: some methods may be able to be eliminated.
+  module GraphTransactionsMixin
+    def self.included(target)
+      target.send :protected, :startTransaction, :start_transaction
+    end
+
+    def in_transaction?
+      Pacer.graphs_in_transaction.include? self
+    end
+
+    def manual_transaction
+      manual_transactions do
+        transaction do
+          yield
+        end
+      end
+    end
+
+    def manual_transactions
+      original_buffer_size = getMaxBufferSize
+      if original_buffer_size != 0
+        begin
+          puts "transaction buffer size reset to 0 (MANUAL)" if Pacer.verbose == :very
+          setMaxBufferSize 0
+          yield
+        rescue Exception
+          rollback_transaction if in_transaction?
+          raise
+        ensure
+          puts "transaction buffer size reset to #{ original_buffer_size }" if Pacer.verbose == :very
+          setMaxBufferSize original_buffer_size
+        end
+      else
+        yield
+      end
+    end
+
+    def transaction
+      begin_transaction
+      conclusion = TransactionalGraph::Conclusion::FAILURE
+      begin
+        catch :transaction_failed do
+          yield
+          conclusion = TransactionalGraph::Conclusion::SUCCESS
+        end
+      rescue Exception
+        puts "transaction aborted" if Pacer.verbose == :very
+        raise
+      ensure
+        puts "transaction finished #{ conclusion }" if Pacer.verbose == :very
+        stop_transaction conclusion
+        Pacer.graphs_in_transaction.delete self
+      end
+    end
+
+    def begin_transaction
+      r = startTransaction
+      Pacer.graphs_in_transaction << self
+      puts "transaction started" if Pacer.verbose == :very
+      r
+    end
+
+    def commit_transaction
+      r = stop_transaction TransactionalGraph::Conclusion::SUCCESS
+      Pacer.graphs_in_transaction.delete self
+      puts "transaction committed" if Pacer.verbose == :very
+      r
+    end
+
+    def rollback_transaction
+      r = stop_transaction TransactionalGraph::Conclusion::FAILURE
+      Pacer.graphs_in_transaction.delete self
+      puts "transaction rolled back" if Pacer.verbose == :very
+      r
+    end
+
+    def checkpoint(success = true)
+      if success
+        commit_transaction
+      else
+        rollback_transaction
+      end
+      begin_transaction
+      Pacer.graphs_in_transaction << self
+    end
+
+  end
+end

data/lib/pacer/graph/index_mixin.rb

@@ -0,0 +1,30 @@
+module Pacer
+  module IndexMixin
+    def graph=(graph)
+      @graph = graph
+    end
+
+    def graph
+      @graph if defined? @graph
+    end
+
+    def first(key, value, extensions = nil)
+      e = get(key, value).first
+      if e and (graph or extensions)
+        e.graph = graph
+        e.add_extensions extensions
+      end
+      e
+    end
+
+    def all(key, value, extensions = nil)
+      iter = get(key, value)
+      if graph or extensions
+        iter.extend Pacer::Core::Route::IteratorExtensionsMixin
+        iter.graph = graph
+        iter.extensions = extensions
+      end
+      iter
+    end
+  end
+end

data/lib/pacer/graph/vertex_mixin.rb

@@ -0,0 +1,119 @@
+module Pacer
+  # This module is mixed into the raw Blueprints Vertex class from any
+  # graph implementation.
+  #
+  # Adds more convenient/rubyish methods and adds support for extensions
+  # to some methods where needed.
+  module VertexMixin
+    # Add extensions to this vertex.
+    #
+    # If any extension has a Vertex module within it, this vertex will
+    # be extended with the extension's Vertex module.
+    #
+    # @see Core::Route#add_extension
+    #
+    # @param [[extensions]] exts the extensions to add
+    # @return [Pacer::EdgeWrapper] this vertex wrapped up and including
+    #   the extensions
+    def add_extensions(exts)
+      if exts.any?
+        Wrappers::VertexWrapper.wrap(self, exts)
+      else
+        self
+      end
+    end
+
+    # Returns a human-readable representation of the vertex using the
+    # standard ruby console representation of an instantiated object.
+    # @return [String]
+    def inspect
+      "#<#{ ["V[#{element_id}]", display_name].compact.join(' ') }>"
+    end
+
+    # Returns the display name of the vertex.
+    # @return [String]
+    def display_name
+      graph.vertex_name.call self if graph and graph.vertex_name
+    end
+
+    # Deletes the vertex from its graph along with all related edges.
+    def delete!
+      graph.removeVertex element
+    end
+
+    # Copies including the vertex id unless a vertex with that id
+    # already exists.
+    # @param [Pacer::GraphMixin] target_graph
+    # @param opts for compatibility with {Pacer::EdgeMixin#clone_into}
+    # @yield [v] Optional block yields the vertex after it has been created.
+    # @return [Pacer::VertexMixin] the new vertex
+    def clone_into(target_graph, opts = nil)
+      v_idx = target_graph.index_name("tmp:v:#{graph.to_s}", :vertex, :create => true)
+      v = target_graph.vertex(element_id) || v_idx.get('id', element_id).first
+      unless v
+        v = target_graph.create_vertex element_id, properties
+        v_idx.put('id', element_id, v)
+        yield v if block_given?
+      end
+      v
+    end
+
+    # Make a new copy of the element with the next available vertex id.
+    #
+    # @param [Pacer::GraphMixin] target_graph
+    # @yield [v] Optional block yields the vertex after it has been created.
+    # @return [Pacer::VertexMixin] the new vertex
+    def copy_into(target_graph)
+      v = target_graph.create_vertex properties
+      yield v if block_given?
+      v
+    end
+
+    def raw_out_edges(*labels)
+      element.getOutEdges *labels
+    end
+
+    def raw_in_edges(*labels)
+      element.getInEdges *labels
+    end
+
+    def out_edges(*labels_and_extensions)
+      labels, exts = split_labels_and_extensions(labels_and_extensions)
+      edge_iterator(raw_out_edges(*labels).iterator, exts)
+    end
+
+    def in_edges(*labels_and_extensions)
+      labels, exts = split_labels_and_extensions(labels_and_extensions)
+      edge_iterator(raw_in_edges(*labels).iterator, exts)
+    end
+
+    def both_edges(*labels_and_extensions)
+      labels, exts = split_labels_and_extensions(labels_and_extensions)
+      ins = raw_in_edges(*labels).iterator
+      outs = raw_out_edges(*labels).iterator
+      edge_iterator(Pacer::Pipes::MultiIterator.new(ins, outs), exts)
+    end
+
+    protected
+
+    def split_labels_and_extensions(mixed)
+      labels = Set[]
+      exts = Set[]
+      mixed.each do |obj|
+        if obj.is_a? Symbol or obj.is_a? String
+          labels << obj
+        else
+          exts << obj
+        end
+      end
+      [labels, exts]
+    end
+
+    def edge_iterator(iter, exts)
+      iter.extend Pacer::Core::Route::IteratorExtensionsMixin
+      iter.graph = self.graph
+      iter.extensions = exts
+      iter
+    end
+  end
+end