neo4j-core 3.0.0.alpha.19 → 3.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99c353a80ee0078fb684f74860c6b9adab86f81a
-  data.tar.gz: 5164eb9d290c70506f2e38c8e70952b59e058b0b
+  metadata.gz: d20898c080d0bca882d65f41646ef7e4067a5b9b
+  data.tar.gz: adc55730515f69c5b8df000ffdd661964520a1eb
 SHA512:
-  metadata.gz: ff3c176237a7fe786532cee32b922fcf6e239c9493bf3a64b0da3adf38d4e73941948cad014bcb486aab6ddfb6ece763b11cc14e65e89b354504d520d9d513bf
-  data.tar.gz: c4a5a1e0b1597f5a0f12ad4a88d8b13f730429101552a778f99583efbe3eddabec83f6964fea15193084e1da7bbc5e7839a2e9e09df2539843bc3b9d017efcac
+  metadata.gz: 45044b6d438c430d95ca67c70a2572479c2fcaaa5f4001b117f0096d2a497f119b1f9ea5212966ba4fff83266d7308d8c93aefc043a6a5eae2827e7a040fc0d1
+  data.tar.gz: c3812fad93af67cdde06336b870aa67a7de44e7052c2c24ad6e0d038ce23d788573b2791ef4cf00baf05758860bdd63811a3c3bb135e59309dde36cc2b7b0a47

data/README.md

@@ -1,458 +1,29 @@
 # Neo4j-core v3.0 [![Code Climate](https://codeclimate.com/github/andreasronge/neo4j-core.png)](https://codeclimate.com/github/andreasronge/neo4j-core) [![Build Status](https://travis-ci.org/andreasronge/neo4j-core.png)](https://travis-ci.org/andreasronge/neo4j-core)
 
-A simple Ruby wrapper around the Neo4j graph database that works with the server and embedded Neo4j API.
-This gem can be used both from JRuby and normal MRI. You may get better performance using it from JRuby and the embedded
-Neo4j, but it will probably be easier to develop (e.g. faster to run tests) on MRI and neo4j server.
-This gem is designed to work well together with the neo4j active model compliant gem (see the 3.0 branch).
+A simple Ruby wrapper around the Neo4j graph database that works with the server and embedded Neo4j API. This gem can be used both from JRuby and normal MRI.
+It can be used standalone without the neo4j gem.
 
-For the stable v2.0 version, see the v2.0 branch https://github.com/andreasronge/neo4j-core/tree/v2.x
-Do not use this gem in production.
+## Documentation
 
+* [3.0 Documentation](https://github.com/andreasronge/neo4j-core/wiki)
+* [2.x Documentation](https://github.com/andreasronge/neo4j-core/tree/v2.x)
 
-## Installation
 
-You can use this gem in two different ways:
+## Support
 
-* 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)
+* [Neo4j.rb mailing list](https://groups.google.com/forum/#!forum/neo4jrb)
+* Consulting support ? ask any of the developers
 
-### Embedded or Server Neo4j ?
+## Developers
 
-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.
+* [Andreas Ronge](https://github.com/andreasronge)
+* [Brian Underwood](https://github.com/cheerfulstoic)
+* [Chris Grigg](https://github.com/subvertallchris)
 
-### Usage from Neo4j Server
 
-You need to install the Neo4j server. This can be done by using a Rake task.
-
-
-Install the gem:
-```
-gem install neo4j-core --pre
-```
-
-Create a Rakefile with the following content:
-
-```
-require 'neo4j/tasks/neo4j_server'
-```
-
-Install and start neo4j by typing:
-```
-rake neo4j:install[community-2.1.3]
-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
-
-### API Documentation
-
-* [Neo4j::Node](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Node)
-* [Neo4j::Relationship](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Relationship)
-* [Neo4j::Session](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Session)
-* [Neo4j::Label](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Label)
-* [Neo4j::Transaction](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Transaction)
-* [Neo4j::Query](Neo4j/Query.html)
-
-See also [Neo4j Docs](http://docs.neo4j.org/)
-
-
-### 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).
-
-Using the Neo4j Server: `:server_db`
-Open a IRB/Pry session:
-
-```ruby
-  require 'neo4j-core'
-  # Using Neo4j Server Cypher Database
-  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
-  # Using Neo4j Embedded Database
-  session = Neo4j::Session.open(:embedded_db, '/folder/db', auto_commit: true)
-  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
-
-```ruby
-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:
-
-```ruby
-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`, multiple sessions are supported. They
-can be created using the open_named method. This method takes two extra parameters,
-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).
-
-```ruby
-Neo4j::Session.open_named(:server_db, :test, true, "https://localhost:7474")
-session = Neo4j::Session.named :test # Returns the session named :test.
-session = Neo4j::Session.current # Returns the session named :test, because the 'default' flag was set to true.
-```
-
-
-### Label and Index Support
-
-Create a node with an label `person` and one property
-```ruby
-Neo4j::Node.create({name: 'kalle'}, :person)
-```
-
-Add index on a label
-
-```ruby
-  person = Label.create(:person)
-  person.create_index(:name) # compound keys will be supported in Neo4j 2.1
-
-  # drop index
-  person.drop_index(:name)
-```
-
-```ruby
-  # which indexes do we have and on which properties,
-  red.indexes.each {|i| puts "Index #{i.label} properties: #{i.properties}"}
-
-  # drop index, we assume it's the first one we want
-  red.indexes.first.drop(:name)
-
-  # which indices exist ?
-  # (compound keys will be supported in Neo4j 2.1 (?))
-  red.indexes # => {:property_keys => [[:age]]}
-```
-
-Constraints
-
-Only unique constraint and single property is supported (yet).
-
-```ruby
-label = Neo4j::Label.create(:person)
-label.create_constraint(:name, type: :unique)
-label.drop_constraint(:name, type: :unique)
-```
-
-### Creating Nodes
-
-```ruby
-  # notice, label argument can be both Label objects or string/symbols.
-  node = Node.create({name: 'andreas'}, red, :green)
-  puts "Created node #{node[:name]} with labels #{node.labels.map(&:name).join(', ')}"
-```
-
-Notice, nodes will be indexed based on which labels they have.
-
-Setting properties
-
-```ruby
-  node = Node.create({name: 'andreas'}, red, :green)
-  node[:name] = 'changed name' # changes immediately one property
-  node[:name] # => 'changed name'
-  node.props # => {name: 'changed name'}
-  node.props={ foo: 42}  # replace all properties
-  node.update_props( bar: 42) # keeps old properties (unlike #props=) update with given hash
-```
-
-Notice properties are never stored in ruby objects, instead they are always fetched from the database.
-
-### Finding Nodes by Label
-
-Each node and relationship has a id, `neo_id`
-
-```ruby
-  node = Neo4j::Node.create
-  # load the node again from the database
-  node2 = Neo4j::Node.load(node.neo_id)
-```
-
-Finding nodes by label:
-
-```ruby
-  # Find nodes using an index, returns an Enumerable
-  Neo4j::Label.find_nodes(:red, :name, "andreas")
-
-  # Find all nodes for this label, returns an Enumerable
-  Neo4j::Label.find_all_nodes(:red)
-
-  # which labels does a node have ?
-  node.labels # [:red]
-```
-
-### Cypher Queries
-
-Full documentation, see [Neo4j::Session#query](http://www.rubydoc.info/github/andreasronge/neo4j-core/Neo4j/Session#query-instance_method) or RSpecs.
-
-Examples using queries as strings:
-
-```ruby
-# same as Neo4j::Session.current.query
-Neo4j::Session.query.create(n: Label: {mydata: 'Hello'}).exec
-
-# With cypher parameters
-Neo4j::Session.query.start(n: "node({a_parameter})").params(a_parameter: 0).pluck("ID(n)").first
-```
-
-Example of chained queries:
-
-```ruby
-query = Neo4j::Session.query.match(n: :person) # Returns a Query object
- 
-
-query.return(:n) # Also returns a Query object
-
-query.return(:n).to_a # Returns an array of result rows as Structs (i.e. [<struct n=Node>, etc...])
-
-query.pluck(:n) # Returns an array of nodes
-
-query.return(n: [:name, :age]) # => [<struct name='Brian', age=33>, etc...]
-
-query.where(name: /kalle.*/)
-
-query.order(n: {name: :desc, age: :asc}).skip(5).limit(4) # sorting and skip and limit the result
-
-query.match('n-[:friends]->o').where(o: {age: 42}, n: {age: 1})
-
-query.match('n-[f:friends]->o').pluck(:f) # [<Relationship>, etc..]
-
-```
-
-
-
-### Transactions
-
-By default each Neo4j operation is wrapped in an transaction.
-If you want to execute several operation in one operation you can use the `Neo4j::Transaction` class, example:
-
-```ruby
-Neo4j::Transaction.run do
-  n = Neo4j::Node.create(name: 'kalle')
-  n[:age] = 42
-end
-```
-
-Rollback occurs if an exception is thrown, or the failure method is called on the transaction.
-
-E.g.
-
-```ruby
-Neo4j::Transaction.run do |tx|
-  n = Neo4j::Node.create(name: 'kalle')
-  tx.failure # all operations inside this tx will be rollbacked
-  n[:age] = 42
-end
-
-```
-
-This feature is experimental, since it has not been tested enough.
-
-### Relationship
-
-How to create a relationship between node n1 and node n2 with one property
-
-```ruby
-n1 = Neo4j::Node.create
-n2 = Neo4j::Node.create
-rel = n1.create_rel(:knows, n2, since: 1994)
-
-# Alternative
-Neo4j::Relationship.create(:knows, n1, n2, since: 1994)
-```
-
-Setting properties on relationships works like setting properties on nodes.
-
-Finding relationships
-
-```ruby
-# any type any direction any label
-n1.rels
-
-# Outgoing of one type:
-n1.rels(dir: :outgoing, type: :know).to_a
-
-# same but expects only one relationship
-n1.rel(dir: :outgoing, type: :best_friend)
-
-# several types
-n1.rels(types: [:knows, :friend])
-
-# label
-n1.rels(label: :rich)
-
-# matching several labels
-n1.rels(labels: [:rich, :poor])
-
-# outgoing between two nodes
-n1.rels(dir: :outgoing, between: n2)
-```
-
-Returns nodes instead of relationships
-
-```ruby
-# same parameters as rels method
-n1.nodes(dir: outgoing)
-n1.node(dir: outgoing)
-```
-
-
-Delete relationship
-
-```ruby
-rel = n1.rel(:outgoing, :know) # expects only one relationship
-rel.del
-```
-
-
-
-## Implementation:
-
-All method prefixed with `_` gives direct access to the java layer/rest layer.
-Notice, the database starts with auto commit by default.
-
-No state is cached in the neo4j-core (e.g. neo4j properties).
-
-The public `Neo4j::Node` classes is abstract and provides a common API/docs for both the embedded and
-  neo4j server.
-
-The Neo4j::Embedded and Neo4j::Server modules contains drivers for classes like the `Neo4j::Node`.
-This is implemented something like this:
-
-```ruby
-  class Neo4j::Node
-    # YARD docs
-    def [](key)
-      # abstract method - impl using either HTTP or Java API
-      get_property(key,session=Neo4j::Session.current)
-    end
-
-
-    def self.create(props, session=Neo4j::Session.current)
-     session.create_node(props)
-    end
-  end
-```
-
-Both implementation use the same E2E specs.
-
-
-## Testing
-
-The testing will be using much more mocking.
-
-* The `unit` rspec folder only contains testing for one Ruby module. All other modules should be mocked.
-* The `integration` rspec folder contains testing for two or more modules but mocks the neo4j database access.
-* The `e2e` rspec folder for use the real database (or Neo4j's ImpermanentDatabase)
-* The `shared_examples` common specs for different types of databases
-
-
-## The public API
-
-* {Neo4j::Node} The Neo4j Node
-
-* {Neo4j::Relationship} The Relationship
-
-* {Neo4j::Session} The session to the embedded or server database.
-
-
-See also the cypher DSL gem, [Neo4j Wiki](https://github.com/andreasronge/neo4j/wiki/Neo4j%3A%3ACore-Cypher)
-
-## Version 3.0
-
-The neo4j-core version 3.0 uses the java Jar and/or the Neo4j Server version 2.0.0-M6+ . This mean that it should work on
-Ruby implementation and not just JRuby !
-
-It uses the new label feature in order to do mappings between `Neo4j::Node` (java objects) and your own ruby classes.
-
-The code base for the 3.0 should be smaller and simpler to maintain because there is less work to be done in the
-Ruby layer but also by removing features that are too complex or not that useful.
-
-The neo4j-wrapper source code is included in this git repo until the refactoring has stabilized.
-The old source code for neo4j-core is also included (lib.old). The old source code might later on be copied into the
- 3.0 source code (the lib folder).
-
-The neo4j-core gem will work for both the embedded Neo4j API and the server api.
-That means that neo4j.rb will work on any Ruby implementation and not just JRuby. This is under investigation !
-It's possible that some features for the Neo4j.rb 2.0 will not be available in the 3.0 version since it has to work
- with both the Neo4j server and Neo4j embedded APIs.
-
-Since neo4j-core provides one unified API to both the server end embedded neo4j database the neo4j-wrapper and neo4j
-gems will also work with server and embedded neo4j databases.
-
-New features:
-
-* neo4j-core provides the same API to both the Embedded database and the Neo4j Server
-* auto commit is each operation is now default (neo4j-core)
-
-Removed features:
-
-* auto start of the database (neo4j-core)
-* wrapping of Neo4j::Relationship java objects but there will be a work around (neo4j-wrapper)
-* traversals (the outgoing/incoming/both methods) moves to a new gem, neo4j-traversal.
-* rules will not be supported
-* versioning will not be supported, will Neo4j support it ?
-* multitenancy will not be supported, will Neo4j support it ?
-
-Changes:
-
-* `Neo4j::Node.create` now creates a node instead of `Neo4j::Node.new`
-* `Neo4j::Node#rels` different arguments, see below
-* Many Neo4j Java methods requires you to close an ResourceIterable as well as be in an transaction (even for read operations)
-In neo4j-core there are two version of these methods, one that create transaction and close the iterable for you and one raw
-where you have to do it yourself (which may give you be better performance).
-* The neo4j-core includes the neo4j-wrapper implementation.
-
-Future (when Neo4j 2.1 is released)
-* Support for fulltext search
-* Compound keys in index
+## Contributing
 
+Pull request with high test coverage and good [code climate](https://codeclimate.com/github/andreasronge/neo4j-core) values will be accepted faster.
 
 ## License
 * Neo4j.rb - MIT, see the LICENSE file http://github.com/andreasronge/neo4j-core/tree/master/LICENSE.

data/lib/neo4j-core.rb

@@ -1,8 +1,10 @@
 require 'forwardable'
 require 'fileutils'
 
+require 'neo4j-core/version'
 require 'neo4j/property_validator'
 require 'neo4j/property_container'
+require 'neo4j-core/active_entity'
 require 'neo4j-core/helpers'
 require 'neo4j-core/cypher_translator'
 require 'neo4j-core/query'
@@ -23,4 +25,7 @@ else
   # just for the tests
   module Neo4j::Embedded
   end
+
+  require 'oj'
+  require 'oj_mimic_json'
 end

data/lib/neo4j-core.rb~

@@ -0,0 +1,26 @@
+require 'forwardable'
+require 'fileutils'
+
+require 'neo4j/property_validator'
+require 'neo4j/property_container'
+require 'neo4j-core/helpers'
+require 'neo4j-core/cypher_translator'
+require 'neo4j-core/query'
+
+require 'neo4j/entity_equality'
+require 'neo4j/node'
+require 'neo4j/label'
+require 'neo4j/session'
+
+require 'neo4j/relationship'
+require 'neo4j/transaction'
+
+require 'neo4j-server'
+
+if RUBY_PLATFORM == 'java'
+  require 'neo4j-embedded'
+else
+  # just for the tests
+  module Neo4j::Embedded
+  end
+end

data/lib/neo4j-core/active_entity.rb

@@ -0,0 +1,13 @@
+module Neo4j::Core
+
+  # A module to make Neo4j::Node and Neo4j::Relationship work better together with neo4j.rb's Neo4j::ActiveNode and Neo4j::ActiveRel
+  module ActiveEntity
+    # @return true
+    def persisted?
+      true
+    end
+
+  end
+end
+
+

data/lib/neo4j-core/query.rb

@@ -1,4 +1,5 @@
 require 'neo4j-core/query_clauses'
+require 'active_support/notifications'
 
 module Neo4j::Core
   # Allows for generation of cypher queries via ruby method calls (inspired by ActiveRecord / arel syntax)
@@ -142,7 +143,11 @@ module Neo4j::Core
     end
 
     def response
-      response = @session._query(self.to_cypher, @_params)
+      return @response if @response
+      cypher = self.to_cypher
+      @response = ActiveSupport::Notifications.instrument('neo4j.cypher_query', context: @options[:context] || 'CYPHER', cypher: cypher, params: @_params) do
+        @session._query(cypher, merge_params)
+      end
       if !response.respond_to?(:error?) || !response.error?
         response
       else
@@ -183,7 +188,7 @@ module Neo4j::Core
     # @example
     #    Query.new.match(n: :Person).return(p: :name}.pluck(p: :name) # => Array of names
     # @example
-    #    Query.new.match(n: :Person).return(p: :name}.pluck('p, p.name') # => Array of [node, name] pairs
+    #    Query.new.match(n: :Person).return(p: :name}.pluck('p, DISTINCT p.name') # => Array of [node, name] pairs
     #
     def pluck(*columns)
       query = self.dup
@@ -199,6 +204,8 @@ module Neo4j::Core
 
       query = query.return(columns)
 
+      columns = query.response.columns
+
       case columns.size
       when 0
         raise ArgumentError, 'No columns specified for Query#pluck'
@@ -301,6 +308,11 @@ module Neo4j::Core
 
       partitioning
     end
+
+    def merge_params
+      @clauses.compact.inject(@_params) {|params, clause| params.merge(clause.params) }
+    end
+
   end
 end
 

data/lib/neo4j-core/query_clauses.rb

@@ -13,9 +13,12 @@ module Neo4j::Core
     class Clause
       include CypherTranslator
 
+      attr_reader :params
+
       def initialize(arg, options = {})
         @arg = arg
         @options = options
+        @params = {}
       end
 
       def value
@@ -154,27 +157,25 @@ module Neo4j::Core
     class WhereClause < Clause
       @keyword = 'WHERE'
 
-      def from_key_and_value(key, value)
+      def from_key_and_value(key, value, previous_keys = [])
         case value
         when Hash
           value.map do |k, v|
             if k.to_sym == :neo_id
-              "ID(#{key}) = #{v}"
+              "ID(#{key}) = #{v.to_i}"
             else
-              key.to_s + '.' + from_key_and_value(k, v)
+              key.to_s + '.' + from_key_and_value(k, v, previous_keys + [key])
             end
           end.join(' AND ')
-        when Array
-          "#{key} IN [#{value.join(', ')}]"
         when NilClass
           "#{key} IS NULL"
         when Regexp
           pattern = (value.casefold? ? "(?i)" : "") + value.source
           "#{key} =~ #{escape_value(pattern.gsub(/\\/, '\\\\\\'))}"
-        when /^\{[^\{\}]+\}$/
-          "#{key} = #{value}"
+        when Array
+          key_value_string(key, value, previous_keys)
         else
-          "#{key} = #{value.inspect}"
+          key_value_string(key, value, previous_keys)
         end
       end
 
@@ -183,6 +184,19 @@ module Neo4j::Core
           clauses.map(&:value).join(' AND ')
         end
       end
+
+      private
+
+      def key_value_string(key, value, previous_keys = [])
+        param = (previous_keys + [key]).join('_').gsub(/[\(\)\._]+/, '_')
+        @params = @params.merge(param.to_sym => value)
+
+        if value.is_a?(Array)
+          "#{key} IN {#{param}}"
+        else
+          "#{key} = {#{param}}"
+        end
+      end
     end
 
 
@@ -368,12 +382,12 @@ module Neo4j::Core
           "#{key} = #{value}"
         when Hash
           if @options[:set_props]
+            attribute_string = value.map {|k, v| "#{k}: #{v.inspect}" }.join(', ')
+            "#{key} = {#{attribute_string}}"
+          else
             value.map do |k, v|
               "#{key}.#{k} = #{v.inspect}"
             end
-          else
-            attribute_string = value.map {|k, v| "#{k}: #{v.inspect}" }.join(', ')
-            "#{key} = {#{attribute_string}}"
           end
         else
           raise ArgError.new(value)
@@ -392,7 +406,7 @@ module Neo4j::Core
 
       def initialize(*args)
         super
-        @options[:set_props] = true
+        @options[:set_props] = false
       end
     end
 

data/lib/neo4j-core/version.rb

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

data/lib/neo4j-core/version.rb~

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

data/lib/neo4j-embedded/embedded_node.rb

@@ -54,6 +54,7 @@ module Neo4j::Embedded
         java_clazz.class_eval do
           include Neo4j::Embedded::Property
           include Neo4j::EntityEquality
+          include Neo4j::Core::ActiveEntity
           extend Neo4j::Core::TxMethods
 
           def inspect
@@ -78,7 +79,6 @@ module Neo4j::Embedded
             Java::OrgNeo4jGraphdb.DynamicLabel.label(label_name)
           end
 
-
           def _add_label(*label_name)
             label_name.each do |name|
               addLabel(_java_label(name))

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -7,6 +7,7 @@ module Neo4j::Embedded
           include Neo4j::Embedded::Property
           include Neo4j::EntityEquality
           include Neo4j::Relationship::Wrapper
+          include Neo4j::Core::ActiveEntity
           extend Neo4j::Core::TxMethods
 
           alias_method :_other_node, :getOtherNode

data/lib/neo4j-server/cypher_node.rb

@@ -2,6 +2,7 @@ module Neo4j::Server
   class CypherNode < Neo4j::Node
     include Neo4j::Server::Resource
     include Neo4j::Core::CypherTranslator
+    include Neo4j::Core::ActiveEntity
 
     def initialize(session, value)
       @session = session

data/lib/neo4j-server/cypher_relationship.rb

@@ -3,6 +3,7 @@ module Neo4j::Server
   class CypherRelationship < Neo4j::Relationship
     include Neo4j::Server::Resource
     include Neo4j::Core::CypherTranslator
+    include Neo4j::Core::ActiveEntity
 
     attr_reader :start_node_neo_id, :end_node_neo_id
 

data/lib/neo4j-server/cypher_response.rb

@@ -59,14 +59,18 @@ module Neo4j::Server
     end
 
     def map_row_value(value, session)
-      return value unless value.is_a?(Hash)
-
-      if value['labels']
-        add_entity_id(value)
-        CypherNode.new(session, value).wrapper
-      elsif value['type']
-        add_entity_id(value)
-        CypherRelationship.new(session, value).wrapper
+      if value.is_a?(Hash)
+        if value['labels']
+          add_entity_id(value)
+          CypherNode.new(session, value).wrapper
+        elsif value['type']
+          add_entity_id(value)
+          CypherRelationship.new(session, value).wrapper
+        else
+          value
+        end
+      elsif value.is_a?(Array)
+        value.map {|v| map_row_value(v, session) }
       else
         value
       end
@@ -101,7 +105,7 @@ module Neo4j::Server
     end
 
     def add_entity_id(data)
-      data.merge!({'id' => data['self'].match(/\d+$/)[0].to_i})
+      data.merge!({'id' => data['self'].split('/')[-1].to_i})
     end
 
     def error?

data/lib/neo4j/session.rb

@@ -51,11 +51,19 @@ module Neo4j
       end
     end
 
-    # Returns a Query object.  See Neo4j::Core::Query for more details, but basic usage looks like:
+
+    # Performs a cypher query.  See {Neo4j::Core::Query} for more details, but basic usage looks like:
+    #
+    # @example Using cypher DSL
+    #   Neo4j::Session.query.match("(c:person)-[:friends]->(p:person)").where(c: {name: 'andreas'}).pluck(:p).first[:name]
+    #
+    # @example Show the generated Cypher
+    #   Neo4j::Session.query..match("(c:person)-[:friends]->(p:person)").where(c: {name: 'andreas'}).return(:p).to_cypher
     #
-    # @example
-    #   session.query.match("(c:Car)<-[:OWNS]-(p:Person)").where(c: {vin: '234UAEB3425B'}).return(:p).first[:p]
+    # @example Use Cypher string instead of the cypher DSL
+    #   Neo4j::Session.query("MATCH (c:person)-[:friends]->(p:person) WHERE c.name = \"andreas\" RETURN p").first[:p][:name]
     #
+    # @return [Neo4j::Core::Query, Enumerable] return a Query object for DSL or a Enumerable if using raw cypher strings
     # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
     #
     def query(options = {})

data/lib/neo4j/tasks/config_server.rb

@@ -0,0 +1,18 @@
+module Neo4j
+  module Tasks
+
+    module ConfigServer
+
+      def config(data, port)
+        s = set_property(data, 'org.neo4j.server.webserver.https.enabled', 'false')
+        set_property(s, 'org.neo4j.server.webserver.port', port)
+      end
+
+      def set_property(data, property, value)
+        data.gsub(/#{property}\s*=\s*(\w+)/, "#{property}=#{value}")
+      end
+
+      extend self
+    end
+  end
+end

data/lib/neo4j/tasks/neo4j_server.rb

@@ -2,6 +2,7 @@
 require 'os'
 require 'httparty'
 require 'zip'
+require File.expand_path("../config_server", __FILE__)
 
 namespace :neo4j do
 
@@ -56,18 +57,26 @@ namespace :neo4j do
     file_name
   end
 
-  desc "Install Neo4j, example neo4j:install[community,2.0.3]"
-  task :install, :edition, :version do |t, args|
-    args.with_defaults(:edition => "community")
+  def get_environment(args)
+    args[:environment] || 'development'
+  end
+
+  def install_location(args)
+    FileUtils.mkdir_p("db/neo4j")
+    "db/neo4j/#{get_environment(args)}"
+  end
 
-    file = args[:version] ? "#{args[:edition]}-#{args[:version]}" : "#{args[:edition]}"
-    puts "Installing Neo4j-#{file}"
+  desc "Install Neo4j, example neo4j:install[community-2.1.3,development]"
+  task :install, :edition, :environment do |_, args|
+    file = args[:edition]
+    environment = get_environment(args)
+    puts "Installing Neo4j-#{file} environment: #{environment}"
 
     downloaded_file = download_neo4j file
     
     if OS::Underlying.windows?
       # Extract and move to neo4j directory
-      unless File.exist?('neo4j')
+      unless File.exist?(install_location(args))
         Zip::ZipFile.open(downloaded_file) do |zip_file|
           zip_file.each do |f|
            f_path=File.join(".", f.name)
@@ -79,100 +88,126 @@ namespace :neo4j do
            end
           end
         end
-        FileUtils.mv "neo4j-#{file}", "neo4j"
+        FileUtils.mv "neo4j-#{file}", install_location(args)
         FileUtils.rm downloaded_file
      end
 
       # Install if running with Admin Privileges
-      if %x[reg query "HKU\\S-1-5-19"].size > 0 
-        %x[neo4j/bin/neo4j install]
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+        %x["#{install_location(args)}/bin/neo4j install"]
         puts "Neo4j Installed as a service."
       end
 
     else
       %x[tar -xvf #{downloaded_file}]
-      %x[mv neo4j-#{file} neo4j]
+      %x[mv neo4j-#{file} #{install_location(args)}]
       %x[rm #{downloaded_file}]
       puts "Neo4j Installed in to neo4j directory."
     end
-    puts "Type 'rake neo4j:start' to start it"
+    puts "Type 'rake neo4j:start' or 'rake neo4j:start[ENVIRONMENT]' to start it\nType 'neo4j:config[ENVIRONMENT,PORT]' for changing server port, (default 7474)"
   end
   
   desc "Start the Neo4j Server"
-  task :start do
-    puts "Starting Neo4j..."
+  task :start, :environment do |_, args|
+    puts "Starting Neo4j #{get_environment(args)}..."
     if OS::Underlying.windows? 
       if %x[reg query "HKU\\S-1-5-19"].size > 0 
-        %x[neo4j/bin/Neo4j.bat start]  #start service
+        %x[#{install_location(args)}/bin/Neo4j.bat start]  #start service
       else
         puts "Starting Neo4j directly, not as a service."
-        %x[neo4j/bin/Neo4j.bat]
+        %x[#{install_location(args)}/bin/Neo4j.bat]
       end      
     else
-      %x[neo4j/bin/neo4j start]  
+      %x[#{install_location(args)}/bin/neo4j start]
     end
   end
-  
+
+  desc "Configure Server, e.g. rake neo4j:config[development,8888]"
+  task :config, :environment, :port do |_, args|
+
+    port = args[:port]
+    raise "no port given" unless port
+    puts "Config Neo4j #{get_environment(args)} for port #{port}"
+    location = "#{install_location(args)}/conf/neo4j-server.properties"
+    text = File.read(location)
+    replace = Neo4j::Tasks::ConfigServer.config(text, port)
+    File.open(location, "w") {|file| file.puts replace}
+  end
+
   desc "Stop the Neo4j Server"
-  task :stop do
-    puts "Stopping Neo4j..."
+  task :stop, :environment do |_, args|
+    puts "Stopping Neo4j #{get_environment(args)}..."
     if OS::Underlying.windows? 
       if %x[reg query "HKU\\S-1-5-19"].size > 0
-         %x[neo4j/bin/Neo4j.bat stop]  #stop service
+         %x[#{install_location(args)}/bin/Neo4j.bat stop]  #stop service
       else
         puts "You do not have administrative rights to stop the Neo4j Service"   
       end
     else  
-      %x[neo4j/bin/neo4j stop]
+      %x[#{install_location(args)}/bin/neo4j stop]
+    end
+  end
+
+  desc "Get info the Neo4j Server"
+  task :info, :environment do |_, args|
+    puts "Info from Neo4j #{get_environment(args)}..."
+    if OS::Underlying.windows?
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+        %x[#{install_location(args)}/bin/Neo4j.bat info]  #stop service
+      else
+        puts "You do not have administrative rights to get info from the Neo4j Service"
+      end
+    else
+      puts %x[#{install_location(args)}/bin/neo4j info]
     end
   end
 
   desc "Restart the Neo4j Server"
-  task :restart do
-    puts "Restarting Neo4j..."
+  task :restart, :environment do |_, args|
+    puts "Restarting Neo4j #{get_environment(args)}..."
     if OS::Underlying.windows? 
       if %x[reg query "HKU\\S-1-5-19"].size > 0
-         %x[neo4j/bin/Neo4j.bat restart] 
+         %x[#{install_location(args)}/bin/Neo4j.bat restart]
       else
         puts "You do not have administrative rights to restart the Neo4j Service"   
       end
     else  
-      %x[neo4j/bin/neo4j restart]
+      %x[#{install_location(args)}/bin/neo4j restart]
     end
   end
 
   desc "Reset the Neo4j Server"
-  task :reset_yes_i_am_sure do
+  task :reset_yes_i_am_sure, :environment do |_, args|
     # Stop the server
     if OS::Underlying.windows? 
       if %x[reg query "HKU\\S-1-5-19"].size > 0
-         %x[neo4j/bin/Neo4j.bat stop]
+         %x[#{install_location(args)}/bin/Neo4j.bat stop]
          
         # Reset the database
-        FileUtils.rm_rf("neo4j/data/graph.db")
-        FileUtils.mkdir("neo4j/data/graph.db")
+        FileUtils.rm_rf("#{install_location(args)}/data/graph.db")
+        FileUtils.mkdir("#{install_location(args)}/data/graph.db")
         
         # Remove log files
-        FileUtils.rm_rf("neo4j/data/log")
-        FileUtils.mkdir("neo4j/data/log")
+        FileUtils.rm_rf("#{install_location(args)}/data/log")
+        FileUtils.mkdir("#{install_location(args)}/data/log")
 
-        %x[neo4j/bin/Neo4j.bat start]
+        %x[#{install_location(args)}/bin/Neo4j.bat start]
       else
         puts "You do not have administrative rights to reset the Neo4j Service"   
       end
     else  
-      %x[neo4j/bin/neo4j stop]
+      %x[#{install_location(args)}/bin/neo4j stop]
       
       # Reset the database
-      FileUtils.rm_rf("neo4j/data/graph.db")
-      FileUtils.mkdir("neo4j/data/graph.db")
+      FileUtils.rm_rf("#{install_location(args)}/data/graph.db")
+      FileUtils.mkdir("#{install_location(args)}/data/graph.db")
       
       # Remove log files
-      FileUtils.rm_rf("neo4j/data/log")
-      FileUtils.mkdir("neo4j/data/log")
+      FileUtils.rm_rf("#{install_location(args)}/data/log")
+      FileUtils.mkdir("#{install_location(args)}/data/log")
       
       # Start the server
-      %x[neo4j/bin/neo4j start]
+      %x[#{install_location(args)}/bin/neo4j start]
     end
   end
 

data/neo4j-core.gemspec

@@ -30,11 +30,15 @@ It comes included with the Apache Lucene document database.
 
   # Not released yet
   s.add_dependency("httparty")
-  s.add_dependency("json")
   s.add_dependency("os")  # for Rake task
   s.add_dependency("zip") # for Rake task
+  s.add_dependency("activesupport") # For ActiveSupport::Notifications
 
   if RUBY_PLATFORM =~ /java/
+    s.add_dependency("json")
     s.add_dependency("neo4j-community", '~> 2.1.1')
+  else
+    s.add_dependency("oj")
+    s.add_dependency("oj_mimic_json")
   end
 end

metadata

@@ -1,85 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-core
 version: !ruby/object:Gem::Version
-  version: 3.0.0.alpha.19
+  version: 3.0.0.rc.1
 platform: ruby
 authors:
 - Andreas Ronge
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: os
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: json
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: zip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: os
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: zip
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: neo4j-community
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.1
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj_mimic_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.1
-  prerelease: false
+        version: '0'
   type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   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
@@ -94,6 +108,8 @@ files:
 - Gemfile
 - README.md
 - lib/neo4j-core.rb
+- lib/neo4j-core.rb~
+- lib/neo4j-core/active_entity.rb
 - lib/neo4j-core/cypher_translator.rb
 - lib/neo4j-core/hash_with_indifferent_access.rb
 - lib/neo4j-core/helpers.rb
@@ -136,6 +152,7 @@ files:
 - lib/neo4j/relationship.rb
 - lib/neo4j/session.rb
 - lib/neo4j/session.rb~
+- lib/neo4j/tasks/config_server.rb
 - lib/neo4j/tasks/neo4j_server.rb
 - lib/neo4j/transaction.rb
 - neo4j-core.gemspec
@@ -143,31 +160,31 @@ homepage: http://github.com/andreasronge/neo4j-core/tree
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options:
-- --quiet
-- --title
+- "--quiet"
+- "--title"
 - Neo4j::Core
-- --line-numbers
-- --main
+- "--line-numbers"
+- "--main"
 - README.rdoc
-- --inline-source
+- "--inline-source"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: neo4j-core
 rubygems_version: 2.2.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: A graph database for Ruby
 test_files: []