pacer 0.9.1.1-java → 1.0.0-java

data/lib/pacer/graph/element_mixin.rb

@@ -1,202 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

data/lib/pacer/graph/graph_mixin.rb

@@ -1,361 +0,0 @@
-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/index_mixin.rb

@@ -1,30 +0,0 @@
-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