neography-down 1.6.4

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 'excon'
+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,64 @@
+module Neography
+  class Config
+
+    attr_accessor :protocol, :server, :port, :directory,
+      :cypher_path, :gremlin_path,
+      :log_file, :log_enabled, :logger, :slow_log_threshold,
+      :max_threads,
+      :authentication, :username, :password,
+      :parser, :max_execution_time,
+      :proxy, :http_send_timeout, :http_receive_timeout
+
+    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,
+        :logger                => @logger,
+        :slow_log_threshold    => @slow_log_threshold,
+        :max_threads           => @max_threads,
+        :authentication        => @authentication,
+        :username              => @username,
+        :password              => @password,
+        :parser                => @parser,
+        :max_execution_time    => @max_execution_time,
+        :proxy                 => @proxy,
+        :http_send_timeout     => @http_send_timeout,
+        :http_receive_timeout  => @http_receive_timeout
+      }
+    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
+      @slow_log_threshold   = 0
+      @max_threads          = 20
+      @authentication       = nil
+      @username             = nil
+      @password             = nil
+      @parser               = MultiJsonParser
+      @max_execution_time   = 6000
+      @proxy                = nil
+      @http_send_timeout    = 1200
+      @http_receive_timeout = 1200
+      end
+
+  end
+end

data/lib/neography/connection.rb

@@ -0,0 +1,263 @@
+module Neography
+  module WasCreated
+  end
+  class Connection
+    USER_AGENT = "Neography/#{Neography::VERSION}"
+    ACTIONS = ["get", "post", "put", "delete"]
+
+    attr_reader :protocol, :server, :port, :directory,
+      :cypher_path, :gremlin_path,
+      :log_file, :log_enabled, :logger, :slow_log_threshold,
+      :max_threads,
+      :authentication, :username, :password,
+      :parser, :client,
+      :proxy, :http_send_timeout, :http_receive_timeout
+
+    def initialize(options = ENV['NEO4J_URL'] || {})
+      config = merge_configuration(options)
+      save_local_configuration(config)
+      @client ||= Excon.new(config[:proxy] || "#{@protocol}#{@server}:#{@port}", 
+                            :read_timeout => config[:http_receive_timeout],
+                            :write_timeout => config[:http_send_timeout],
+                            :persistent => true,
+                            :user =>  config[:username],
+                            :password => config[:password])
+      #authenticate
+    end
+
+    def configure(protocol, server, port, directory)
+      @protocol = protocol
+      @server = server
+      @port = port
+      @directory = directory
+    end
+
+    def configuration
+      @configuration ||= "#{@protocol}#{@server}:#{@port}#{@directory}"
+    end
+
+    def merge_options(options)
+      merged_options = options.merge!(@authentication)
+      if merged_options[:headers]
+        merged_options[:headers].merge!(@user_agent)
+        merged_options[:headers].merge!('X-Stream' => true) unless merged_options[:headers].key?('X-Stream')
+        merged_options[:headers].merge!(@max_execution_time)
+      end
+      merged_options
+    end
+
+    ACTIONS.each do |action|
+      define_method(action) do |path, options = {}|
+        # This ugly hack is required because internal Batch paths do not start with "/db/data"
+        # if somebody has a cleaner solution... pull request please!
+        partial_path = path.split("/") 
+        if partial_path.size > 0
+          partial_path = partial_path[1].split("?").first
+        end
+        reserved = ["node", "relationship", "transaction", "cypher", "propertykeys", "schema", "label", "labels", "batch", "index", "ext"]
+        path = "/db/data" + path if reserved.include?(partial_path)
+        query_body = options[:body]
+        stream = ""
+        headers = merge_options(options)[:headers]
+        log path, query_body do
+          req_params = {:method => action.to_sym, :path => path, :body => query_body, :headers => headers}
+          is_streaming = headers && (headers['X-Stream'] == true)
+          if is_streaming
+            streamer = lambda { |chunk, _, _| stream += chunk }
+            req_params.merge!({:persistent => false, :response_block => streamer,
+                               :read_timeout => 100000000, :write_timeout => 100000000})
+          end
+          response = @client.request(req_params)
+          evaluate_response(response, path, query_body, is_streaming, (partial_path == "batch"), stream)
+        end
+      end
+    end
+
+    def log(path, body)
+      if @log_enabled
+        start_time = Time.now
+        response = yield
+        time = ((Time.now - start_time) * 1000).round(2)
+        @logger.info "[Neography::Query] #{path} #{body} [#{time}ms]" if time >= slow_log_threshold
+        response
+      else
+        yield
+      end
+    end
+
+    def authenticate(path = nil)
+      unless @authentication.empty?
+        auth_type = @authentication.keys.first
+        @client.set_auth(
+          path,
+          @authentication[auth_type][:username],
+          @authentication[auth_type][:password]
+        )
+        # Force http client to always send auth credentials without
+        # waiting for WWW-Authenticate headers, thus saving one request
+        # roundtrip for each URI. Only works for HTTP basic auth.
+        @client.www_auth.basic_auth.challenge(configuration) if auth_type == 'basic_auth'
+      end
+    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]
+      @slow_log_threshold = config[:slow_log_threshold]
+      @max_threads        = config[:max_threads]
+      @parser             = config[:parser]
+      @logger             = config[:logger]
+      @proxy              = config[:proxy]
+
+      @max_execution_time = { 'max-execution-time' => config[:max_execution_time] }
+      @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, path, query_body, streaming, batching, stream = nil)
+      code = response.status
+      parsed = false
+      if streaming && batching
+        code, body, parsed = handle_batch(stream)
+      elsif streaming
+        body = (stream || '').force_encoding("UTF-8")
+      else
+        body = response.body.force_encoding("UTF-8")
+      end
+      return_result(response, code, body, parsed, path, query_body)
+    end
+
+    def handle_batch(stream)
+      code = 200
+      body = @parser.json(stream.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(response, code, body, parsed, path, query_body)
+      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(response, code, body, path, query_body)
+        nil
+      end
+    end
+
+    def handle_4xx_500_response(response, code, body, path, query_body)
+      index = 0
+      request = {:path => path, :body => query_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_with_index do |result, idx|
+          if result["status"] >= 400
+            index = idx
+            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 "#{response.dump} error: #{body}" if @log_enabled
+      raise_errors(code, parsed_body["exception"], message, stacktrace, request, index)
+    end
+
+    def raise_errors(code, exception, message, stacktrace, request, index)
+      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 /ParameterNotFoundException/    ; ParameterNotFoundException
+        when /NotFoundException/             ; NotFoundException
+        when /UniquePathNotUniqueException/  ; UniquePathNotUniqueException
+        when /DeadlockDetectedException/     ; DeadlockDetectedException
+        else
+          NeographyError
+      end
+
+      raise error.new(message, code, stacktrace, request, index)
+    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