active_node 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26171a6609bb3a3042fd11f4202bb9abc700315f
-  data.tar.gz: e888b8fb7acf8cdee146d4a2aaa29052c7ce219a
+  metadata.gz: 19347532b691863f735cdb799989cf68a1bc624b
+  data.tar.gz: 71833a5ff1029940a6965c90c9f86504747f5c6a
 SHA512:
-  metadata.gz: 2ac77c3a6654c341b368fcf60c317ef04bdee15d793332373070bd08658a8daae18e719ebdb23c758f5515b7e8829e1f385a7a4cd8a7c4261c8e81621c5db932
-  data.tar.gz: 075a8582b6c6e28fd0b60483fcd141d9d680b9e34dfcc411ee528e6e7d34e1948ac1c9b0e5658ea609262b4a9633116da35ea4eb50ac6e2348b5a2704b13596a
+  metadata.gz: 9017661492388db4212a1674c9364ff182ea756f48252a8de0221e1194e0697ab2faf2964182d6f5ac310ea9deee3e4045556389ab50ecac4898747009ef301a
+  data.tar.gz: 63610493b0a11263928de9fab5bbe3f79741a82e54dd8869f87d9d733444046da275816d803d78946e6f42f7f0cafb213fcd57bc1fc6d88834cb69a75eb1e453

data/.travis.yml

@@ -1,4 +1,7 @@
-script: "CODECLIMATE_REPO_TOKEN=88fa9b8eb0bfc48e8c5077253d829e94af9f76aca60df9e75ae0e50a4c7cd9f0 bundle exec rake neo4j:install['enterprise','2.0.2'] neo4j:start spec --trace"
+script: "bundle exec rake neo4j:install['enterprise','2.0.3'] neo4j:start spec --trace"
 language: ruby
 rvm:
-  - 2.0.0
+  - 2.1.1
+addons:
+  code_climate:
+    repo_token: 88fa9b8eb0bfc48e8c5077253d829e94af9f76aca60df9e75ae0e50a4c7cd9f0

data/lib/active_node.rb

@@ -8,11 +8,17 @@ module ActiveNode
   autoload :Persistence
   autoload :Validations
   autoload :Reflection
+  autoload :Dirty
   autoload :VERSION
   autoload :Neo
   autoload :Relationship
   autoload :Graph
 
+  autoload_under 'graph' do
+    autoload :QueryMethods
+    autoload :FinderMethods
+  end
+
   eager_autoload do
     autoload :ActiveNodeError, 'active_node/errors'
     autoload :Associations

data/lib/active_node/associations/association.rb

@@ -40,9 +40,8 @@ module ActiveNode
         reflection.klass
       end
 
-
       def rel(*associations)
-        owner.relationships(reflection, *associations)
+        owner.includes!(reflection.name => associations)
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -85,7 +84,7 @@ module ActiveNode
       def save(fresh=false)
         #return unless @dirty
         #delete all relations missing in new target
-        original_rels = fresh ? [] : ActiveNode::Graph::Builder.new(owner.class, reflection.name).build(owner.id).first.association(reflection.name).rels_reader
+        original_rels = fresh ? [] : owner.class.includes(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/base.rb

@@ -3,7 +3,11 @@ require 'active_node/errors'
 
 module ActiveNode
   class Base
-    include ActiveAttr::Model
+    include ActiveAttr::BasicModel
+    include ActiveAttr::Attributes
+    include ActiveAttr::MassAssignment
+    include ActiveAttr::TypecastedAttributes
+    include Dirty
     include Persistence
     include Validations
     include Callbacks
@@ -15,4 +19,6 @@ module ActiveNode
       Class.new(super_class=self) { define_singleton_method(:label) { klass_name } }
     end
   end
+
+  ActiveSupport.run_load_hooks(:active_node, Base)
 end

data/lib/active_node/dirty.rb

@@ -0,0 +1,26 @@
+module ActiveNode
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    module ClassMethods
+      def attribute!(name, options={})
+        super(name, options)
+        define_method("#{name}=") do |value|
+          send("#{name}_will_change!") unless value == read_attribute(name)
+          super(value)
+        end
+      end
+    end
+
+    def initialize(attributes = nil, options = {})
+      super(attributes, options)
+      (@changed_attributes || {}).clear
+    end
+
+    def save(*)
+      @previously_changed = changes
+      @changed_attributes.clear
+    end
+  end
+end

data/lib/active_node/errors.rb

@@ -6,7 +6,11 @@ module ActiveNode
   class ActiveNodeError < StandardError
   end
 
-  # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
+  # Raised when Active Node cannot find record by given id or set of ids.
+  class RecordNotFound < ActiveNodeError
+  end
+
+  # Raised by ActiveNode::Base.save! and ActiveRecord::Base.create! methods when record cannot be
   # saved because record is invalid.
   class RecordNotSaved < ActiveNodeError
   end

data/lib/active_node/graph.rb

@@ -1,7 +1,216 @@
 module ActiveNode
-  module Graph
-    extend ActiveSupport::Autoload
+  class Graph
+    include Neography::Rest::Helpers
+    include FinderMethods, QueryMethods
 
-    autoload :Builder, 'active_node/graph/builder'
+    attr_reader :reflections, :matches, :klass, :loaded
+    alias :loaded? :loaded
+
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, to: :to_a
+
+    def initialize klass, *includes
+      @klass = klass if klass < ActiveNode::Base
+      @matches = []
+      @reflections =[]
+      @object_cache = {}
+      @relationship_cache = {}
+      @loaded_assoc_cache = {}
+      @where = {}
+      @includes = includes
+      @offsets = {}
+    end
+
+    def all
+      self
+    end
+
+    def count
+      to_a.count
+    end
+
+    def includes *includes
+      @includes += includes
+      self
+    end
+
+    def where hash
+      @where.merge! hash if hash
+      self
+    end
+
+    def limit count
+      @limit = count
+      self
+    end
+
+    def build *objects
+      find objects.map { |o| o.is_a?(ActiveNode::Base) ? o.id.tap { |id| @object_cache[id]=o } : extract_id(o) }
+    end
+
+    def load
+      parse_results execute unless loaded?
+      self
+    end
+
+    def to_a
+      load
+      @records
+    end
+
+    # Compares two relations for equality.
+    def ==(other)
+      case other
+        when Graph
+          other.to_cypher == to_cypher
+        when Array
+          to_a == other
+      end
+    end
+
+    def pretty_print(q)
+      q.pp(self.to_a)
+    end
+
+    # def first
+    #   limit 1
+    #   to_a.first
+    # end
+
+    def delete_all
+      Neo.db.execute_query("#{initial_match} OPTIONAL MATCH (n0)-[r]-() DELETE n0,r")
+    end
+
+    private
+    def query
+      parse_paths(:n0, @klass, @includes)
+      @matches.join ' '
+    end
+
+    def conditions
+      cond = @where.map { |key, value| "#{cond_left(key)} #{cond_operator(value)} {#{key}}" }
+      "where #{cond.join ' and '}" unless cond.empty?
+    end
+
+    def cond_left key
+      key.to_s == 'id' ? "id(n0)" : "n0.#{key}"
+    end
+
+    def cond_operator value
+      value.is_a?(Array) ? 'in' : '='
+    end
+
+    def limit_cond
+      "limit #{@limit}" if @limit
+    end
+
+    def initial_match
+      "match (n0#{label @klass})"
+    end
+
+    def execute
+      Neo.db.execute_query(to_cypher, sanitize_where)
+    end
+
+    def sanitize_where
+      @where.each { |key, value| @where[key] = extract_id(value) if key.to_s == 'id'}
+    end
+
+    def to_cypher
+      [initial_match, conditions, "with n0", limit_cond, query, 'return', list_with_rel(@reflections.size), 'order by', created_at_list(@reflections.size)].compact.join ' '
+    end
+
+    def parse_results results
+      records = Set.new
+      results['data'].each do |record|
+        records << 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
+      @loaded = true
+      @records = records.to_a
+    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)
+      case id
+        when Array
+          id.map { |i| extract_id(i) }
+        when ActiveNode::Base
+          id.id
+        else
+          get_id(id).to_i
+      end
+    end
   end
-end
+end

data/lib/active_node/graph/finder_methods.rb

@@ -0,0 +1,326 @@
+module ActiveNode
+  module FinderMethods
+    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
+    # is an integer, find by id coerces its arguments using +to_i+.
+    #
+    #   Person.find(1)          # returns the object for ID = 1
+    #   Person.find("1")        # returns the object for ID = 1
+    #   Person.find("31-sarah") # returns the object for ID = 31
+    #   Person.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
+    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17)
+    #   Person.find([1])        # returns an array for the object with ID = 1
+    #   Person.where("administrator = 1").order("created_on DESC").find(1)
+    #
+    # <tt>ActiveRecord::RecordNotFound</tt> will be raised if one or more ids are not found.
+    #
+    # NOTE: The returned records may not be in the same order as the ids you
+    # provide since database rows are unordered. You'd need to provide an explicit <tt>order</tt>
+    # option if you want the results are sorted.
+    #
+    # ==== Find with lock
+    #
+    # Example for find with a lock: Imagine two concurrent transactions:
+    # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
+    # in two saves of <tt>person.visits = 3</tt>. By locking the row, the second
+    # transaction has to wait until the first is finished; we get the
+    # expected <tt>person.visits == 4</tt>.
+    #
+    #   Person.transaction do
+    #     person = Person.lock(true).find(1)
+    #     person.visits += 1
+    #     person.save!
+    #   end
+    #
+    # ==== Variations of +find+
+    #
+    #   Person.where(name: 'Spartacus', rating: 4)
+    #   # returns a chainable list (which can be empty).
+    #
+    #   Person.find_by(name: 'Spartacus', rating: 4)
+    #   # returns the first item or nil.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).first_or_initialize
+    #   # returns the first item or returns a new instance (requires you call .save to persist against the database).
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).first_or_create
+    #   # returns the first item or creates it and returns it, available since Rails 3.2.1.
+    #
+    # ==== Alternatives for +find+
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).exists?(conditions = :none)
+    #   # returns a boolean indicating if any record with the given conditions exist.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).select("field1, field2, field3")
+    #   # returns a chainable list of instances with only the mentioned fields.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).ids
+    #   # returns an Array of ids, available since Rails 3.2.1.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).pluck(:field1, :field2)
+    #   # returns an Array of the required fields, available since Rails 3.1.
+    def find(*args)
+      if block_given?
+        to_a.find { |*block_args| yield(*block_args) }
+      else
+        find_with_ids(*args)
+      end
+    end
+
+    # Finds the first record matching the specified conditions. There
+    # is no implied ordering so if order matters, you should specify it
+    # yourself.
+    #
+    # If no record is found, returns <tt>nil</tt>.
+    #
+    #   Post.find_by name: 'Spartacus', rating: 4
+    #   Post.find_by "published_at < ?", 2.weeks.ago
+    def find_by(*args)
+      where(*args).take
+    end
+
+    # Like <tt>find_by</tt>, except that if no record is found, raises
+    # an <tt>ActiveRecord::RecordNotFound</tt> error.
+    def find_by!(*args)
+      where(*args).take!
+    end
+
+    # Gives a record (or N records if a parameter is supplied) without any implied
+    # order. The order will depend on the database implementation.
+    # If an order is supplied it will be respected.
+    #
+    #   Person.take # returns an object fetched by SELECT * FROM people LIMIT 1
+    #   Person.take(5) # returns 5 objects fetched by SELECT * FROM people LIMIT 5
+    #   Person.where(["name LIKE '%?'", name]).take
+    def take(limit = nil)
+      limit ? limit(limit).to_a : find_take
+    end
+
+    # Same as +take+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>take!</tt> accepts no arguments.
+    def take!
+      take or raise RecordNotFound
+    end
+
+    # Find the first record (or first N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).first
+    #   Person.where(["user_name = :u", { u: user_name }]).first
+    #   Person.order("created_on DESC").offset(5).first
+    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
+    #
+    # ==== Rails 3
+    #
+    #   Person.first # SELECT "people".* FROM "people" LIMIT 1
+    #
+    # NOTE: Rails 3 may not order this query by the primary key and the order
+    # will depend on the database implementation. In order to ensure that behavior,
+    # use <tt>User.order(:id).first</tt> instead.
+    #
+    # ==== Rails 4
+    #
+    #   Person.first # SELECT "people".* FROM "people" ORDER BY "people"."id" ASC LIMIT 1
+    #
+    def first(limit = nil)
+      if limit
+        find_nth_with_limit(offset_value, limit)
+      else
+        find_nth(:first, offset_value)
+      end
+    end
+
+    # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>first!</tt> accepts no arguments.
+    def first!
+      first or raise RecordNotFound
+    end
+
+    # Find the last record (or last N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.last # returns the last object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).last
+    #   Person.order("created_on DESC").offset(5).last
+    #   Person.last(3) # returns the last three objects fetched by SELECT * FROM people.
+    #
+    # Take note that in that last case, the results are sorted in ascending order:
+    #
+    #   [#<Person id:2>, #<Person id:3>, #<Person id:4>]
+    #
+    # and not:
+    #
+    #   [#<Person id:4>, #<Person id:3>, #<Person id:2>]
+    def last(limit = nil)
+      if limit
+        if order_values.empty?
+          order(id: :desc).limit(limit).reverse
+        else
+          to_a.last(limit)
+        end
+      else
+        find_last
+      end
+    end
+
+    # Same as +last+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>last!</tt> accepts no arguments.
+    def last!
+      last or raise RecordNotFound
+    end
+
+    # Returns +true+ if a record exists in the table that matches the +id+ or
+    # conditions given, or +false+ otherwise. The argument can take six forms:
+    #
+    # * Integer - Finds the record with this primary key.
+    # * String - Finds the record with a primary key corresponding to this
+    #   string (such as <tt>'5'</tt>).
+    # * Array - Finds the record that matches these +find+-style conditions
+    #   (such as <tt>['name LIKE ?', "%#{query}%"]</tt>).
+    # * Hash - Finds the record that matches these +find+-style conditions
+    #   (such as <tt>{name: 'David'}</tt>).
+    # * +false+ - Returns always +false+.
+    # * No args - Returns +false+ if the table is empty, +true+ otherwise.
+    #
+    # For more information about specifying conditions as a hash or array,
+    # see the Conditions section in the introduction to <tt>ActiveRecord::Base</tt>.
+    #
+    # Note: You can't pass in a condition as a string (like <tt>name =
+    # 'Jamie'</tt>), since it would be sanitized and then queried against
+    # the primary key column, like <tt>id = 'name = \'Jamie\''</tt>.
+    #
+    #   Person.exists?(5)
+    #   Person.exists?('5')
+    #   Person.exists?(['name LIKE ?', "%#{query}%"])
+    #   Person.exists?(id: [1, 4, 8])
+    #   Person.exists?(name: 'David')
+    #   Person.exists?(false)
+    #   Person.exists?
+    # def exists?(conditions = :none)
+    #   conditions = conditions.id if Base === conditions
+    #   return false if !conditions
+    #
+    #   relation = apply_join_dependency(self, construct_join_dependency)
+    #   return false if ActiveRecord::NullRelation === relation
+    #
+    #   relation = relation.except(:select, :order).select(ONE_AS_ONE).limit(1)
+    #
+    #   case conditions
+    #     when Array, Hash
+    #       relation = relation.where(conditions)
+    #     else
+    #       relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+    #   end
+    #
+    #   connection.select_value(relation, "#{name} Exists", relation.bind_values) ? true : false
+    # end
+
+    # This method is called whenever no records are found with either a single
+    # id or multiple ids and raises a +ActiveRecord::RecordNotFound+ exception.
+    #
+    # The error message is different depending on whether a single id or
+    # multiple ids are provided. If multiple ids are provided, then the number
+    # of results obtained should be provided in the +result_size+ argument and
+    # the expected number of results should be provided in the +expected_size+
+    # argument.
+    def raise_record_not_found_exception!(ids, result_size, expected_size) #:nodoc:
+      if Array(ids).size == 1
+        error = "Couldn't find #{@klass.name} with 'id'=#{ids}#{conditions}"
+      else
+        error = "Couldn't find all #{@klass.name.pluralize} with 'id': "
+        error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
+      end
+
+      raise RecordNotFound, error
+    end
+
+    protected
+
+    def find_with_ids(*ids)
+      expects_array = ids.first.kind_of?(Array)
+      return ids.first if expects_array && ids.first.empty?
+
+      ids = ids.flatten.compact.uniq
+
+      case ids.size
+        when 0
+          raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+        when 1
+          result = find_one(ids.first)
+          expects_array ? [result] : result
+        else
+          find_some(ids)
+      end
+    end
+
+    def find_one(id)
+      id = id.id if ActiveNode::Base === id
+
+      record = where(id: id).take
+
+      raise_record_not_found_exception!(id, 0, 1) unless record
+
+      record
+    end
+
+    def find_some(ids)
+      result = where(id: ids).to_a
+
+      expected_size =
+          if limit_value && ids.size > limit_value
+            limit_value
+          else
+            ids.size
+          end
+
+      # 11 ids with limit 3, offset 9 should give 2 results.
+      if offset_value && (ids.size - offset_value < expected_size)
+        expected_size = ids.size - offset_value
+      end
+
+      if result.size == expected_size
+        result
+      else
+        raise_record_not_found_exception!(ids, result.size, expected_size)
+      end
+    end
+
+    def find_take
+      if loaded?
+        @records.first
+      else
+        @take ||= limit(1).to_a.first
+      end
+    end
+
+    def find_nth(ordinal, offset)
+      if loaded?
+        @records.send(ordinal)
+      else
+        @offsets[offset] ||= find_nth_with_limit(offset, 1).first
+      end
+    end
+
+    def find_nth_with_limit(offset, limit)
+      if order_values.empty?
+        order(:id).limit(limit).offset(offset).to_a
+      else
+        limit(limit).offset(offset).to_a
+      end
+    end
+
+    def find_last
+      if loaded?
+        @records.last
+      else
+        @last ||=
+            if limit_value
+              to_a.last
+            else
+              reverse_order.limit(1).to_a.first
+            end
+      end
+    end
+  end
+end

data/lib/active_node/graph/query_methods.rb

@@ -0,0 +1,28 @@
+module ActiveNode
+  module QueryMethods
+    def order(*args)
+      self
+    end
+
+    def offset(value)
+      self
+    end
+
+    def reverse_order
+      self
+    end
+
+    #TODO temporary stubbing
+    def offset_value
+      0
+    end
+
+    def order_values
+      []
+    end
+
+    def limit_value
+      nil
+    end
+  end
+end

data/lib/active_node/persistence.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/hash/indifferent_access'
+require 'neography'
 
 module ActiveNode
   module Persistence
@@ -11,24 +12,17 @@ module ActiveNode
     end
 
     module ClassMethods
+      delegate :all, :first, :where, :limit, :includes, :delete_all, :build, :find, :offset, :count, :order, to: :graph
+
       def timestamps
         attribute :created_at, type: String
         attribute :updated_at, type: String
       end
 
-      def find ids, options={}
-        array = ActiveNode::Graph::Builder.new(self, *options[:include]).build(*ids)
-        ids.is_a?(Array) ? array : array.first
-      end
-
       def find_by_cypher query, params={}, klass=nil
         wrap(Neo.db.execute_query(query, params)['data'].map(&:first), klass)
       end
 
-      def all
-        new_instances(Neo.db.get_nodes_labeled(label), self)
-      end
-
       def label
         name
       end
@@ -50,6 +44,10 @@ module ActiveNode
         klass && klass < ActiveNode::Base && klass || default_klass
       end
 
+      def graph
+        ActiveNode::Graph.new(self)
+      end
+
       private
       def new_instance node, klass=nil
         (klass || find_suitable_class(Neo.db.get_node_labels(node))).try(:new, data(node), :declared?)
@@ -74,7 +72,7 @@ module ActiveNode
 
     def []=(attr, value)
       if declared? attr
-        send "#{attr}=", value
+        write_attr attr, value
       else
         @hash[attr]=value
       end
@@ -88,6 +86,10 @@ module ActiveNode
       id.to_s if persisted?
     end
 
+    def to_key
+      id
+    end
+
     def persisted?
       id.present? && !destroyed?
     end
@@ -103,6 +105,7 @@ module ActiveNode
 
     def save(*)
       create_or_update
+      super
     end
 
     alias save! save
@@ -129,8 +132,13 @@ module ActiveNode
       related(:outgoing, type, klass)
     end
 
-    def relationships(reflection, *associations)
-      ActiveNode::Graph::Builder.new(self.class, reflection.name => associations).build(self)
+    def includes!(includes)
+      new_record? ? self : self.class.includes(includes).build(self).first
+    end
+
+    def update_attributes attributes
+      attributes.each { |key, value| respond_to_writer?(attr) ? write_attr(key, value) : self[key]=value }
+      save
     end
 
     private
@@ -143,7 +151,15 @@ module ActiveNode
     end
 
     def respond_to_writer? attr
-      respond_to? "#{attr}="
+      respond_to? writer(attr)
+    end
+
+    def write_attr attr, value
+      send writer(attr), value
+    end
+
+    def writer attr
+      "#{attr}="
     end
 
     def related(direction, type, klass)

data/lib/active_node/reflection.rb

@@ -132,10 +132,6 @@ module ActiveNode
       end
 
       private
-      def derive_class_name
-        (direction == :outgoing ? type : name).to_s.camelize
-      end
-
       def derive_type
         direction == :outgoing ? name.to_s.singularize : @model.name.underscore
       end
@@ -144,22 +140,23 @@ module ActiveNode
 
     # Holds all the meta-data about an association as it was specified in the
     # Active Record class.
-    class AssociationReflection < MacroReflection #:nodoc:
-                                                  # Returns the target association's class.
-                                                  #
-                                                  #   class Author < ActiveRecord::Base
-                                                  #     has_many :books
-                                                  #   end
-                                                  #
-                                                  #   Author.reflect_on_association(:books).klass
-                                                  #   # => Book
-                                                  #
-                                                  # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
-                                                  # a new association object. Use +build_association+ or +create_association+
-                                                  # instead. This allows plugins to hook into association object creation.
-                                                  #def klass
-                                                  #  @klass ||= model.send(:compute_type, class_name)
-                                                  #end
+    class AssociationReflection < MacroReflection
+      #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      #def klass
+      #  @klass ||= model.send(:compute_type, class_name)
+      #end
 
       def initialize(*args)
         super
@@ -225,9 +222,13 @@ module ActiveNode
 
       private
       def derive_class_name
-        class_name = name.to_s.camelize
-        class_name = class_name.singularize if collection?
-        class_name
+        if direction == :outgoing
+          class_name = type.to_s
+        else
+          class_name = name.to_s
+          class_name = class_name.singularize if collection?
+        end
+        model.name.sub(/[^:]*$/, class_name.camelize)
       end
     end
 

data/lib/active_node/validations.rb

@@ -31,7 +31,7 @@ module ActiveNode
     extend ActiveSupport::Concern
     include ActiveModel::Validations
 
-    autoload :UniquenessValidator, 'active_node/validations/uniqueness_validator'
+    autoload :UniquenessValidator, 'active_node/validations/uniqueness'
 
     module ClassMethods
       # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
@@ -82,3 +82,5 @@ module ActiveNode
     end
   end
 end
+
+require "active_node/validations/uniqueness"

data/lib/active_node/validations/{uniqueness_validator.rb → uniqueness.rb}

@@ -1,6 +1,8 @@
 module ActiveNode
   module Validations
-    class UniquenessValidator < ActiveModel::EachValidator # :nodoc:
+  extend ActiveSupport::Concern
+
+  class UniquenessValidator < ActiveModel::EachValidator # :nodoc:
       def validate_each(record, attribute, value)
         if value && other_matching_records(record, attribute, value).any?
           record.errors.add(attribute, :taken, value: value)
@@ -16,5 +18,11 @@ module ActiveNode
         )
       end
     end
+
+    module ClassMethods
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
   end
 end

data/lib/active_node/version.rb

@@ -1,3 +1,3 @@
 module ActiveNode
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/spec/functional/associations_spec.rb

@@ -19,7 +19,7 @@ describe ActiveNode::Associations do
     it "can set association by id" do
       user = NeoUser.create!(name: 'Heinrich')
       client = Client.create!(name: 'a', user_ids: [user.id])
-      client.users.should == [user]
+      client.users.to_a.should == [user]
       client.user_ids.should == [user.id]
       client.users.first.clients.first.should == client
       client.user_ids = []
@@ -80,7 +80,7 @@ describe ActiveNode::Associations do
       person.people = [person]
       person.save
       person.people.first == person
-      Person.all.count.should == 1
+      Person.count.should == 1
     end
 
     it 'can handle reference to the same class' do

data/spec/functional/graph_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ActiveNode::Graph do
+  describe "#path" do
+    it "should parse includes" do
+      ActiveNode::Graph.new(Person, :father).send(:query).should == "optional match (n0)<-[r1:child]-(n1:`Person`)"
+      ActiveNode::Graph.new(Person, :father, :children).send(:query).should == "optional match (n0)<-[r1:child]-(n1:`Person`) optional match (n0)-[r2:child]->(n2:`Person`)"
+      ActiveNode::Graph.new(Person, children: 2).send(:query).should == "optional match (n0)-[r1:child*1..2]->(n1:`Person`)"
+      ActiveNode::Graph.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.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.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.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 = person.includes!({children: '*'} => [:address, :father])
+      g_person = ActiveNode::Graph.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!
+      person.includes! :children
+      ActiveNode::Neo.should_not_receive(:db)
+      person.children
+    end
+  end
+end

data/spec/functional/persistence_spec.rb

@@ -31,21 +31,21 @@ describe ActiveNode::Persistence do
 
     it 'should destroy node' do
       user = NeoUser.create!(name: 'abc')
-      NeoUser.all.count.should == 1
+      NeoUser.count.should == 1
       user.destroy.should be_true
-      NeoUser.all.count.should == 0
+      NeoUser.count.should == 0
     end
 
     it 'should not destroy node with relationships' do
       person = Person.create! children: [Person.create!, Person.create!]
       person.destroy.should be_false
-      Person.all.count.should == 3
+      Person.count.should == 3
     end
 
     it 'should destroy! node with relationships' do
       person = Person.create! children: [Person.create!, Person.create!]
       person.destroy!.should be_true
-      Person.all.count.should == 2
+      Person.count.should == 2
     end
 
     it 'should record timestamp' do
@@ -100,7 +100,7 @@ describe ActiveNode::Persistence do
     it 'should find objects passing multiple ids' do
       person1 = Person.create!
       person2 = Person.create!
-      Person.find([person1.id, person2.id]).should == [person1, person2]
+      Person.find([person1.id, person2.id]).to_a.should == [person1, person2]
     end
 
     it 'should find an object with id of an unknown model' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_node
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-15 00:00:00.000000000 Z
+date: 2014-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -165,19 +165,21 @@ files:
 - lib/active_node/base.rb
 - lib/active_node/callbacks.rb
 - lib/active_node/core.rb
+- lib/active_node/dirty.rb
 - lib/active_node/errors.rb
 - lib/active_node/graph.rb
-- lib/active_node/graph/builder.rb
+- lib/active_node/graph/finder_methods.rb
+- lib/active_node/graph/query_methods.rb
 - lib/active_node/neo.rb
 - lib/active_node/persistence.rb
 - lib/active_node/reflection.rb
 - lib/active_node/relationship.rb
 - lib/active_node/validations.rb
-- lib/active_node/validations/uniqueness_validator.rb
+- lib/active_node/validations/uniqueness.rb
 - lib/active_node/version.rb
 - spec/functional/associations_spec.rb
 - spec/functional/base_spec.rb
-- spec/functional/graph/builder_spec.rb
+- spec/functional/graph_spec.rb
 - spec/functional/persistence_spec.rb
 - spec/functional/validations_spec.rb
 - spec/models/address.rb
@@ -213,7 +215,7 @@ 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/graph_spec.rb
 - spec/functional/persistence_spec.rb
 - spec/functional/validations_spec.rb
 - spec/models/address.rb

data/lib/active_node/graph/builder.rb

@@ -1,119 +0,0 @@
-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 } : extract_id(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/spec/functional/graph/builder_spec.rb

@@ -1,34 +0,0 @@
-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