neo4j-core 3.0.0.alpha.10 → 3.0.0.alpha.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a84afded3b491b86251ab1b129c8722e921fd0b
-  data.tar.gz: c2db2be7dfdf1cf1dc33f5a13d43c3083b24e46d
+  metadata.gz: 4fede67cc634151503c9657840ab07e5e5784bff
+  data.tar.gz: 1557f284030e803a3eb4a24678e99d373f7fe4f5
 SHA512:
-  metadata.gz: fd6fccc4a3ba5c2980b0ed478d65d5a2389f1da43f24540fd5e823fdf91b5b7a5cd1148a6f0049b5f4c3db698617235a40ce52aea7da2d81c9e263b0b9231a76
-  data.tar.gz: 22ad54611e1d5d896f94e5d47265c08e9dd27dd26132f7e9b9262eb4097a01e2030f2ebb806636c1d6c20999d2751291225c548f54e6ad999ac989982a82532d
+  metadata.gz: ea3b1d9c597fa378ca6f6fb7c9bd3a4e63f964781839ac7bf1aa9926a7da81fd68c0e417a7d42e405631167e3092b0fa5285d1457bbd4a5cfbb09c941c70ab3f
+  data.tar.gz: ae5e4467e29dbeae65d929579d98201326e45e3d6a7691b00f5c528aae01cb4c554b65eb2ab04b2c55c1562ebb0bfdb3fbbeca49cdaddc75eb19d90bea81e1d4

data/README.md

@@ -11,9 +11,22 @@ Do not use this gem in production.
 
 ## Installation
 
+You can use this gem in two different ways:
+
+* embedded - talking directly to the database using the Neo4j Java API (only JRuby)
+* server   - talking to the Neo4j Server via HTTP (Both JRuby and MRI)
+
+### Embedded or Server Neo4j ?
+
+I suggest you start using the Neo4j server instead of Neo4j embedded because it is easier to use for development.
+If you later get performance problem (e.g. too many HTTP requests hitting the Neo4j Server)
+you can try the embedded neo4j with almost no changes in your code base.
+The embedded neo4j via JRuby also gives you direct access to the Neo4j Java API (e.g. the Neo4j Traversal API)
+which can be used to do more powerful and efficient traversals.
+
 ### Usage from Neo4j Server
 
-You need to install the Neo4j server. This can be done by included Rake file.
+You need to install the Neo4j server. This can be done by using a Rake task.
 
 
 Install the gem:
@@ -27,20 +40,22 @@ Create a Rakefile with the following content:
 require 'neo4j/tasks/neo4j_server'
 ```
 
-Install and start neo4j:
+Install and start neo4j by typing:
 ```
-rake neo4j:install[community-2.0.0]
+rake neo4j:install[community-2.0.2]
 rake neo4j:start
 ```
 
+
 ### Usage from Neo4j Embedded
 
 The Gemfile contains references to Neo4j Java libraries. Nothing is needed to be installed.
 The embedded database is only accessible from JRuby (unlike the Neo4j Server).
+No need to start the server since it is embedded.
 
 ## Neo4j-core API, v3.0
 
-### Creating a database session
+### Database Session
 
 There are currently two available types of session, one for connecting to a neo4j server
 and one for connecting to the embedded Neo4j database (which requires JRuby).
@@ -51,9 +66,22 @@ Open a IRB/Pry session:
 ```ruby
   require 'neo4j-core'
   # Using Neo4j Server Cypher Database
-  session = Neo4j::Session.open(:server_db, "http://localhost:7474")
+  session = Neo4j::Session.open(:server_db)
+```
+
+### Session Configuration
+
+Example, Basic Authentication:
+
+```ruby
+  Neo4j::Session.open(:server_db, 'http://my.server', basic_auth: { username: 'username', password: 'password'})
 ```
 
+The last option hash is passed on to HTTParty. See here for more available options:
+http://rdoc.info/github/jnunemaker/httparty/HTTParty/ClassMethods
+
+### Embedded Session
+
 Using the Neo4j Embedded Database, `:embedded_db`
 
 ```ruby
@@ -62,6 +90,15 @@ Using the Neo4j Embedded Database, `:embedded_db`
   session.start
 ```
 
+To stop the database (only supported via the embedded database) use
+```
+session.shutdown
+session.running? #=> false
+session.close # make the session not current/default
+```
+
+### Session.current
+
 When a session has been created it will be stored in the `Neo4j::Session` object.
 Example, get the default session
 
@@ -69,6 +106,8 @@ Example, get the default session
 session = Neo4j::Session.current
 ```
 
+### Multiple Sessions
+
 The default session is used by all operation unless specified as the last argument.
 For example create a node with a different session:
 
@@ -77,9 +116,9 @@ my_session = Neo4j::Session.create_session(:server_db, "http://localhost:7474")
 Neo4j::Node.create(name: 'kalle', my_session)
 ```
 
-When using the Neo4j Server: `:server_db`, mutliple sessions are supported. They
+When using the Neo4j Server: `:server_db`, multiple sessions are supported. They
 can be created using the open_named method. This method takes two extra parameters,
-the second prameter is the session name, and the third parameter is whether the new session should over-ride
+the second parameter is the session name, and the third parameter is whether the new session should over-ride
 the default session (becoming the session returned by calling `Neo4j::Session.current`).
 Valid options are true (always become current), false (never become current) and nil (become current if no
 existing current session).
@@ -291,6 +330,27 @@ session.query("START n=node({a_parameter}) RETURN ID(n)", a_parameter: 0)
 session.query(a_parameter: 0) { node("{a_parameter}").neo_id.as(:foo) }
 ```
 
+The `query` method returns an Enumeration of Hash values.
+
+Example of loading Neo4j::Nodes from a cypher query
+
+```ruby
+result = session.query("START n=node(*) RETURN ID(n)")
+nodes = result.map do |key_values|
+  # just one column is returned in this example - :'ID(n)'
+  node_id = key_values.values[0]
+  Neo4j::Node.load(node_id)
+end
+```
+
+Example, using the name of the column
+
+```ruby
+result = session.query("START n=node(0) RETURN ID(n) as mykey")
+Neo4j::Node.load(result.first[:mykey])
+```
+
+
 ## Implementation:
 
 All method prefixed with `_` gives direct access to the java layer/rest layer.

data/lib/neo4j-core/cypher_translator.rb

@@ -37,7 +37,10 @@ module Neo4j::Core
     # Cypher Helper
     def cypher_prop_list(props)
       return "" unless props
-      list = props.keys.map{|k| "#{k} : #{escape_value(props[k])}"}.join(',')
+
+      properties_to_set = props.reject {|k,v| v.nil? }
+
+      list = properties_to_set.map{|k,v| "#{k} : #{escape_value(v)}"}.join(',')
       "{#{list}}"
     end
 

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "3.0.0.alpha.10"
+    VERSION = "3.0.0.alpha.11"
   end
 end

data/lib/neo4j-server.rb

@@ -1,5 +1,6 @@
 require 'httparty'
 require 'json'
+require 'neo4j-server/neo4j_server_endpoint'
 require 'neo4j-server/resource'
 require 'neo4j-server/cypher_node'
 require 'neo4j-server/cypher_label'

data/lib/neo4j-server/cypher_session.rb

@@ -1,22 +1,38 @@
 module Neo4j::Server
 
   # Plugin
-  Neo4j::Session.register_db(:server_db) do |endpoint_url|
-    response = HTTParty.get(endpoint_url || 'http://localhost:7474')
-    raise "Server not available on #{endpoint_url} (response code #{response.code})" unless response.code == 200
-    root_data = JSON.parse(response.body)
-    data_url = root_data['data']
-    data_url << '/' unless data_url.end_with?('/') 
-    Neo4j::Server::CypherSession.new(data_url)
+  Neo4j::Session.register_db(:server_db) do |*url_opts|
+    Neo4j::Server::CypherSession.open(*url_opts)
   end
 
   class CypherSession < Neo4j::Session
     include Resource
     include Neo4j::Core::CypherTranslator
-
+    
     alias_method :super_query, :query
 
-    def initialize(data_url)
+
+    # Opens a session to the database
+    # @see Neo4j::Session#open
+    #
+    # @param url - defaults to 'http://localhost:7474' if not given
+    # @params - see https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb for supported
+    # HTTParty options
+    def self.open(endpoint_url=nil, params = {})
+      endpoint = Neo4jServerEndpoint.new(params)
+      url = endpoint_url || 'http://localhost:7474'
+      response = endpoint.get(url)
+      raise "Server not available on #{url} (response code #{response.code})" unless response.code == 200
+      
+      root_data = JSON.parse(response.body)
+      data_url = root_data['data']
+      data_url << '/' unless data_url.end_with?('/')
+
+      CypherSession.new(data_url, endpoint)
+    end
+
+    def initialize(data_url, endpoint = nil)
+      @endpoint = endpoint || Neo4jServerEndpoint.new(data_url)
       Neo4j::Session.register(self)
       initialize_resource(data_url)
       Neo4j::Session._notify_listeners(:session_available, self)
@@ -27,7 +43,7 @@ module Neo4j::Server
     end
 
     def initialize_resource(data_url)
-      response = HTTParty.get(data_url)
+      response = @endpoint.get(data_url)
       expect_response_code(response,200)
       data_resource = JSON.parse(response.body)
       raise "No data_resource for #{response.body}" unless data_resource
@@ -41,7 +57,7 @@ module Neo4j::Server
     end
 
     def begin_tx
-      Thread.current[:neo4j_curr_tx] = wrap_resource(self, 'transaction', CypherTransaction, nil, :post)
+      Thread.current[:neo4j_curr_tx] = wrap_resource(self, 'transaction', CypherTransaction, nil, :post, @endpoint)
     end
 
     def create_node(props=nil, labels=[])
@@ -78,7 +94,7 @@ module Neo4j::Server
     end
 
     def indexes(label)
-      response = HTTParty.get("#{@resource_url}schema/index/#{label}")
+      response = @endpoint.get("#{@resource_url}schema/index/#{label}")
       expect_response_code(response, 200)
       data_resource = JSON.parse(response.body)
 
@@ -135,7 +151,7 @@ module Neo4j::Server
       else
         url = resource_url('cypher')
         q = params.nil? ? {query: q} : {query: q, params: params}
-        response = HTTParty.post(url, headers: resource_headers, body: q.to_json)
+        response = @endpoint.post(url, headers: resource_headers, body: q.to_json)
         CypherResponse.create_with_no_tx(response)
       end
     end

data/lib/neo4j-server/cypher_transaction.rb

@@ -14,7 +14,8 @@ module Neo4j::Server
       end
     end
 
-    def initialize(db, response, url)
+    def initialize(db, response, url, endpoint)
+      @endpoint = endpoint
       @commit_url = response['commit']
       @exec_url = response.headers['location']
       init_resource_data(response, url)
@@ -39,7 +40,7 @@ module Neo4j::Server
           statement[:statement].gsub!("{ #{k} }", "#{escape_value(v)}")
         end
       end
-      response = HTTParty.post(@exec_url, headers: resource_headers, body: body.to_json)
+      response = @endpoint.post(@exec_url, headers: resource_headers, body: body.to_json)
 
       first_result = response['results'][0]
       cr = CypherResponse.new(response, true)
@@ -68,9 +69,9 @@ module Neo4j::Server
     def finish
       Neo4j::Transaction.unregister(self)
       if failure?
-        response = HTTParty.delete(@exec_url, headers: resource_headers)
+        response = @endpoint.delete(@exec_url, headers: resource_headers)
       else
-        response = HTTParty.post(@commit_url, headers: resource_headers)
+        response = @endpoint.post(@commit_url, headers: resource_headers)
       end
       expect_response_code(response,200)
       response

data/lib/neo4j-server/neo4j_server_endpoint.rb

@@ -0,0 +1,24 @@
+module Neo4j::Server
+  class Neo4jServerEndpoint
+    def initialize(params = {})
+      @params = params
+    end
+
+    def merged_options(options)
+      options.merge!(@params)
+    end
+
+    def get(url, options={})
+      HTTParty.get(url, merged_options(options))
+    end
+
+    def post(url, options={})
+      HTTParty.post(url, merged_options(options))
+    end
+
+    def delete(url, options={})
+      HTTParty.delete(url, merged_options(options))
+    end
+
+  end
+end

data/lib/neo4j-server/resource.rb

@@ -16,10 +16,10 @@ module Neo4j
       end
 
 
-      def wrap_resource(db, rel, resource_class, args=nil, verb=:get, payload=nil)
+      def wrap_resource(db, rel, resource_class, args=nil, verb=:get, payload=nil, endpoint)
         url = resource_url(rel, args)
-        response = HTTParty.send(verb, url, headers: {'Content-Type' => 'application/json'}, body: payload)
-        response.code == 404 ? nil : resource_class.new(db, response, url)
+        response = endpoint.send(verb, url, headers: {'Content-Type' => 'application/json'}, body: payload)
+        response.code == 404 ? nil : resource_class.new(db, response, url, endpoint)
       end
 
       def resource_url(rel=nil, args=nil)

data/lib/neo4j/session.rb

@@ -89,7 +89,8 @@ module Neo4j
     end
 
     class << self
-      # Creates a new session
+      # Creates a new session to Neo4j
+      # @see also Neo4j::Server::CypherSession#open for :server_db params
       # @param db_type the type of database, e.g. :embedded_db, or :server_db
       def open(db_type, *params)
         register(create_session(db_type, params))

data/neo4j-core.gemspec

@@ -12,7 +12,9 @@ Gem::Specification.new do |s|
   s.email    = 'andreas.ronge@gmail.com'
   s.homepage = "http://github.com/andreasronge/neo4j-core/tree"
   s.rubyforge_project = 'neo4j-core'
-  s.summary = "A graph database for JRuby"
+  s.summary = "A graph database for Ruby"
+  s.license = 'MIT'
+
   s.description = <<-EOF
 You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database.
 The programmer works with an object-oriented, flexible network structure rather than with strict and static tables

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-core
 version: !ruby/object:Gem::Version
-  version: 3.0.0.alpha.10
+  version: 3.0.0.alpha.11
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-12 00:00:00.000000000 Z
+date: 2014-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -102,6 +102,7 @@ files:
 - lib/neo4j-server/cypher_response.rb
 - lib/neo4j-server/cypher_session.rb
 - lib/neo4j-server/cypher_transaction.rb
+- lib/neo4j-server/neo4j_server_endpoint.rb
 - lib/neo4j-server/resource.rb
 - lib/neo4j/entity_equality.rb
 - lib/neo4j/label.rb
@@ -114,7 +115,8 @@ files:
 - lib/neo4j/transaction.rb
 - neo4j-core.gemspec
 homepage: http://github.com/andreasronge/neo4j-core/tree
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options:
@@ -142,6 +144,6 @@ rubyforge_project: neo4j-core
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: A graph database for JRuby
+summary: A graph database for Ruby
 test_files: []
 has_rdoc: true