neography-down 1.6.4

data/lib/neography/equal.rb

@@ -0,0 +1,21 @@
+module Neography
+
+  # == This mixin is used for both nodes and relationships to decide if two entities are equal or not.
+  #
+  module Equal
+    def equal?(o)
+      eql?(o)
+    end
+
+    def eql?(o)
+      return false unless o.respond_to?(:neo_id)
+      o.neo_id == neo_id
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+  end
+
+end

data/lib/neography/errors.rb

@@ -0,0 +1,60 @@
+module Neography
+
+  class NeographyError < StandardError
+    attr_reader :message, :code, :stacktrace, :request, :index
+
+    def initialize(message = nil, code = nil, stacktrace = nil, request = nil, index = 0)
+      @message    = message
+      @code       = code
+      @stacktrace = stacktrace
+      @request    = request
+      @index      = index
+    end
+  end
+
+    def to_s
+     "NeographyError: \n--message: #{@message}, \n--code: #{@code}, \n--stacktrace: #{@stacktrace}, \n--request: #{@request}, \n--index: #{@index}"
+    end
+
+  # HTTP Authentication error
+  class UnauthorizedError < NeographyError; end
+
+  # the Neo4j server Exceptions returned by the REST API:
+
+  # A node could not be found
+  class NodeNotFoundException < NeographyError; end
+
+  # A node cannot be deleted because it has relationships
+  class OperationFailureException < NeographyError; end
+
+  # Properties can not be null
+  class PropertyValueException < NeographyError; end
+
+  # Trying to a delete a property that does not exist
+  class NoSuchPropertyException < NeographyError; end
+
+  # A relationship could not be found
+  class RelationshipNotFoundException < NeographyError; end
+
+  # Error during valid Cypher query
+  class BadInputException < NeographyError; end
+
+  # Invalid Cypher query syntax
+  class SyntaxException < NeographyError; end
+
+  # A path could not be found by node traversal
+  class NotFoundException < NeographyError; end
+
+  # Thrown when CREATE UNIQUE matches multiple paths.
+  class UniquePathNotUniqueException < NeographyError; end
+
+  # Signals that a deadlock between two or more transactions has been detected
+  class DeadlockDetectedException < NeographyError; end
+
+  # Unknown batch option exception detected
+  class UnknownBatchOptionException < NeographyError; end
+
+  # A Cypher query is using a parameter that is not supplied
+  class ParameterNotFoundException < NeographyError; end
+
+end

data/lib/neography/index.rb

@@ -0,0 +1,52 @@
+module Neography
+  module Index
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+    def add_to_index(index, key, value, unique = false)
+      if self.is_a? Neography::Node
+        self.neo_server.add_node_to_index(index, key, value, self.neo_id, unique)
+      else
+        self.neo_server.add_relationship_to_index(index, key, value, self.neo_id)
+      end
+    end
+
+    def remove_from_index(*args)
+      if self.is_a? Neography::Node
+        self.neo_server.remove_node_from_index(*args)
+      else
+        self.neo_server.remove_relationship_from_index(*args)
+      end
+    end
+
+    module ClassMethods
+      def find(*args)
+        db = args[3] ? args.pop : Neography::Rest.new
+
+        if self <= Neography::Node
+          nodes = []
+          results = db.find_node_index(*args)
+          return nil unless results
+          results.each do |r|
+            node = self.new(r)
+            node.neo_server = db
+            nodes << node
+          end
+          nodes.size > 1 ? nodes : nodes.first
+        else
+          rels = []
+          results = db.find_relationship_index(*args)
+          return nil unless results
+          results.each do |r|
+            rel = self.new(r, db)
+            rels << rel
+          end
+          rels.size > 1 ? rels : rels.first
+        end  
+      end
+    end
+    
+  end
+end

data/lib/neography/multi_json_parser.rb

@@ -0,0 +1,28 @@
+class MultiJsonParser
+
+
+    # I know this looks pretty ugly, but we have issues with Neo4j returning true, false,
+    # plain numbers and plain strings, which is considered by some JSON libraries to be
+    # invalid JSON, but some consider it perfectly fine.
+    # This ugly hack deals with the problem.  Send me a Pull Request if you
+    # come up with a nicer solution... please!
+    #
+    def self.json(body)
+      begin
+        MultiJson.load(body)
+      rescue MultiJson::DecodeError, ArgumentError
+        case
+          when body == "true"
+            true
+          when body == "false"
+            false
+           when body.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true
+            Float(body)
+          else
+            body[1..-2]
+        end
+
+      end
+    end
+
+end

data/lib/neography/neography.rb

@@ -0,0 +1,10 @@
+module Neography
+
+  class << self
+
+    def ref_node(this_db = Neography::Rest.new)
+      this_db.get_root
+    end
+
+  end
+end

data/lib/neography/node.rb

@@ -0,0 +1,63 @@
+module Neography
+  class Node < PropertyContainer
+    include Neography::Index
+    include Neography::NodeRelationship
+    include Neography::NodePath
+    include Neography::Equal
+    include Neography::Property
+
+    attr_accessor :neo_server
+
+    def self.create(props = nil, db = Neography::Rest.new)
+      raise ArgumentError.new("syntax deprecated") if props.is_a?(Neography::Rest)
+
+      node = self.new(db.create_node(props))
+      node.neo_server = db
+      node
+    end
+
+    def self.create_unique(index, key, value, props = nil, db = Neography::Rest.new)
+      raise ArgumentError.new("syntax deprecated") if props.is_a?(Neography::Rest)
+
+      node = self.new(db.create_unique_node(index, key, value, props))
+      node.neo_server = db
+      node
+    end
+
+    def self.load(node, db = Neography::Rest.new)
+      raise ArgumentError.new("syntax deprecated") if node.is_a?(Neography::Rest)
+      node = node.first if node.kind_of?(Array)
+      node = db.get_node(node) if (node.to_s.match(/^\d+$/) or node.to_s.split("/").last.match(/^\d+$/))
+      if node
+        node = self.new(node)
+        node.neo_server = db
+      end
+      node
+    end
+
+    def find(*args)
+      node = self.new
+      node.find(args)
+    end
+
+    def del
+      neo_server.delete_node!(self.neo_id)
+    end
+
+    def exist?
+      begin
+        neo_server.get_node(self.neo_id)
+        true
+      rescue NodeNotFoundException
+        false
+      end
+    end
+
+    ##
+    # List of labels of current node.
+    # Returns array of strings
+    def labels
+      self.neo_server.get_node_labels(self.neo_id)
+    end
+  end
+end

data/lib/neography/node_path.rb

@@ -0,0 +1,29 @@
+module Neography
+  module NodePath
+
+    def all_paths_to(to)
+      PathTraverser.new(self, to, "allPaths", true)
+    end
+
+    def all_simple_paths_to(to)
+      PathTraverser.new(self, to, "allSimplePaths", true)
+    end
+
+    def all_shortest_paths_to(to)
+      PathTraverser.new(self, to, "shortestPath", true)
+    end
+
+    def path_to(to)
+      PathTraverser.new(self, to, "allPaths", false)
+    end
+
+    def simple_path_to(to)
+      PathTraverser.new(self, to, "allSimplePaths", false)
+    end
+
+    def shortest_path_to(to)
+      PathTraverser.new(self, to, "shortestPath", false)
+    end
+
+  end
+end

data/lib/neography/node_relationship.rb

@@ -0,0 +1,37 @@
+module Neography
+  module NodeRelationship
+
+    DIRECTIONS = ["incoming", "in", "outgoing", "out", "all", "both"]
+
+    def outgoing(types=nil)
+      NodeTraverser.new(self).outgoing(types)
+    end
+
+    def incoming(types=nil)
+      NodeTraverser.new(self).incoming(types)
+    end
+
+    def both(types=nil)
+      NodeTraverser.new(self).both(types)
+    end
+
+    def rels(*types)
+      Neography::RelationshipTraverser.new(self, types, :both)
+    end
+
+    def rel(dir, type)
+      rel = Neography::RelationshipTraverser.new(self, type, dir)
+      rel = rel.first unless rel.empty?
+      rel
+    end
+
+    def rel?(dir=nil, type=nil)
+      if DIRECTIONS.include?(dir.to_s)
+        !self.neo_server.get_node_relationships(self, dir, type).empty? 
+      else
+        !self.neo_server.get_node_relationships(self, type, dir).empty? 
+      end
+    end
+
+  end
+end

data/lib/neography/node_traverser.rb

@@ -0,0 +1,146 @@
+module Neography
+  class NodeTraverser
+    include Enumerable
+
+    attr_accessor :order, :uniqueness, :depth, :prune, :filter, :relationships
+
+    def initialize(from, types = nil, dir = "all" )
+      @from  = from
+      @order = "depth first"
+      @uniqueness = "none"
+      @relationships = Array.new
+      types.each do |type|
+        @relationships << {"type" => type.to_s, "direction" => dir.to_s }
+      end unless types.nil?
+    end
+
+    def <<(other_node)
+      create(other_node)
+      self
+    end
+
+    def create(other_node)
+      case @relationships.first["direction"]
+        when "outgoing", "out"
+          rel = Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], @from, other_node))
+        when "incoming", "in"
+          rel = Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], other_node, @from))
+        else
+          rel = Array.new
+          rel << Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], @from, other_node))
+          rel << Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], other_node, @from))
+      end
+      rel       
+    end
+
+    def both(type)
+      @relationships << {"type" => type.to_s, "direction" => "all"}
+      self
+    end
+
+    def outgoing(type)
+      @relationships << {"type" => type.to_s, "direction" => "out"}
+      self
+    end
+
+    def incoming(type)
+      @relationships << {"type" => type.to_s, "direction" => "in"}
+      self
+    end
+
+    def uniqueness(u)
+      @uniqueness = u
+      self
+    end
+
+    def order(o)
+      @order = o
+      self
+    end
+
+    def filter(body)
+      @filter = {
+        "language" => "javascript",
+        "body"     => body
+      }
+      self
+    end
+
+    def prune(body)
+      @prune = {
+        "language" => "javascript",
+        "body"     => body
+      }
+      self
+    end
+
+    def depth(d)
+      d = 2147483647 if d == :all
+      @depth = d
+      self
+    end
+
+    def include_start_node
+      @filter = {
+        "language" => "builtin",
+        "name"     => "all"
+      }
+      self
+    end
+
+    def size
+      [*self].size
+    end
+
+    alias_method :length, :size
+
+    def [](index)
+      each_with_index {|node,i| break node if index == i}
+    end
+
+    def empty?
+      first == nil
+    end
+
+    def each
+      iterator.each do |i| 
+        node = @from.class.new(i)
+        node.neo_server = @from.neo_server
+        yield node
+      end
+    end
+
+    def iterator
+      options = {
+        "order"         => @order,
+        "uniqueness"    => @uniqueness,
+        "relationships" => @relationships
+      }
+      options["prune evaluator"] = @prune  unless @prune.nil?
+      options["return filter"]   = @filter unless @filter.nil?
+      options["depth"]           = @depth  unless @depth.nil?
+
+      if @relationships[0]["type"].empty?
+        rels = @from.neo_server.get_node_relationships(@from, @relationships[0]["direction"]) || []
+        case @relationships[0]["direction"]
+          when "in"
+            rels.collect { |r| @from.neo_server.get_node(r["start"]) } #.uniq
+          when "out"
+            rels.collect { |r| @from.neo_server.get_node(r["end"]) } #.uniq
+          else
+            rels.collect { |r|
+            if @from.neo_id == r["start"].split('/').last
+              @from.neo_server.get_node(r["end"])
+            else
+              @from.neo_server.get_node(r["start"])
+            end
+            } #.uniq
+        end
+      else
+        @from.neo_server.traverse(@from, "nodes", options)
+      end
+    end
+
+  end
+
+end