active_node 2.0.4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: caa007d44ee08eba702076849cea0c799428c3b6
-  data.tar.gz: a5df8569e661a75c6291db2dc3803df0bcfe2f51
+  metadata.gz: 2b740f77651e77a06827ae6f01ab6a6592c3f8ad
+  data.tar.gz: 03ecfa69835cae01a75c82fb869d263020fbc5d9
 SHA512:
-  metadata.gz: 24731c0ae1f393568ac28a1c06f924105e530dcf60d82b96b56dedbab10016bd02e6c067bea482633283acb9415e5e601007e85855432fcf3a999d526c75143c
-  data.tar.gz: b3060005f8751aa730546ddf3ec72e1168b8400b8ce8eb7c72f7bc4a6ae591cc60e148ffaff508a37af58fe817d5a6ae5f581ebb2072c836082a9ec684a778b3
+  metadata.gz: 189c5d2da767a7ea045aa5973bfac329177863280490f30d8e380255c4afed57f763726845a878778f6c742931d6d0f26945d763467dd82eda5d66208608332b
+  data.tar.gz: 74300a45a8374d76f946cc77fd0f59dd606aa5b2c437053d40813bf0f6475eee9cf84a5eaf38d3eb22a43a23aea6f4f5aa04de9d91414877853cb0381a6da9cb

data/.travis.yml

@@ -1,4 +1,4 @@
-script: "bundle exec rake neo4j:install['enterprise','2.0.1'] neo4j:start spec --trace"
+script: "CODECLIMATE_REPO_TOKEN=88fa9b8eb0bfc48e8c5077253d829e94af9f76aca60df9e75ae0e50a4c7cd9f0 bundle exec rake neo4j:install['enterprise','2.0.2'] neo4j:start spec --trace"
 language: ruby
 rvm:
-  - 1.9.3
+  - 2.0.0

data/README.md

@@ -1,73 +1,107 @@
-active_node
-===========
+ActiveNode
+==========
 
-ActiveRecord style Object Graph Mapping for neo4j
+- [![Gem Version](https://badge.fury.io/rb/active_node.png)](https://rubygems.org/gems/active_node)
+- [![Build Status](https://travis-ci.org/klobuczek/active_node.png?branch=master)](https://travis-ci.org/klobuczek/active_node)
+- [![Code Climate](https://codeclimate.com/github/klobuczek/active_node.png)](https://codeclimate.com/github/klobuczek/active_node)
+- [![Coverage Status](https://coveralls.io/repos/klobuczek/active_node/badge.png?branch=master)](https://coveralls.io/r/klobuczek/active_node?branch=master)
 
 
-gem install active_node
+ActiveNode is object graph mapping layer for neo4j deployed as standalone server. It is implemented on top of [neography](http://github.com/maxdemarzi/neography) by Max De Marzi.
 
+If you use neo4j in embedded mode with JRuby please refer to the Neo4j.rb gem at https://github.com/andreasronge/neo4j by Andreas Ronge.
+
+## Installation
+
+### Gemfile
+
+Add `active_node` to your Gemfile:
 
 ```ruby
-require 'rubygems'
-require 'active_node'
-require 'neography'
-
-Neography.configure do |config|
-  config.protocol           = "http://"
-  config.server             = "localhost"
-  config.port               = 7474
-  config.directory          = ""  # prefix this path with '/'
-  config.cypher_path        = "/cypher"
-  config.gremlin_path       = "/ext/GremlinPlugin/graphdb/execute_script"
-  config.log_file           = "neography.log"
-  config.log_enabled        = false
-  config.slow_log_threshold = 0    # time in ms for query logging
-  config.max_threads        = 20
-  config.authentication     = nil  # 'basic' or 'digest'
-  config.username           = nil
-  config.password           = nil
-  config.parser             = MultiJsonParser
-  end
+gem 'active_node'
+```
 
-class NeoUser < ActiveNode::Base
-  attribute :name, type: String
-  has_many :clients
-  validates :name, presence: true
+In case of default neo4j installation no further configuration is required. Otherwise refer to https://github.com/maxdemarzi/neography for further configuration options.
 
-  def self.label
-    'User'
-  end
-end
+## Usage
 
-class Client < ActiveNode::Base
-  attribute :name, type: String
+ActiveNode is inspired by ActiveRecord, but it implements only some of its features and if necessary provides some extensions to work with a graph database.
 
-  has_many :users, direction: :incoming, class_name: 'NeoUser'
-  has_one :address
+### Creating and Retrieving Nodes
 
-  validates :name, presence: true
+```ruby
+class Client < ActiveNode::Base
 end
 
-class Address < ActiveNode::Base
-end
+client = Client.create! name: 'Abc' # Creates a neo4j node with label Client and property 'name' == 'Abc'
+client = Client.find client.id
+client[:name] # 'Abc'
+client[:name] = 'Abc Inc.'
+client.save
 
-class Person < ActiveNode::Base
-  attribute :name, type: String
-  attribute :multi
-  timestamps
+Client.all # returns array of all clients
+Client.find_by_cypher('match (c:Client) where c.name = {name}', name: 'Abc') # array of all Clients meeting given criteria
+```
 
-  has_many :people
-  has_many :children, class_name: "Person"
-  #has_many :sons, class_name: "Person"
-  has_one :father, type: :child, direction: :incoming, class_name: "Person"
-  has_one :address
+### Declared Attrribues
 
-  validates :name, uniqueness: true
+```ruby
+class Client < ActiveNode::Base
+  attribute :name, type: String #typed
+  attribute :code #untyped
+  attribute :keywords # leave array attributes untyped
+  timestamps # will automatically add and maintain created_at and updated_at
 end
 
+client.name = 'Abc'
+client.keywords = ['finance', 'investment']
 
-user = NeoUser.new(name: 'Heinrich')
-user.save
-client = Client.new(name: 'a', users: [user])
-client.save
 ```
+
+### Validation
+Validation is similar to ActiveModel e.g.
+
+```ruby
+validates :name, presence: true
+```
+ 
+### Association
+
+There are 2 types of associations: has_many and has_one. With additional options they can cover all possible relationships between nodes. 
+
+```ruby
+# label, class name, relationship type are derived from the association name, direction is by default outgoing
+has_one :user # node with label User connected with outgoing relationship of type 'user'
+has_many :users # multiple nodes with label User connected with outgoing relationship of type 'user'
+# all option customized
+has_one :father, type: :child, direction: :incoming, class_name: "Person"
+```
+
+The association declarations generate readers and writers.
+```ruby
+Client.create!(name: 'Abc', users: [User.create!, User.create!])
+Client.create!(name: 'Abc', user_id: User.create!.id)
+...
+client.user_ids = [user1.id, user2.id]
+save
+client.users # [user1, user2]
+```
+### Custom Label
+
+```ruby
+class Client < ActiveNode::Base
+  def label
+    'Company'
+  end
+end
+```
+
+Instances of Client will correspond to nodes with label Company.
+ 
+## More
+
+ActiveNode works nicely with [neography](http://github.com/maxdemarzi/neography). If at any point you need more control or want to leverage some advanced features of the neo4j REST API you can easily take advantage of the lower layer calls.
+
+Please create a  [new issue](https://github.com/klobuczek/active_node/issues) if you are missing any important feature in active_node.
+
+In case of any questions don't hesitate to contact me at heinrich@mail.com

data/active_node.gemspec

@@ -26,5 +26,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "net-http-spy", "0.2.1"
   s.add_development_dependency "rake", ">= 0.8.7"
   s.add_development_dependency "coveralls"
-
+  s.add_development_dependency "codeclimate-test-reporter"
 end

data/lib/active_node.rb

@@ -11,6 +11,7 @@ module ActiveNode
   autoload :VERSION
   autoload :Neo
   autoload :Relationship
+  autoload :Graph
 
   eager_autoload do
     autoload :ActiveNodeError, 'active_node/errors'

data/lib/active_node/associations/association.rb

@@ -17,7 +17,7 @@ module ActiveNode
     #       HasManyAssociation
     #         HasManyThroughAssociation + ThroughAssociation
     class Association #:nodoc:
-      attr_reader :owner, :target, :reflection
+      attr_reader :owner, :target, :rel_target, :reflection
 
       delegate :options, :to => :reflection
 
@@ -51,6 +51,7 @@ module ActiveNode
         @rel_target = nil
         @target = records
       end
+
       alias :super_writer :writer
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
@@ -71,7 +72,8 @@ module ActiveNode
 
 
       def rels_reader(*args)
-        @rel_target ||= rel(*args)
+        rel(*args) unless @rel_target
+        @rel_target ||= []
       end
 
       def rels_writer(rels)
@@ -83,7 +85,7 @@ module ActiveNode
       def save(fresh=false)
         #return unless @dirty
         #delete all relations missing in new target
-        original_rels = fresh ? [] : rel
+        original_rels = fresh ? [] : ActiveNode::Graph::Builder.new(owner.class, reflection.name).build(owner.id).first.association(reflection.name).rels_reader
         original_rels.each do |r|
           unless ids_reader.include? r.other.id
             Neo.db.delete_relationship(r.id)

data/lib/active_node/graph.rb

@@ -0,0 +1,7 @@
+module ActiveNode
+  module Graph
+    extend ActiveSupport::Autoload
+
+    autoload :Builder, 'active_node/graph/builder'
+  end
+end

data/lib/active_node/graph/builder.rb

@@ -0,0 +1,119 @@
+module ActiveNode
+  module Graph
+    class Builder
+      include Neography::Rest::Helpers
+
+      attr_reader :reflections, :matches, :klass
+
+      def initialize klass, *includes
+        @klass = klass if klass < ActiveNode::Base
+        @matches = []
+        @reflections =[]
+        @object_cache = {}
+        @relationship_cache = {}
+        @loaded_assoc_cache = {}
+        parse_paths(:n0, klass, includes)
+      end
+
+      def build *objects
+        ids = objects.map { |o| o.is_a?(ActiveNode::Base) ? o.id.tap { |id| @object_cache[id]=o } : o }
+        parse_results execute(ids.compact)
+        @object_cache.slice(*ids).values
+      end
+
+      private
+      def query
+        @matches.join " "
+      end
+
+      def execute(ids)
+        q="start n0=node({ids}) #{query}#{"where n0#{label @klass}" if @klass} return #{list_with_rel(@reflections.size)} order by #{created_at_list(@reflections.size)}"
+        Neo.db.execute_query(q, ids: ids)
+      end
+
+      def parse_results results
+        results['data'].each do |record|
+          wrap(record.first, @klass)
+          @reflections.each_with_index do |reflection, index|
+            node_rel = record[2*index+1]
+            node_rel = node_rel.last if node_rel.is_a? Array
+            next unless node_rel
+            owner = @object_cache[owner_id node_rel, reflection.direction]
+            node = wrap record[2*index + 2], reflection.klass
+            rel = reflection.klass.create_rel node_rel, node
+            assoc = owner.association(reflection.name)
+            assoc.rels_writer((assoc.rel_target || []) << rel) unless previously_loaded?(assoc)
+          end
+        end
+      end
+
+      def previously_loaded?(assoc)
+        @loaded_assoc_cache[assoc] = assoc.rel_target unless @loaded_assoc_cache.key? assoc
+        @loaded_assoc_cache[assoc]
+      end
+
+      def wrap(record, klass)
+        @object_cache[extract_id record] ||= ActiveNode::Base.wrap(record, klass)
+      end
+
+      def owner_id relationship, direction
+        extract_id relationship[direction == :incoming ? 'end' : 'start']
+      end
+
+      def parse_paths as, klass, includes
+        if includes.is_a?(Hash)
+          includes.each do |key, value|
+            if (value.is_a?(String) || value.is_a?(Numeric))
+              add_match(as, klass, key, value)
+            else
+              parse_paths(as, klass, key)
+              parse_paths(latest_alias, @reflections.last.klass, value)
+            end
+          end
+        elsif includes.is_a?(Array)
+          includes.each { |inc| parse_paths(as, klass, inc) }
+        else
+          add_match(as, klass, includes)
+        end
+      end
+
+      def add_match from, klass, key, multiplicity=nil
+        reflection = klass.reflect_on_association(key)
+        @reflections << reflection
+        matches << match(from, reflection, multiplicity)
+      end
+
+      def latest_alias
+        "n#{@reflections.size}"
+      end
+
+      def match(start_var, reflection, multiplicity)
+        "optional match (#{start_var})#{'<' if reflection.direction == :incoming}-[r#{@reflections.size}:#{reflection.type}#{multiplicity(multiplicity)}]-#{'>' if reflection.direction == :outgoing}(#{latest_alias}#{label reflection.klass})"
+      end
+
+      def label klass
+        ":#{klass.label}" if klass
+      end
+
+      def multiplicity multiplicity
+        multiplicity.is_a?(Numeric) ? "*1..#{multiplicity}" : multiplicity
+      end
+
+      def list_with_rel num
+        comma_sep_list(num) { |i| [("r#{i}" if i>0), "n#{i}"] }
+      end
+
+      def comma_sep_list num, &block
+        (0..num).map(&block).flatten.compact.join(', ')
+      end
+
+      def created_at_list num
+        comma_sep_list(num) { |i| "n#{i}.created_at" }
+      end
+
+      def extract_id(id)
+        get_id(id).to_i
+      end
+    end
+  end
+end

data/lib/active_node/persistence.rb

@@ -16,8 +16,8 @@ module ActiveNode
         attribute :updated_at, type: String
       end
 
-      def find ids
-        array = new_instances(Neo.db.get_nodes([ids].flatten))
+      def find ids, options={}
+        array = ActiveNode::Graph::Builder.new(self, *options[:include]).build(*ids)
         ids.is_a?(Array) ? array : array.first
       end
 
@@ -38,7 +38,11 @@ module ActiveNode
       end
 
       def wrap_rel rel, node, klass
-        ActiveNode::Relationship.new wrap(node, klass), rel['data'].merge(id: get_id(rel).to_i)
+        create_rel rel, wrap(node, klass)
+      end
+
+      def create_rel rel, node
+        ActiveNode::Relationship.new node, rel['data'].merge(id: get_id(rel).to_i)
       end
 
       def active_node_class(class_name, default_klass=nil)
@@ -126,50 +130,10 @@ module ActiveNode
     end
 
     def relationships(reflection, *associations)
-      id ?
-          Neo.db.execute_query(
-              "start n=node({id}) match #{match reflection}#{optional_match reflection, associations} return #{list_with_rel reflection.name, *associations} order by #{created_at_list reflection.name, *associations}",
-              {id: id})['data'].map { |rel_node| self.class.wrap_rel rel_node[0], rel_node[1], reflection.klass } :
-          []
+      ActiveNode::Graph::Builder.new(self.class, reflection.name => associations).build(self)
     end
 
     private
-    def parse_result klass, result, associations
-      node_map = {}
-      result.each do |record|
-        (node_map[extract_id(record[1])] ||= wrap_rel(record[0], record[1], klass))
-      end
-    end
-
-    def extract_id(id)
-      get_id(id).to_i
-    end
-
-    def match(reflection, start_var='n')
-      "(#{start_var})#{'<' if reflection.direction == :incoming}-[#{reflection.name}_rel:#{reflection.type}]-#{'>' if reflection.direction == :outgoing}(#{reflection.name}#{label reflection.klass})"
-    end
-
-    def optional_match reflection, associations
-      return if associations.empty?
-      " optional match " + comma_sep_list(associations.map { |association| match(reflection.klass.reflect_on_association(association), association) })
-    end
-
-    def label klass
-      ":#{klass.label}" if klass
-    end
-
-    def list_with_rel *names
-      comma_sep_list names.map { |name| ["#{name}_rel", name] }.flatten
-    end
-
-    def comma_sep_list *items
-      items.join(', ')
-    end
-
-    def created_at_list *names
-      comma_sep_list names.map { |name| "#{name}.created_at" }
-    end
-
     def split_hash hash, method, split_by
       hash.try(method) { |k, _| send split_by, k }
     end

data/lib/active_node/version.rb

@@ -1,3 +1,3 @@
 module ActiveNode
-  VERSION = "2.0.4"
+  VERSION = "2.1.0"
 end

data/spec/functional/base_spec.rb

@@ -16,5 +16,5 @@ describe ActiveNode::Base do
     end
   end
 
-  it_behaves_like "ActiveModel"
+  # it_behaves_like "ActiveModel"
 end

data/spec/functional/graph/builder_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ActiveNode::Graph::Builder do
+  describe "#path" do
+    it "should parse includes" do
+      ActiveNode::Graph::Builder.new(Person, :father).send(:query).should == "optional match (n0)<-[r1:child]-(n1:Person)"
+      ActiveNode::Graph::Builder.new(Person, :father, :children).send(:query).should == "optional match (n0)<-[r1:child]-(n1:Person) optional match (n0)-[r2:child]->(n2:Person)"
+      ActiveNode::Graph::Builder.new(Person, children: 2).send(:query).should == "optional match (n0)-[r1:child*1..2]->(n1:Person)"
+      ActiveNode::Graph::Builder.new(Person, {children: :address}, :address).send(:query).should == "optional match (n0)-[r1:child]->(n1:Person) optional match (n1)-[r2:address]->(n2:Address) optional match (n0)-[r3:address]->(n3:Address)"
+      ActiveNode::Graph::Builder.new(Person, children: [:address, :father]).send(:query).should == "optional match (n0)-[r1:child]->(n1:Person) optional match (n1)-[r2:address]->(n2:Address) optional match (n1)<-[r3:child]-(n3:Person)"
+      ActiveNode::Graph::Builder.new(Person, {children: 2} => [:address, :father]).send(:query).should == "optional match (n0)-[r1:child*1..2]->(n1:Person) optional match (n1)-[r2:address]->(n2:Address) optional match (n1)<-[r3:child]-(n3:Person)"
+      ActiveNode::Graph::Builder.new(Person, {children: '*'} => [:address, :father]).send(:query).should == "optional match (n0)-[r1:child*]->(n1:Person) optional match (n1)-[r2:address]->(n2:Address) optional match (n1)<-[r3:child]-(n3:Person)"
+    end
+
+    it "should build graph" do
+      person = Person.create! children: [c1=Person.create!, c2=Person.create!(address: a=Address.create!)]
+      g_person = ActiveNode::Graph::Builder.new(Person, {children: '*'} => [:address, :father]).build(person).first
+      g_person.should == person
+      g_person.object_id.should == person.object_id
+      ActiveNode::Neo.should_not_receive(:db)
+      g_person.children.last.address.should == a
+      g_person.children.first.father = person
+      g_person.children.should == [c1, c2]
+    end
+
+    it "should not query db twice" do
+      pending
+      person = Person.create!
+      ActiveNode::Graph::Builder.new(Person, :children).build(person)
+      ActiveNode::Neo.should_not_receive(:db)
+      person.children
+    end
+  end
+end

data/spec/functional/persistence_spec.rb

@@ -89,9 +89,22 @@ describe ActiveNode::Persistence do
       person = Person.create!(multi: [1, 2, 3])
       Person.find(person.id).multi.should == [1, 2, 3]
     end
+  end
+
+  describe "#find" do
+    it 'should find an object by id' do
+      person = Person.create!
+      Person.find(person.id).should == person
+    end
+
+    it 'should find objects passing multiple ids' do
+      person1 = Person.create!
+      person2 = Person.create!
+      Person.find([person1.id, person2.id]).should == [person1, person2]
+    end
 
-    it 'should find an object with id of a different model' do
-      Client.find(Person.create!.id).class.should == Person
+    it 'should find an object with id of an unknown model' do
+      ActiveNode::Base.find(Person.create!.id).class.should == Person
     end
   end
 

data/spec/functional/validations_spec.rb

@@ -22,5 +22,11 @@ describe ActiveNode::Validations do
         person.should be_valid
       end
     end
+
+    it "should validate presence on has_one" do
+      House.new.should_not be_valid
+      house = House.create! address_id: Address.create!.id
+      House.find(house.id).should be_valid
+    end
   end
 end

data/spec/models/house.rb

@@ -0,0 +1,5 @@
+class House < ActiveNode::Base
+  has_one :address
+
+  validates :address, presence: true
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
 #require 'rubygems'
 #require 'bundler/setup'
 require 'active_node'
@@ -41,8 +43,8 @@ RSpec.configure do |c|
   c.before(:each) do
     @neo=Neography::Rest.new
     @neo.execute_query("MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
-    @neo.set_node_auto_index_status(true)
-    @neo.add_node_auto_index_property('type')
+    #@neo.set_node_auto_index_status(true)
+    #@neo.add_node_auto_index_property('type')
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_node
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.0
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2014-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -122,6 +122,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ActiveRecord style Object Graph Mapping for neo4j
 email:
 - heinrich@mail.com
@@ -152,6 +166,8 @@ files:
 - lib/active_node/callbacks.rb
 - lib/active_node/core.rb
 - lib/active_node/errors.rb
+- lib/active_node/graph.rb
+- lib/active_node/graph/builder.rb
 - lib/active_node/neo.rb
 - lib/active_node/persistence.rb
 - lib/active_node/reflection.rb
@@ -161,10 +177,12 @@ files:
 - lib/active_node/version.rb
 - spec/functional/associations_spec.rb
 - spec/functional/base_spec.rb
+- spec/functional/graph/builder_spec.rb
 - spec/functional/persistence_spec.rb
 - spec/functional/validations_spec.rb
 - spec/models/address.rb
 - spec/models/client.rb
+- spec/models/house.rb
 - spec/models/neo_user.rb
 - spec/models/person.rb
 - spec/spec_helper.rb
@@ -195,10 +213,12 @@ summary: ActiveRecord style Object Graph Mapping for neo4j
 test_files:
 - spec/functional/associations_spec.rb
 - spec/functional/base_spec.rb
+- spec/functional/graph/builder_spec.rb
 - spec/functional/persistence_spec.rb
 - spec/functional/validations_spec.rb
 - spec/models/address.rb
 - spec/models/client.rb
+- spec/models/house.rb
 - spec/models/neo_user.rb
 - spec/models/person.rb
 - spec/spec_helper.rb