neo4j-core 0.0.15-java → 2.0.0.alpha.1-java

data/lib/neo4j-core/cypher/result_wrapper.rb

@@ -1,48 +0,0 @@
-module Neo4j
-  module Core
-    module Cypher
-      # Wraps the Cypher query result.
-      # Loads the node and relationships wrapper if possible and use symbol as column keys.
-      # @notice The result is a once forward read only Enumerable, work if you need to read the result twice - use #to_a
-      #
-      # @example
-      #   result = Neo4j.query(@a, @b){|a,b| node(a,b).as(:n)}
-      #   r = @query_result.to_a # can only loop once
-      #   r.size.should == 2
-      #   r.first.should include(:n)
-      #   r[0][:n].neo_id.should == @a.neo_id
-      #   r[1][:n].neo_id.should == @b.neo_id
-      class ResultWrapper
-        include Enumerable
-
-        # @return the original result from the Neo4j Cypher Engine, once forward read only !
-        attr_reader :source
-
-        def initialize(source)
-          @source = source
-        end
-
-        # @return [Array<Symbol>] the columns in the query result
-        def columns
-          @source.columns.map{|x| x.to_sym}
-        end
-
-        # for the Enumerable contract
-        def each
-          @source.each { |row| yield map(row) }
-        end
-
-        # Maps each row so that we can use symbols for column names.
-        # @private
-        def map(row)
-          out = {} # move to a real hash!
-          row.each do |key, value|
-            out[key.to_sym] = value.respond_to?(:wrapper) ? value.wrapper : value
-          end
-          out
-        end
-
-      end
-    end
-  end
-end

data/lib/neo4j-core/hash_with_indifferent_access.rb

@@ -1,165 +0,0 @@
-module Neo4j
-  module Core
-    # Stolen from http://as.rubyonrails.org/classes/HashWithIndifferentAccess.html
-    # We don't want to depend on active support
-    class HashWithIndifferentAccess < Hash
-
-      # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
-      def extractable_options?
-        true
-      end
-
-      def with_indifferent_access
-        dup
-      end
-
-      def nested_under_indifferent_access
-        self
-      end
-
-      def initialize(constructor = {})
-        if constructor.is_a?(Hash)
-          super()
-          update(constructor)
-        else
-          super(constructor)
-        end
-      end
-
-      def default(key = nil)
-        if key.is_a?(Symbol) && include?(key = key.to_s)
-          self[key]
-        else
-          super
-        end
-      end
-
-      def self.new_from_hash_copying_default(hash)
-        new(hash).tap do |new_hash|
-          new_hash.default = hash.default
-        end
-      end
-
-      alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-      alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-      # Assigns a new value to the hash:
-      #
-      #   hash = HashWithIndifferentAccess.new
-      #   hash[:key] = "value"
-      #
-      def []=(key, value)
-        regular_writer(convert_key(key), convert_value(value))
-      end
-
-      alias_method :store, :[]=
-
-      # Updates the instantized hash with values from the second:
-      #
-      #   hash_1 = HashWithIndifferentAccess.new
-      #   hash_1[:key] = "value"
-      #
-      #   hash_2 = HashWithIndifferentAccess.new
-      #   hash_2[:key] = "New Value!"
-      #
-      #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-      #
-      def update(other_hash)
-        if other_hash.is_a? HashWithIndifferentAccess
-          super(other_hash)
-        else
-          other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-          self
-        end
-      end
-
-      alias_method :merge!, :update
-
-      # Checks the hash for a key matching the argument passed in:
-      #
-      #   hash = HashWithIndifferentAccess.new
-      #   hash["key"] = "value"
-      #   hash.key? :key  # => true
-      #   hash.key? "key" # => true
-      #
-      def key?(key)
-        super(convert_key(key))
-      end
-
-      alias_method :include?, :key?
-      alias_method :has_key?, :key?
-      alias_method :member?, :key?
-
-      # Fetches the value for the specified key, same as doing hash[key]
-      def fetch(key, *extras)
-        super(convert_key(key), *extras)
-      end
-
-      # Returns an array of the values at the specified indices:
-      #
-      #   hash = HashWithIndifferentAccess.new
-      #   hash[:a] = "x"
-      #   hash[:b] = "y"
-      #   hash.values_at("a", "b") # => ["x", "y"]
-      #
-      def values_at(*indices)
-        indices.collect {|key| self[convert_key(key)]}
-      end
-
-      # Returns an exact copy of the hash.
-      def dup
-        self.class.new(self).tap do |new_hash|
-          new_hash.default = default
-        end
-      end
-
-      # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
-      # Does not overwrite the existing hash.
-      def merge(hash)
-        self.dup.update(hash)
-      end
-
-      # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-      # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
-      def reverse_merge(other_hash)
-        super self.class.new_from_hash_copying_default(other_hash)
-      end
-
-      def reverse_merge!(other_hash)
-        replace(reverse_merge( other_hash ))
-      end
-
-      # Removes a specified key from the hash.
-      def delete(key)
-        super(convert_key(key))
-      end
-
-      def stringify_keys!; self end
-      def stringify_keys; dup end
-#      undef :symbolize_keys!
-      def symbolize_keys; to_hash.symbolize_keys end
-      def to_options!; self end
-
-      # Convert to a Hash with String keys.
-      def to_hash
-        Hash.new(default).merge!(self)
-      end
-
-      protected
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.to_s : key
-        end
-
-        def convert_value(value)
-          if value.is_a? Hash
-            value #.nested_under_indifferent_access
-          elsif value.is_a?(Array)
-            value.dup.replace(value.map { |e| convert_value(e) })
-          else
-            value
-          end
-        end
-    end
-
-  end
-end

data/lib/neo4j-core/index/unique_factory.rb

@@ -1,54 +0,0 @@
-module Neo4j
-  module Core
-
-    module Index
-
-      # A Utility class that can be used to make it easier to create unique entities. It uses {Neo4j::Core::Index::Indexer#put_if_absent}.
-      #
-      # @see Indexer#put_if_absent
-      #
-      # @example
-      #   index = index_for_type(:exact)
-      #   Neo4j::Core::Index::UniqueFactory.new(:email, index) { |k,v| Neo4j::Node.new(k => v) }.get_or_create(:email, 'foo@gmail.com')
-      #
-      class UniqueFactory
-        # @param [Symbol] key only one key is possible
-        # @param [Java::Neo4j] index the lucene index (see #index_for_type)
-        # @yield a proc for initialize each created entity
-        def initialize(key, index, &entity_creator_block)
-          @key = key
-          @index = index
-          @entity_creator_block = entity_creator_block || Proc.new{|k,v| Neo4j::Node.new(key.to_s => v)}
-        end
-
-        # Get the indexed entity, creating it (exactly once) if no indexed entity exists.
-        # There must be an index on the key
-        # @param [Symbol] key the key to find the entity under in the index.
-        # @param [String, Fixnum, Float] value  the value the key is mapped to for the entity in the index.
-        # @param [Hash] props optional properties that the entity will have if created
-        # @yield optional, make it possible to initialize the created node in a block
-        def get_or_create(key, value, props=nil, &init_block)
-          tx = Neo4j::Transaction.new
-          result = @index.get(key.to_s, value).get_single
-          return result if result
-
-          created = @entity_creator_block.call(key,value)
-          result = @index.put_if_absent(created._java_entity, key.to_s, value)
-          if result.nil?
-            props.each_pair{|k,v| created[k.to_s] = v} if props
-            init_block.call(result) if init_block
-            result = created
-          else
-            created.del
-          end
-          tx.success
-          result
-        ensure
-          tx.finish
-        end
-
-      end
-    end
-
-  end
-end

data/lib/neo4j-core/property/java.rb

@@ -1,59 +0,0 @@
-module Neo4j
-  module Core
-    module Property
-      # This module is only used for documentation purpose
-      # It simplify declares the java methods which are available Java org.neo4j.graphdb.PropertyContainer
-      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/PropertyContainer.html
-      module Java
-
-
-        # Get the GraphDatabaseService that this Node or Relationship belongs to.
-        # @return [Java::Neo4jGraphdbGraphDatabaseService]
-        def graph_database
-        end
-
-        # Returns the property value associated with the given key, or a default value.
-        # The value is of one of the valid property types, i.e. a Java primitive, a String or an array of any of the valid types.
-        # If there's no property associated with key an unchecked exception is raised.
-        # The idiomatic way to avoid an exception for an unknown key and instead get null back is to use a default value: Object valueOrNull = nodeOrRel.getProperty( key, null )
-        # @param [String] key the property key
-        # @param [String] default_value the default value that will be returned if no property value was associated with the given key
-        # @return [String,Fixnum,Boolean,Float,Array] ]the property value associated with the given key.
-        # @raise an exception if not given a default value and there is no property for the given key
-        # @see Neo4j::Core:Property#[]
-        def get_property(key, default_value = nil)
-        end
-
-        # @return all existing property keys, or an empty iterable if this property container has no properties.
-        def property_keys
-        end
-
-
-        # Removes the property associated with the given key and returns the old value.
-        # @param [String] key the name of the property
-        # @return [String,Fixnum,Boolean,Float,Array, nil] The old value or <tt>nil</tt> if there's no property associated with the key.
-        def remove_property(key)
-        end
-
-        # Sets the property value for the given key to value.
-        # The property value must be one of the valid property types, i.e:
-        # * boolean or boolean[]
-        # * byte or byte[]
-        # * short or short[]
-        # * int or int[]
-        # * long or long[]
-        # * float or float[]
-        # * double or double[]
-        # * char or char[]
-        # * java.lang.String or String[]
-        # Notice that JRuby does map Ruby primitive object (e.g. Fixnum) to java primitives automatically.
-        # Also, nil is not an accepted property value.
-        # @param [String] key the property key
-        # @param [String,Fixnum,Boolean,Float,Array] value
-        # @see Neo4j::Core::Property#[]=
-        def set_property(key, value)
-        end
-      end
-    end
-  end
-end

data/lib/neo4j-core/wrapper/class_methods.rb

@@ -1,22 +0,0 @@
-module Neo4j
-  module Core
-    module Wrapper
-      module ClassMethods
-
-        # Tries to load a wrapper for this node if possible
-        # @see #wrapper_proc=
-        def wrapper(entity)
-          @_wrapper_proc ? @_wrapper_proc.call(entity) : entity
-        end
-
-        # Sets the procs to be used to load wrappers
-        # @see #wrapper
-        def wrapper_proc=(proc)
-          @_wrapper_proc = proc
-        end
-
-
-      end
-    end
-  end
-end

data/lib/neo4j-core/wrapper/wrapper.rb

@@ -1,20 +0,0 @@
-module Neo4j
-  module Core
-    # Can be used to define your own wrapper class around nodes and relationships
-    module Wrapper
-
-      # @return [self, Object] return self or a wrapper Ruby object
-      # @see  Neo4j::Node::ClassMethods#wrapper
-      def wrapper
-        self.class.wrapper(self)
-      end
-
-      # This can be implemented by a wrapper to returned the underlying java node or relationship.
-      # You can override this method in your own wrapper class.
-      # @return self
-      def _java_entity
-        self
-      end
-    end
-  end
-end

data/lib/neo4j/algo.rb

@@ -1,300 +0,0 @@
-module Neo4j
-
-
-  # A wrapper for the Neo4j Algo <tt>org.neo4j.graphalgo.GraphAlgoFactory</tt> class.
-  #
-  # @example the length of the first path found between two nodes
-  #   Neo4j::Algo.all_paths(a,b).outgoing(:friends).depth(1).first.length
-  #
-  # @example the nodes in the shortest path between two nodes
-  #   Neo4j::Algo.shortest_path(a,b).outgoing(:friends).outgoing(:knows).to_a #=> [node1, node2, node3 ...]
-  #
-  # @example the relationships in the shortest path between two nodes
-  #   Neo4j::Algo.shortest_path(a,b).outgoing(:friends).outgoing(:knows).rels.to_a #=> [rel1, rel2, rel3 ...]
-  #
-  # @example The Dijkstra algorithm using a cost evaluator
-  #   Neo4j::Algo.dijkstra_path(a,b).cost_evaluator{|rel,direction| rel[:weight]}
-  class Algo
-    include Enumerable
-    include Neo4j::Core::ToJava
-
-    class EstimateEvaluator #:nodoc
-      include org.neo4j.graphalgo.EstimateEvaluator
-      include Neo4j::Core::ToJava
-
-      def initialize(&evaluator)
-        @evaluator = evaluator
-      end
-
-      # Implements T getCost(Node node, Node goal)
-      # Estimate the weight of the remaining path from one node to another.
-      def get_cost(node, goal)
-        @evaluator.call(node, goal)
-      end
-    end
-
-    class CostEvaluator #:nodoc
-      include org.neo4j.graphalgo.CostEvaluator
-      include Neo4j::Core::ToJava
-
-      def initialize(&evaluator)
-        @evaluator = evaluator
-      end
-
-      # Implements the Java Method:   T getCost(Relationship relationship, Direction direction)
-      # From the JavaDoc: <pre>
-      # This is the general method for looking up costs for relationships.
-      # This can do anything, like looking up a property or running some small calculation.
-      # Parameters:
-      # relationship -
-      # direction - The direction in which the relationship is being evaluated, either Direction.INCOMING or Direction.OUTGOING.
-      # Returns:
-      # The cost for this edge/relationship
-      # </pre>
-      def get_cost(relationship, direction)
-        @evaluator.call(relationship, dir_from_java(direction))
-      end
-    end
-
-    def initialize(from, to, &factory_proc) #:nodoc:
-      @from          = from
-      @to            = to
-      @factory_proc  = factory_proc
-      @type_and_dirs = []
-
-    end
-
-    def _depth #:nodoc:
-      @depth || java.lang.Integer::MAX_VALUE
-    end
-
-    def _expander #:nodoc:
-      expander = @expander
-      expander ||= @type_and_dirs.empty? ? org.neo4j.kernel.Traversal.expanderForAllTypes() : org.neo4j.kernel.Traversal.expanderForTypes(*@type_and_dirs)
-      expander
-    end
-
-    def _cost_evaluator #:nodoc:
-      raise "Algorithm requeries a cost evalulator, use the cost_evaluator to provide one" unless @cost_evaluator
-      @cost_evaluator
-    end
-
-    def _estimate_evaluator #:nodoc:
-      raise "Algorithm requeries a estimate evaluator, use the estimate_evaluator to provide one" unless @estimate_evaluator
-      @estimate_evaluator
-    end
-
-    # Specifies which outgoing relationship should be traversed for the graph algorithm
-    #
-    # @param [String, Symbol] rel the relationship type
-    # @return self
-    def outgoing(rel)
-      @type_and_dirs << type_to_java(rel)
-      @type_and_dirs << dir_to_java(:outgoing)
-      self
-    end
-
-    # Specifies which incoming relationship should be traversed for the graph algorithm
-    #
-    # @param [String, Symbol] rel the relationship type
-    # @return self
-    def incoming(rel)
-      @type_and_dirs << type_to_java(rel)
-      @type_and_dirs << dir_to_java(:incoming)
-      self
-    end
-
-    # Specifies which relationship should be traversed for the graph algorithm
-    #
-    # @example
-    #  Neo4j::Algo.shortest_path(@x,@y).expand{|node| node._rels(:outgoing, :friends)}
-    #
-    # @example the above is same as:
-    #  Neo4j::Algo.shortest_path(@x,@y).outgoing(:friends)
-    #
-    # @param [Proc] expander_proc a proc relationship type (symbol)
-    # @return self
-    def expand(&expander_proc)
-      @expander = (Neo4j::Core::Traversal::RelExpander.create_pair(&expander_proc))
-      self
-    end
-
-    # If only a single path should be returned,
-    # default for some algorithms, like shortest_path
-    def single
-      @single = true
-      self
-    end
-
-    # See #single
-    # Not sure if this method is useful
-    def many
-      @single = false
-    end
-
-    # The depth of the traversal
-    # Notice not all algorithm uses this argument (aStar and dijkstra)
-    def depth(depth)
-      @depth = depth
-      self
-    end
-
-    # Specifies a cost evaluator for the algorithm.
-    # Only available for the aStar and dijkstra algorithms.
-    #
-    # @example
-    #  Neo4j::Algo.dijkstra(@x,@y).cost_evaluator{|rel,*| rel[:weight]}
-    #
-    def cost_evaluator(&cost_evaluator_proc)
-      @cost_evaluator = CostEvaluator.new(&cost_evaluator_proc)
-      self
-    end
-
-    # Specifies an evaluator that returns an (optimistic) estimation of the cost to get from the current node (in the traversal) to the end node.
-    # Only available for the aStar algorithm.
-    #
-    # The provided proc estimate the weight of the remaining path from one node to another.
-    # The proc takes two parameters:
-    # * node :: the node to estimate the weight from.
-    # * goal :: the node to estimate the weight to.
-    #
-    # The proc should return an estimation of the weight of the path from the first node to the second.
-    #
-    # @example
-    #  Neo4j::Algo.a_star(@x,@y).cost_evaluator{...}.estimate_evaluator{|node,goal| some calculation returning a Float}
-    #
-    def estimate_evaluator(&estimate_evaluator_proc)
-      @estimate_evaluator = EstimateEvaluator.new(&estimate_evaluator_proc)
-      self
-    end
-
-    # Specifies that nodes should be returned from as result
-    # @see #rels
-    def nodes
-      @path_finder_method = :nodes
-      self
-    end
-
-    # Specifies that relationships should be returned from as result
-    # @see #nodes
-    def rels
-      @path_finder_method = :relationships
-      self
-    end
-
-
-    # So that one can call directly method on the PathFinder result from an executed algorithm.
-    def method_missing(m, *args, &block)
-      execute_algo.send(m, *args)
-    end
-
-    def each(&block) #:nodoc:
-      if @single && @path_finder_method
-        execute_algo.send(@path_finder_method).each &block
-      else
-        traversal = execute_algo
-        traversal.each &block if traversal
-      end
-    end
-
-    def execute_algo #:nodoc:
-      instance = self.instance_eval(&@factory_proc)
-      if @single
-        instance.find_single_path(@from._java_node, @to._java_node)
-      else
-        instance.find_all_paths(@from._java_node, @to._java_node)
-      end
-    end
-
-    # Returns an instance of Neo4j::Algo which can find all available paths between two nodes.
-    # These returned paths can contain loops (i.e. a node can occur more than once in any returned path).
-    def self.all_paths(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_paths(_expander, _depth) }
-    end
-
-    # See #all_paths, returns the first path found
-    def self.all_path(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_paths(_expander, _depth) }.single
-    end
-
-    # Returns an instance of Neo4j::Algo which can find all simple paths between two nodes.
-    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
-    def self.all_simple_paths(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_simple_paths(_expander, _depth) }
-    end
-
-    # See #all_simple_paths, returns the first path found
-    def self.all_simple_path(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_simple_paths(_expander, _depth) }.single
-    end
-
-    # Returns an instance of Neo4j::Algo which can find all shortest paths (that is paths with as short Path.length() as possible) between two nodes.
-    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
-    def self.shortest_paths(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.shortest_path(_expander, _depth) }
-    end
-
-    # See #shortest_paths, returns the first path found
-    def self.shortest_path(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.shortest_path(_expander, _depth) }.single
-    end
-
-    # Returns an instance of Neo4j::Algo which uses the Dijkstra algorithm to find the cheapest path between two nodes.
-    # The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from costEvaluator.
-    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
-    # See http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm for more information.
-    #
-    # Example
-    #
-    #   Neo4j::Algo.dijkstra_path(node_a,node_b).cost_evaluator{|rel,*| rel[:weight]}.rels
-    #
-    def self.dijkstra_paths(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.dijkstra(_expander, _cost_evaluator) }
-    end
-
-    # See #dijkstra_paths, returns the first path found
-    #
-    def self.dijkstra_path(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.dijkstra(_expander, _cost_evaluator) }.single
-    end
-
-    # Returns an instance of Neo4j::Algo which uses the A* algorithm to find the cheapest path between two nodes.
-    # The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from lengthEvaluator and estimateEvaluator. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
-    # See http://en.wikipedia.org/wiki/A*_search_algorithm for more information.
-    #
-    # Expacts an cost evaluator and estimate evaluator, see Algo#cost_evaluator and Algo#estimate_evaluator
-    #
-    # Example:
-    #
-    #  Neo4j::Algo.a_star_path(@x,@y).cost_evaluator{|rel,*| rel[:weight]}.estimate_evaluator{|node,goal| returns a float value}
-    #
-    def self.a_star_paths(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.a_star(_expander, _cost_evaluator, _estimate_evaluator) }
-    end
-
-    # See #a_star_paths, returns the first path found
-    #
-    def self.a_star_path(from, to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.a_star(_expander, _cost_evaluator, _estimate_evaluator) }.single
-    end
-
-    # Returns an instance of Neo4j::Algo can find all paths of a certain length(depth) between two nodes.
-    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
-    # Expects setting the depth parameter (the lenghto of the path) by the Algo#depth method.
-    #
-    # Example:
-    #
-    #   Neo4j::Algo.with_length_paths(node_a,node_b).depth(2).each {|x| puts "Node #{x}"}
-    #
-    def self.with_length_paths(from,to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.paths_with_length(_expander, _depth) }
-    end
-
-    # See #with_length_paths, returns the first path found
-    #
-    def self.with_length_path(from,to)
-      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.paths_with_length(_expander, _depth) }.single
-    end
-
-  end
-end