pacer 0.9.1.1-java

data/lib/pacer/graph/edge_mixin.rb

@@ -0,0 +1,127 @@
+module Pacer
+  # This module is mixed into the raw Blueprints Edge class from any
+  # graph implementation.
+  #
+  # Adds more convenient/rubyish methods and adds support for extensions
+  # to some methods where needed.
+  module EdgeMixin
+    # Add extensions to this edge.
+    #
+    # If any extension has a Edge module within it, this edge will
+    # be extended with the extension's Edge module.
+    #
+    # @see Core::Route#add_extension
+    #
+    # @param [[extensions]] exts the extensions to add
+    # @return [Pacer::Wrappers::EdgeWrapper] this edge wrapped up and including
+    #   the extensions
+    def add_extensions(exts)
+      if exts.any?
+        Wrappers::EdgeWrapper.wrap(self, exts)
+      else
+        self
+      end
+    end
+
+    # The incoming vertex for this edge.
+    # @return [Pacer::VertexMixin]
+    def in_vertex(extensions = nil)
+      v = getInVertex
+      v.graph = graph
+      if extensions
+        v.add_extensions extensions
+      else
+        v
+      end
+    end
+
+    def label
+      getLabel
+    end
+
+    # The outgoing vertex for this edge.
+    # @return [Pacer::VertexMixin]
+    def out_vertex(extensions = nil)
+      v = getOutVertex
+      v.graph = graph
+      if extensions
+        v.add_extensions extensions
+      else
+        v
+      end
+    end
+
+    # Returns a human-readable representation of the edge using the
+    # standard ruby console representation of an instantiated object.
+    # @return [String]
+    def inspect
+      "#<E[#{element_id}]:#{display_name}>"
+    end
+
+    # Returns the display name of the edge.
+    # @return [String]
+    def display_name
+      if graph and graph.edge_name
+        graph.edge_name.call self
+      else
+        "#{ out_vertex.element_id }-#{ getLabel }-#{ in_vertex.element_id }"
+      end
+    end
+
+    # Deletes the edge from its graph.
+    def delete!
+      graph.removeEdge element
+    end
+
+    # Clones this edge into the target graph.
+    #
+    # This differs from the {#copy_into} in that it tries to set
+    # the new element_id the same as the original element_id.
+    #
+    # @param [Pacer::GraphMixin] target_graph
+    # @param [Hash] opts
+    # @option opts :create_vertices [true] Create the vertices
+    #   associated to this edge if they don't already exist.
+    # @yield [e] Optional block yields the edge after it has been created.
+    # @return [Pacer::EdgeMixin] the new edge
+    #
+    # @raise [StandardError] If this the associated vertices don't exist and :create_vertices is not set
+    def clone_into(target_graph, opts = {})
+      e_idx = target_graph.index_name("tmp:e:#{graph.to_s}", :edge, :create => true)
+      e = target_graph.edge(element_id) || e_idx.get('id', element_id).first
+      unless e
+        v_idx = target_graph.index_name("tmp:v:#{graph.to_s}", :vertex, :create => true)
+        iv = target_graph.vertex(in_vertex.element_id) || v_idx.get('id', in_vertex.element_id).first
+        ov = target_graph.vertex(out_vertex.element_id) || v_idx.get('id', out_vertex.element_id).first
+        if opts[:create_vertices]
+          iv ||= in_vertex.clone_into target_graph
+          ov ||= out_vertex.clone_into target_graph
+        end
+        raise 'vertices not found' if not iv or not ov
+        e = target_graph.create_edge(element_id, iv, ov, label, properties)
+        e_idx.put('id', element_id, e)
+        yield e if block_given?
+      end
+      e
+    end
+
+    # Copies this edge into the target graph with the next available
+    # edge id.
+    #
+    # @param [Pacer::GraphMixin] target_graph
+    # @yield [e] Optional block yields the edge after it has been created.
+    # @return [Pacer::EdgeMixin] the new edge
+    #
+    # @raise [StandardError] If this the associated vertices don't exist
+    def copy_into(target_graph)
+      v_idx = target_graph.index_name("tmp:v:#{graph.to_s}", :vertex, :create => true)
+      iv = v_idx.get('id', in_vertex.element_id).first || target_graph.vertex(in_vertex.element_id)
+      ov = v_idx.get('id', out_vertex.element_id).first || target_graph.vertex(out_vertex.element_id)
+
+      raise 'vertices not found' if not iv or not ov
+      e = target_graph.create_edge nil, iv, ov, label, properties
+      yield e if block_given?
+      e
+    end
+  end
+end

data/lib/pacer/graph/element_mixin.rb

@@ -0,0 +1,202 @@
+module Pacer
+  # This module is mixed into the raw Blueprints Edge and Vertex classes
+  # from any graph implementation.
+  #
+  # Adds more convenient/rubyish methods and adds support for extensions
+  # to some methods where needed.
+  module ElementMixin
+    class << self
+      protected
+      def included(target)
+        target.send :include, Enumerable unless target.is_a? Enumerable
+      end
+    end
+
+    # Which extensions does this element have?
+    # @return [Set[extensions]]
+    def extensions
+      Set[]
+    end
+
+    # See {Core::Graph::VerticesRoute#v}
+    # @return [Route]
+    def v(*args)
+      route = super
+      if args.empty? and not block_given?
+        route.add_extensions extensions
+      end
+      route
+    end
+
+    # See {Core::Graph::EdgesRoute#e}
+    # @return [Route]
+    def e(*args)
+      route = super
+      if args.empty? and not block_given?
+        route.add_extensions extensions
+      end
+      route
+    end
+
+    # For internal use only.
+    #
+    # Specify the graph the element belongs to.
+    def graph=(graph)
+      @graph = graph
+    end
+
+    # The graph the element belongs to.
+    #
+    # Used to help prevent objects from different graphs from being
+    # accidentally associated, as well as to get graph-specific data for
+    # the element.
+    #
+    # @return [GraphMixin]
+    def graph
+      @graph
+    end
+
+    # Convenience method to retrieve a property by name.
+    #
+    # @param [#to_s] key the property name
+    # @return [Object]
+    def [](key)
+      if key.is_a? Array
+        key.map { |k| self[k] }
+      else
+        value = element.getProperty(key.to_s)
+        if graph
+          graph.decode_property(value)
+        else
+          value
+        end
+      end
+    end
+
+    # Convenience method to set a property by name to the given value.
+    # @param [#to_s] key the property name
+    # @param [Object] value the value to set the property to
+    def []=(key, value)
+      value = graph.encode_property(value) if graph
+      key = key.to_s
+      if value
+        if value != element.getProperty(key)
+          element.setProperty(key, value)
+        end
+      else
+        element.removeProperty(key) if element.getPropertyKeys.include? key
+      end
+    end
+
+    # Specialize result to return self for elements.
+    # @return [ElementMixin] self
+    def result(name = nil)
+      self
+    end
+
+    # Query whether the current node belongs to the given graph.
+    #
+    # @param [Object] g the object to compare to {#graph}
+    def from_graph?(g)
+      g.equal? graph
+    end
+
+    # Returns a hash of property values by name.
+    #
+    # @return [Hash]
+    def properties
+      element.getPropertyKeys.inject({}) { |h, name| h[name] = element.getProperty(name); h }
+    end
+
+    # Replace the element's properties with the given hash
+    #
+    # @param [Hash] props the element's new properties
+    def properties=(props)
+      (element.getPropertyKeys - props.keys.collect { |k| k.to_s }).each do |key|
+        element.removeProperty key
+      end
+      props.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def property_keys
+      getPropertyKeys
+    end
+
+    # The id of the current element
+    # @return [Object] element id (type varies by graph implementation.
+    def element_id
+      element.getId
+    end
+
+    # Sort objects semi arbitrarily based on {VertexMixin#display_name}
+    # or {EdgeMixin#display_name}.
+    # @param other
+    #
+    # @return [Fixnum]
+    def <=>(other)
+      display_name.to_s <=> other.display_name.to_s
+    end
+
+    # Test equality to another object.
+    #
+    # Elements are equal if they are the same type and have the same id
+    # and the same graph, regardless of extensions.
+    #
+    # If the graphdb instantiates multiple copies of the same element
+    # this method will return true when comparing them.
+    #
+    # @see #eql?
+    # @param other
+    def ==(other)
+      if other.respond_to?(:element) and other.element.class == element.class and other.element_id == element_id
+        if graph and other.graph
+          other.graph == graph
+        else
+          true
+        end
+      end
+    end
+
+    # Test object equality of the element instance.
+    #
+    # Wrappers/extensions (if any) are ignored, the underlying element
+    # only is compared
+    #
+    # If the graphdb instantiates multiple copies of the same element
+    # this method will return false when comparing them.
+    #
+    # @see #==
+    # @param other
+    def eql?(other)
+      if other.respond_to? :element
+        super(other.element)
+      else
+        super
+      end
+    end
+
+    # Yields the element once or returns an enumerator if no block is
+    # given. Follows Ruby conventions and is meant to be used along
+    # with the Enumerable mixin.
+    #
+    # @yield [ElementMixin] this element
+    # @return [Enumerator] only if no block is given
+    def each
+      if block_given?
+        yield self
+      else
+        [self].to_enum
+      end
+    end
+
+    # Returns the underlying element. For unwrapped elements, returns
+    # self.
+    # @return [ElementMixin]
+    def element
+      self
+    end
+    alias no_extensions element
+  end
+end

data/lib/pacer/graph/graph_indices_mixin.rb

@@ -0,0 +1,93 @@
+module Pacer
+  module GraphIndicesMixin
+    # 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(name, type = nil, opts = {})
+      name = name.to_s
+      if type
+        idx = getIndices.detect { |i| i.index_name == name and i.index_class == index_class(type) }
+        if idx.nil? and opts[:create]
+          idx = createManualIndex name, element_type(type)
+        end
+      else
+        idx = getIndices.detect { |i| i.index_name == name }
+      end
+      idx.graph = self if idx
+      idx
+    end
+
+    # Drops and recreates an automatic index with the same keys.
+    #
+    # In some earlier graphdb versions it was possible to corrupt
+    # automatic indices. This method provided a fast way to recreate
+    # them.
+    #
+    # @param [Index] old_index this index will be dropped
+    # @return [Index] rebuilt index
+    def rebuild_automatic_index(old_index)
+      name = old_index.getIndexName
+      index_class = old_index.getIndexClass
+      keys = old_index.getAutoIndexKeys
+      drop_index name
+      build_automatic_index(name, index_class, keys)
+    end
+
+    # Creates a new automatic index.
+    #
+    # @param [#to_s] name index name
+    # @param [:vertex, :edge, element type] et element type
+    # @param [[#to_s], nil] keys The keys to be indexed. If nil then
+    #   index all keys
+    def build_automatic_index(name, et, keys = nil)
+      if keys and not keys.is_a? java.util.Set
+        set = java.util.HashSet.new
+        keys.each { |k| set.add k.to_s }
+        keys = set
+      end
+      index = createAutomaticIndex name.to_s, index_class(et), keys
+      index.graph = self
+      if index_class(et) == element_type(:vertex).java_class
+        v.bulk_job do |v|
+          Pacer::Utils::AutomaticIndexHelper.addElement(index, v)
+        end
+      else
+        e.bulk_job do |e|
+          Pacer::Utils::AutomaticIndexHelper.addElement(index, e)
+        end
+      end
+      index
+    end
+
+    # Return an object that can be compared to the return value of
+    # Index#index_class.
+    def index_class(et)
+      element_type(et).java_class.to_java
+    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?
+      true
+    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?
+      true
+    end
+
+    # Does this graph support indices on edges?
+    #
+    # Specific graphs may override this method to return false.
+    def supports_edge_indices?
+      true
+    end
+  end
+end