neography-calamitates 1.2.3.1

data/examples/linkedin.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_person(name)
+  @neo.create_node("name" => name)
+end
+
+def make_mutual_friends(node1, node2)
+  @neo.create_relationship("friends", node1, node2)
+  @neo.create_relationship("friends", node2, node1)
+end
+
+def degrees_of_separation(start_node, destination_node)
+  paths =  @neo.get_paths(start_node, destination_node, {"type"=> "friends", "direction" => "in"}, depth=4, algorithm="allSimplePaths")
+  paths.each do |p|
+   p["names"] = p["nodes"].collect {|node| @neo.get_node_properties(node, "name")["name"] }
+  end
+
+end
+
+johnathan = create_person('Johnathan')
+mark      = create_person('Mark')
+phill     = create_person('Phill')
+mary      = create_person('Mary')
+
+make_mutual_friends(johnathan, mark)
+make_mutual_friends(mark, phill)
+make_mutual_friends(phill, mary)
+make_mutual_friends(mark, mary)
+
+degrees_of_separation(johnathan, mary).each do |path|
+  puts path["names"].join(' => friends => ') 
+end
+
+# RESULT
+# Johnathan => friends => Mark => friends => Phill => friends => Mary
+# Johnathan => friends => Mark => friends => Mary

data/examples/linkedin_v2.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+johnathan = Neography::Node.create("name" =>'Johnathan')
+mark      = Neography::Node.create("name" =>'Mark')
+phill     = Neography::Node.create("name" =>'Phill')
+mary      = Neography::Node.create("name" =>'Mary')
+
+johnathan.both(:friends) << mark
+mark.both(:friends) << phill
+phill.both(:friends) << mary
+mark.both(:friends) << mary
+
+johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).nodes.each do |node|
+  puts node.map{|n| n.name }.join(' => friends => ')
+end
+
+# RESULT
+# Johnathan => friends => Mark => friends => Phill => friends => Mary
+# Johnathan => friends => Mark => friends => Mary

data/examples/traversal_example1.rb

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_node(level, type)
+  @neo.create_node("NODE_LEVEL" => level, "TYPE" => type)
+end
+
+def create_other_node(type)
+  @neo.create_node("TYPE" => type)
+end
+
+
+def get_nodes_by_level(level, node)
+  starting_id = node["self"].split('/').last
+
+  @neo.traverse(node,"nodes", {"order" => "breadth first", 
+                                          "uniqueness" => "node global", 
+                                          "relationships" => {"type"=> "linked", "direction" => "out"}, 
+                                          "prune evaluator" => {
+                                            "language" => "javascript",
+                                            "body" => "position.startNode().hasProperty('NODE_LEVEL') 
+                                                    && position.startNode().getProperty('NODE_LEVEL')==5 
+                                                    && position.startNode().getId()!=#{starting_id};"},
+                                         "return filter" => {
+                                            "language" => "javascript",
+                                            "body" => "position.endNode().hasProperty('NODE_LEVEL') && position.endNode().getProperty('NODE_LEVEL')==5;"}})
+end
+
+node1 = create_node(5, "N")
+node2 = create_node(5, "N")
+node3 = create_node(5, "N")
+node4 = create_node(5, "N")
+node5 = create_node(5, "N")
+node6 = create_node(5, "N")
+node7 = create_node(5, "N")
+
+node8 = create_other_node("Y")
+node9 = create_other_node("Y")
+node10 = create_other_node("Y")
+
+node11 = create_node(6, "N")
+node12 = create_node(7, "N")
+node13 = create_node(8, "N")
+
+
+@neo.create_relationship("linked", node1, node2)
+@neo.create_relationship("linked", node2, node3)
+@neo.create_relationship("linked", node3, node4)
+@neo.create_relationship("linked", node4, node5)
+@neo.create_relationship("linked", node5, node6)
+@neo.create_relationship("linked", node6, node7)
+
+@neo.create_relationship("linked", node2, node8)
+@neo.create_relationship("linked", node3, node9)
+@neo.create_relationship("linked", node4, node10)
+
+@neo.create_relationship("linked", node5, node11)
+@neo.create_relationship("linked", node6, node12)
+@neo.create_relationship("linked", node7, node13)
+
+puts "The node levels returned are  #{get_nodes_by_level(5, node1).map{|n| n["data"]["NODE_LEVEL"]}.join(', ')}"
+
+# The node levels returned are  5, 5, 5, 5, 5, 5, 5

data/examples/traversal_example2.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_node(name, mysql_id)
+  @neo.create_node("name" => name, "mysql_id" => mysql_id)
+end
+
+def attended(student, school, degree, graduated)
+  @neo.create_relationship("attended", student, school, {"degree" => degree, "graduated" => graduated})
+end
+
+
+def graduated_with_me(student)
+  student = student["self"].split('/').last
+  student_attended = @neo.get_node_relationships(student)[0]
+  graduated = student_attended["data"]["graduated"]
+  school = student_attended["end"].split('/').last
+ 
+  @neo.traverse(school,"nodes", {"order" => "breadth first", 
+                                          "uniqueness" => "node global", 
+                                          "relationships" => {"type"=> "attended", "direction" => "in"}, 
+                                          "return filter" => {
+                                            "language" => "javascript",
+                                            "body" => "position.length() == 1  
+                                                       && position.endNode().getId() != #{student} 
+                                                       && position.lastRelationship().getProperty(\"graduated\") == #{graduated};"}})
+end
+
+charlie = create_node("Charlie", 1)
+max     = create_node("Max",     2)
+peter   = create_node("Peter",   3)
+carol   = create_node("Carol",   3)
+tom     = create_node("Tom",     4)
+jerry   = create_node("Jerry",   5)
+larry   = create_node("Larry",   6)
+
+yale    = create_node("Yale",    7)
+harvard = create_node("Harvard", 8)
+rutgers = create_node("Rutgers", 9)
+
+attended(charlie,yale,"engineering", 2010)
+attended(max,yale,"mathematics", 2005)
+attended(peter,yale,"biology", 2010)
+attended(carol,yale,"engineering", 2010)
+attended(tom,harvard,"biology", 2008)
+attended(jerry,rutgers,"physics", 2007)
+attended(larry,rutgers,"mathematics", 2010)
+
+
+puts "Charlie graduated with #{graduated_with_me(charlie).map{|n| n["data"]["name"]}.join(', ')}"
+
+# The node levels returned are Peter, Carol

data/lib/neography.rb

@@ -0,0 +1,45 @@
+require 'cgi'
+require 'httpclient'
+require 'json'
+require 'multi_json'
+require 'logger'
+require 'ostruct'
+require 'os'
+require 'zip/filesystem'
+
+require 'neography/multi_json_parser'
+
+require 'neography/version'
+
+require 'neography/config'
+
+require 'neography/rest'
+
+require 'neography/neography'
+
+require 'neography/property_container'
+require 'neography/property'
+require 'neography/node_relationship'
+require 'neography/node_path'
+require 'neography/relationship_traverser'
+require 'neography/node_traverser'
+require 'neography/path_traverser'
+require 'neography/equal'
+require 'neography/index'
+
+require 'neography/node'
+require 'neography/relationship'
+
+require 'neography/railtie' if defined? Rails::Railtie
+
+module Neography
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Config.new
+  end
+
+end

data/lib/neography/config.rb

@@ -0,0 +1,52 @@
+module Neography
+  class Config
+
+    attr_accessor :protocol, :server, :port, :directory,
+      :cypher_path, :gremlin_path,
+      :log_file, :log_enabled,
+      :max_threads,
+      :authentication, :username, :password,
+      :parser
+
+    def initialize
+      set_defaults
+    end
+
+    def to_hash
+      {
+        :protocol       => @protocol,
+        :server         => @server,
+        :port           => @port,
+        :directory      => @directory,
+        :cypher_path    => @cypher_path,
+        :gremlin_path   => @gremlin_path,
+        :log_file       => @log_file,
+        :log_enabled    => @log_enabled,
+        :max_threads    => @max_threads,
+        :authentication => @authentication,
+        :username       => @username,
+        :password       => @password,
+        :parser         => @parser
+      }
+    end
+
+    private
+
+    def set_defaults
+      @protocol       = "http://"
+      @server         = "localhost"
+      @port           = 7474
+      @directory      = ""
+      @cypher_path    = "/cypher"
+      @gremlin_path   = "/ext/GremlinPlugin/graphdb/execute_script"
+      @log_file       = "neography.log"
+      @log_enabled    = false
+      @max_threads    = 20
+      @authentication = nil
+      @username       = nil
+      @password       = nil
+      @parser         = MultiJsonParser
+    end
+
+  end
+end

data/lib/neography/connection.rb

@@ -0,0 +1,203 @@
+module Neography
+  module WasCreated
+  end
+  class Connection
+    USER_AGENT = "Neography/#{Neography::VERSION}"
+    ACTIONS = ["get", "post", "put", "delete"]
+    
+    attr_accessor :protocol, :server, :port, :directory,
+      :cypher_path, :gremlin_path,
+      :log_file, :log_enabled, :logger,
+      :max_threads,
+      :authentication, :username, :password,
+      :parser, :client
+
+    def initialize(options = ENV['NEO4J_URL'] || {})
+      config = merge_configuration(options)
+      save_local_configuration(config)
+      @client = HTTPClient.new
+      @client.send_timeout = 1200 # 10 minutes
+      @client.receive_timeout = 1200
+    end
+
+    def configure(protocol, server, port, directory)
+      @protocol = protocol
+      @server = server
+      @port = port
+      @directory = directory
+    end
+
+    def configuration
+      @configuration ||= "#{@protocol}#{@server}:#{@port}#{@directory}/db/data"
+    end
+
+    def merge_options(options)
+      merged_options = options.merge!(@authentication)
+      merged_options[:headers].merge!(@user_agent) if merged_options[:headers]
+      merged_options[:headers].merge!('X-Stream' => true) if merged_options[:headers]
+      merged_options
+    end
+
+    ACTIONS.each do |action|
+      define_method(action) do |path, options = {}|
+        authenticate(configuration + path)
+        evaluate_response(@client.send(action.to_sym, configuration + path, merge_options(options)[:body], merge_options(options)[:headers]))    
+      end 
+    end
+
+    def authenticate(path)
+      @client.set_auth(path, 
+                       @authentication[@authentication.keys.first][:username], 
+                       @authentication[@authentication.keys.first][:password]) unless @authentication.empty?
+    end
+    
+    private
+
+    def merge_configuration(options)
+      options = parse_string_options(options) unless options.is_a? Hash
+      config = Neography.configuration.to_hash
+      config.merge(options)
+    end
+
+    def save_local_configuration(config)
+      @protocol       = config[:protocol]
+      @server         = config[:server]
+      @port           = config[:port]
+      @directory      = config[:directory]
+      @cypher_path    = config[:cypher_path]
+      @gremlin_path   = config[:gremlin_path]
+      @log_file       = config[:log_file]
+      @log_enabled    = config[:log_enabled]
+      @max_threads    = config[:max_threads]
+      @parser         = config[:parser]
+
+      @user_agent     = { "User-Agent" => USER_AGENT }
+
+      @authentication = {}
+      if config[:authentication]
+        @authentication = {
+          "#{config[:authentication]}_auth".to_sym => {
+            :username => config[:username],
+            :password => config[:password]
+          }
+        }
+      end
+
+      if @log_enabled
+        @logger = Logger.new(@log_file)
+      end
+    end
+
+    def evaluate_chunk_response(response, result)
+      code = response.code
+      return_result(code, result)
+    end
+
+    def evaluate_response(response)
+      if response.http_header.request_uri.request_uri == "/db/data/batch"
+        code, body, parsed = handle_batch(response)
+      else
+        code = response.code
+        body = response.body.force_encoding("UTF-8")
+        parsed = false
+      end
+      return_result(code, body, parsed)
+    end
+
+    def handle_batch(response)
+      code = 200
+      body = @parser.json(response.body.force_encoding("UTF-8"))
+      body.each do |result|
+        if result["status"] >= 400
+          code = result["status"] 
+          break
+        end
+      end
+      return code, body, true
+    end
+    
+    def return_result(code, body, parsed)
+      case code
+      when 200
+        @logger.debug "OK, created #{body}" if @log_enabled
+        parsed ? body : @parser.json(body)
+      when 201
+        @logger.debug "OK, created #{body}" if @log_enabled
+        r = parsed ? body : @parser.json(body)
+        r.extend(WasCreated)
+        r
+      when 204
+        @logger.debug "OK, no content returned" if @log_enabled
+        nil
+      when 400..500
+        handle_4xx_500_response(code, body)
+        nil
+      end      
+    end
+
+    def handle_4xx_500_response(code, body)
+      if body.nil? or body == ""
+        parsed_body = {"message" => "No error message returned from server.",
+                       "stacktrace" => "No stacktrace returned from server." }
+      elsif body.is_a? Hash
+        parsed_body = body
+      elsif body.is_a? Array
+        body.each do |result|
+          if result["status"] >= 400
+            parsed_body = result["body"] || result
+            break
+          end
+        end        
+      else
+        parsed_body = @parser.json(body)
+      end
+
+      message = parsed_body["message"]
+      stacktrace = parsed_body["stacktrace"]
+
+      @logger.error "#{code} error: #{body}" if @log_enabled
+      raise_errors(code, parsed_body["exception"], message, stacktrace)
+    end
+    
+    def raise_errors(code, exception, message, stacktrace)
+      error = nil
+      case code
+        when 401
+          error = UnauthorizedError
+        when 409
+          error = OperationFailureException
+      end
+
+      error ||= case exception
+        when /SyntaxException/               ; SyntaxException
+        when /this is not a query/           ; SyntaxException
+        when /PropertyValueException/        ; PropertyValueException
+        when /BadInputException/             ; BadInputException
+        when /NodeNotFoundException/         ; NodeNotFoundException
+        when /NoSuchPropertyException/       ; NoSuchPropertyException
+        when /RelationshipNotFoundException/ ; RelationshipNotFoundException
+        when /NotFoundException/             ; NotFoundException
+        when /UniquePathNotUniqueException/  ; UniquePathNotUniqueException
+        else
+          NeographyError
+      end
+      
+      raise error.new(message, code, stacktrace)      
+    end
+
+    def parse_string_options(options)
+      url = URI.parse(options)
+      options = {
+        :protocol  => url.scheme + "://",
+        :server    => url.host,
+        :port      => url.port,
+        :directory => url.path,
+        :username  => url.user,
+        :password  => url.password
+      }
+      options[:authentication] = 'basic' unless url.user.nil?
+      options
+    end
+
+  end
+end