pacer 0.9.1.1-java → 1.0.0-java

data/lib/pacer/wrappers/edge_wrapper.rb

@@ -2,19 +2,20 @@ module Pacer::Wrappers
   class EdgeWrapper < ElementWrapper
     include Pacer::Edge
     include Pacer::Core::Graph::EdgesRoute
-    include Pacer::ElementMixin
-    include Pacer::EdgeMixin
 
     def_delegators :@element,
       :getId, :getLabel, :getPropertyKeys, :getProperty, :setProperty, :removeProperty,
-      :getInVertex, :getOutVertex,
-      :getRawEdge, 
-      :graph, :graph=, :<=>, :==
+      :getVertex,
+      :getRawEdge
 
     class << self
       def wrapper_for(exts)
         @wrappers = {} unless defined? @wrappers
-        @wrappers[exts.to_set] ||= build_edge_wrapper(exts)
+        if exts
+          @wrappers[exts.to_set] ||= build_edge_wrapper(exts)
+        else
+          fail Pacer::LogicError, "Extensions should not be nil"
+        end
       end
 
       def clear_cache
@@ -30,22 +31,174 @@ module Pacer::Wrappers
 
     # This method must be defined here rather than in the superclass in order
     # to correctly override the method in an included module
-    def extensions
-      self.class.extensions
+    attr_reader :element
+
+    def label
+      getLabel
+    end
+
+    # The incoming vertex for this edge.
+    # @return [Pacer::Wrappers::VertexWrapper]
+    def in_vertex(extensions = nil)
+      v = element.getVertex Pacer::Pipes::IN
+      if extensions.is_a? Enumerable
+        v = VertexWrapper.wrapper_for(extensions).new v
+      elsif extensions
+        v = VertexWrapper.wrapper_for([extensions]).new v
+      else
+        v = VertexWrapper.new v
+      end
+      v.graph = graph
+      v
+    end
+
+    # The outgoing vertex for this edge.
+    # @return [Pacer::Wrappers::VertexWrapper]
+    def out_vertex(extensions = nil)
+      v = element.getVertex Pacer::Pipes::OUT
+      if extensions.is_a? Enumerable
+        v = VertexWrapper.wrapper_for(extensions).new v
+      elsif extensions
+        v = VertexWrapper.wrapper_for([extensions]).new v
+      else
+        v = VertexWrapper.new v
+      end
+      v.graph = graph
+      v
     end
 
     # This method must be defined here rather than in the superclass in order
     # to correctly override the method in an included module
-    def element
-      @element
+    def extensions
+      self.class.extensions
     end
 
+    # 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.
+    #
+    # @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?
-        self.class.wrap(element, extensions + exts.to_a)
+        e = self.class.wrap(element, extensions + exts.to_a)
+        e.graph = graph
+        e
       else
         self
       end
     end
+
+    # Returns the element with a new simple wrapper.
+    # @return [EdgeWrapper]
+    def no_extensions
+      EdgeWrapper.new element
+    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.remove_edge 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 [PacerGraph] 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::Wrappers::EdgeWrapper] 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("tmp-e-#{graph.graph_id}", :edge, :create => true)
+      e = target_graph.edge(element_id)
+      unless e
+        e = e_idx.first('id', element_id)
+        if e
+          e = EdgeWrapper.new(e)
+          e.graph = target_graph
+        end
+      end
+      unless e
+        v_idx = target_graph.index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
+        iv = target_graph.vertex(in_vertex.element_id) || v_idx.first('id', in_vertex.element_id)
+        ov = target_graph.vertex(out_vertex.element_id) || v_idx.first('id', out_vertex.element_id)
+        if opts[:create_vertices]
+          iv ||= in_vertex.clone_into target_graph
+          ov ||= out_vertex.clone_into target_graph
+        end
+        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]
+          return nil
+        end
+        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 [PacerGraph] target_graph
+    # @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
+    def copy_into(target_graph)
+      v_idx = target_graph.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
+      e = target_graph.create_edge nil, iv, ov, label, properties
+      yield e if block_given?
+      e
+    end
+
+    # Test equality to another object.
+    #
+    # Elements are equal if they are the same element type and have the same id
+    # and the same graph, regardless of extensions/wrappers.
+    #
+    # If the graphdb instantiates multiple copies of the same element
+    # this method will return true when comparing them.
+    #
+    # If the other instance is an unwrapped edge, this will always return
+    # false because otherwise the == method would not be symetrical.
+    #
+    # @see #eql?
+    # @param other
+    def ==(other)
+      other.is_a? EdgeWrapper and
+        element_id == other.element_id and
+        graph == other.graph
+    end
   end
 end

data/lib/pacer/wrappers/element_wrapper.rb

@@ -3,16 +3,26 @@ module Pacer::Wrappers
     include Pacer::Element
     extend Forwardable
     include Comparable
+    include Pacer::Routes::RouteOperations
+    include Pacer::Core::Graph::ElementRoute
 
     class << self
       def wrap(element, exts)
-        wrapper_for(exts).new(element.element)
+        if element.respond_to? :element
+          wrapper_for(exts).new(element.element)
+        else
+          wrapper_for(exts).new(element)
+        end
       end
 
       def extensions
         @extensions ||= []
       end
 
+      def add_extensions(exts)
+        wrapper_for(extensions + exts.to_a)
+      end
+
       def clear_cache
         Pacer.send :remove_const, :Wrap if Pacer.const_defined? :Wrap
         VertexWrapper.clear_cache
@@ -37,8 +47,19 @@ module Pacer::Wrappers
         sc_name = superclass.to_s.split(/::/).last
         exts = exts.uniq unless exts.is_a? Set
         classname = "#{sc_name}#{exts.map { |m| m.to_s }.join('')}".gsub(/::/, '_').gsub(/\W/, '')
-        eval "module ::Pacer; module Wrap; class #{classname.to_s} < #{sc_name}; end; end; end"
-        wrapper = Pacer::Wrap.const_get classname
+        begin
+          wrapper = Pacer::Wrap.const_get classname
+        rescue NameError
+          eval %{
+            module ::Pacer
+              module Wrap
+                class #{classname.to_s} < #{sc_name}
+                end
+              end
+            end
+          }
+          wrapper = Pacer::Wrap.const_get classname
+        end
         exts.each do |obj|
           if obj.is_a? Module or obj.is_a? Class
             mod_names.each do |mod_name|
@@ -53,21 +74,125 @@ module Pacer::Wrappers
       end
     end
 
+    # For internal use only.
+    #
+    # 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 [PacerGraph]
+    attr_accessor :graph
+    attr_reader :element
+
     def initialize(element)
-      @element = element
+      if element.is_a? ElementWrapper
+        @element = element.element
+      else
+        @element = element
+      end
       after_initialize
     end
 
+    def hash
+      element.hash
+    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)
+        graph.decode_property(value)
+      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)
+      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 [ElementWrapper] 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.blueprints_graph.equal? graph.blueprints_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.get_id
+      element.getId
     end
 
-    def hash
-      @element.hash
+    # Sort objects semi arbitrarily based on {#display_name}.
+    # @param other
+    #
+    # @return [Fixnum]
+    def <=>(other)
+      display_name.to_s <=> other.display_name.to_s
     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)
-      @element.eql?(other)
+      if other.respond_to? :element_id
+        other.graph == graph and other.element_id == element_id
+      else
+        element.equals other
+      end
     end
 
     protected

data/lib/pacer/wrappers/index_wrapper.rb

@@ -0,0 +1,47 @@
+module Pacer::Wrappers
+  class IndexWrapper
+    attr_reader :index, :graph, :element_type
+
+    def initialize(graph, index, element_type)
+      @index = index
+      @graph = graph
+      @element_type = element_type
+    end
+
+    def name
+      index.index_name
+    end
+
+    def wrapper
+      WrapperSelector.build element_type
+    end
+
+    def first(key, value, extensions = nil)
+      e = index.get(key, value).first
+      if e
+        e = wrapper.new e
+        e = e.add_extensions extensions if extensions
+        e.graph = graph
+      end
+      e
+    end
+
+    def all(key, value, extensions = nil)
+      iter = index.get(key, value)
+      if graph or extensions
+        pipe = Pacer::Pipes::WrappingPipe.new graph, element_type, extensions
+        pipe.setStarts iter.iterator
+        pipe
+      else
+        iter
+      end
+    end
+
+    def put(key, value, element)
+      if element.is_a? ElementWrapper
+        element = element.element
+      end
+      index.put key, value, element
+    end
+  end
+end

data/lib/pacer/wrappers/vertex_wrapper.rb

@@ -2,19 +2,20 @@ module Pacer::Wrappers
   class VertexWrapper < ElementWrapper
     include Pacer::Vertex
     include Pacer::Core::Graph::VerticesRoute
-    include Pacer::ElementMixin
-    include Pacer::VertexMixin
 
     def_delegators :@element,
       :getId, :getPropertyKeys, :getProperty, :setProperty, :removeProperty,
-      :getOutEdges, :getInEdges,
-      :getRawVertex,
-      :graph, :graph=, :<=>, :==
+      :getEdges,
+      :getRawVertex
 
     class << self
       def wrapper_for(exts)
         @wrappers = {} unless defined? @wrappers
-        @wrappers[exts.to_set] ||= build_vertex_wrapper(exts)
+        if exts
+          @wrappers[exts.to_set] ||= build_vertex_wrapper(exts)
+        else
+          fail Pacer::LogicError, "Extensions should not be nil"
+        end
       end
 
       def clear_cache
@@ -30,22 +31,184 @@ module Pacer::Wrappers
 
     # This method must be defined here rather than in the superclass in order
     # to correctly override the method in an included module
-    def extensions
-      self.class.extensions
-    end
+    attr_reader :element
 
     # This method must be defined here rather than in the superclass in order
     # to correctly override the method in an included module
-    def element
-      @element
+    def extensions
+      self.class.extensions
     end
 
+    # 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.
+    #
+    # @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?
-        self.class.wrap(element, extensions + exts.to_a)
+        e = self.class.wrap(element, extensions + exts.to_a)
+        e.graph = graph
+        e
       else
         self
       end
     end
+
+    # Returns the element with a new simple wrapper.
+    # @return [VertexWrapper]
+    def no_extensions
+      e = VertexWrapper.new element
+      e.graph = graph
+      e
+    end
+
+    # Checks that the given extensions can be applied to the vertex. If
+    # they can then yield the vertex correctly extended or return the extended
+    # vertex. If not then do not yield and return nil.
+    #
+    # @param [extensions] exts extensions to add if possible
+    # @yield [v] Optional block yields the vertex with the extensions added.
+    # @return nil or the result of the block or the extended vertex
+    def as(*exts)
+      if as?(*exts)
+        exts_to_add = extensions_missing(exts)
+        extended = exts_to_add.empty? ? self : add_extensions(exts_to_add)
+        if block_given?
+          yield extended
+        else
+          extended
+        end
+      end
+    end
+
+    def only_as(*exts)
+      if as?(*exts)
+        extended = exts.empty? ? no_extensions : no_extensions.add_extensions(exts)
+        if block_given?
+          yield extended
+        else
+          extended
+        end
+      end
+    end
+
+    def as?(*exts)
+      has_exts = extensions_missing(exts).all? do |ext|
+        if ext.respond_to? :route_conditions
+          ext.route_conditions.all? do |k, v|
+            self[k] == v
+          end
+        else
+          true
+        end
+      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.remove_vertex element
+    end
+
+    # Copies including the vertex id unless a vertex with that id
+    # already exists.
+    # @param [PacerGraph] target_graph
+    # @param opts for compatibility with {Pacer::Wrappers::EdgeWrapper#clone_into}
+    # @yield [v] Optional block yields the vertex after it has been created.
+    # @return [Pacer::Wrappers::VertexWrapper] the new vertex
+    def clone_into(target_graph, opts = nil)
+      v_idx = target_graph.index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
+      v = target_graph.vertex(element_id) || v_idx.first('id', element_id)
+      unless v
+        v = target_graph.create_vertex element_id, properties
+        v_idx.put('id', element_id, v.element)
+        yield v if block_given?
+      end
+      v
+    end
+
+    # Make a new copy of the element with the next available vertex id.
+    #
+    # @param [PacerGraph] target_graph
+    # @yield [v] Optional block yields the vertex after it has been created.
+    # @return [Pacer::Wrappers::VertexWrapper] the new vertex
+    def copy_into(target_graph)
+      v = target_graph.create_vertex properties
+      yield v if block_given?
+      v
+    end
+
+    def out_edges(*labels_and_extensions)
+      get_edges_helper Pacer::Pipes::OUT, *labels_and_extensions
+    end
+
+    def in_edges(*labels_and_extensions)
+      get_edges_helper Pacer::Pipes::IN, *labels_and_extensions
+    end
+
+    def both_edges(*labels_and_extensions)
+      get_edges_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
+    # 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.
+    #
+    # If the other instance is an unwrapped vertex, this will always return
+    # false because otherwise the == method would not be symetrical.
+    #
+    # @see #eql?
+    # @param other
+    def ==(other)
+      other.is_a? VertexWrapper and
+        element_id == other.element_id and
+        graph == other.graph
+    end
+
+    protected
+
+    def get_edges_helper(direction, *labels_and_extensions)
+      labels, exts = split_labels_and_extensions(labels_and_extensions)
+      pipe = Pacer::Pipes::WrappingPipe.new graph, :edge, exts
+      pipe.setStarts element.getEdges(direction, *labels).iterator
+      pipe
+    end
+
+    def split_labels_and_extensions(mixed)
+      labels = Set[]
+      exts = []
+      mixed.each do |obj|
+        if obj.is_a? Symbol or obj.is_a? String
+          labels << obj
+        else
+          exts << obj
+        end
+      end
+      [labels, exts.uniq]
+    end
+
+    # Return the extensions this vertex is missing from the given array
+    def extensions_missing(exts)
+      Set.new(exts.flatten).difference extensions.to_set
+    end
   end
 end

data/lib/pacer/wrappers/wrapper_selector.rb

@@ -0,0 +1,40 @@
+module Pacer::Wrappers
+  class WrapperSelector
+    import com.tinkerpop.blueprints.Vertex
+    import com.tinkerpop.blueprints.Edge
+
+    def self.build(element_type = nil, extensions = [])
+      if element_type == :vertex
+        Pacer::Wrappers::VertexWrapper.wrapper_for extensions
+      elsif element_type == :edge
+        Pacer::Wrappers::EdgeWrapper.wrapper_for extensions
+      else
+        new extensions
+      end
+    end
+
+    attr_reader :extensions
+    attr_accessor :vertex_wrapper, :edge_wrapper
+
+    def initialize(extensions = [])
+      @extensions = extensions
+    end
+
+    def wrapper(element)
+      if element.is_a? Vertex
+        self.vertex_wrapper ||= Pacer::Wrappers::VertexWrapper.wrapper_for extensions
+      elsif element.is_a? Edge
+        self.edge_wrapper ||= Pacer::Wrappers::EdgeWrapper.wrapper_for extensions
+      end
+    end
+
+    def new(element)
+      w = wrapper(element)
+      if w
+        w.new element
+      else
+        element
+      end
+    end
+  end
+end