active_node 0.0.2.alpha

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.iml
+.idea/*
+neo4j

data/.travis.yml

@@ -0,0 +1,4 @@
+script: "bundle exec rake neo4j:install['enterprise','2.0.0-M03'] neo4j:start spec --trace"
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in active_node.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Heinrich Klobuczek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+require 'neography/tasks'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--color"
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+desc "Run Tests"
+task :default => :spec

data/active_node.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_node/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_node"
+  s.version     = ActiveNode::VERSION
+  s.authors     = ["Heinrich Klobuczek"]
+  s.email       = ["heinrich@mail.com"]
+  s.homepage    = ""
+  s.summary     = "ActiveRecord style Object Graph Mapping for neo4j"
+  s.description = "ActiveRecord style Object Graph Mapping for neo4j"
+
+  s.rubyforge_project = "active_node"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "active_attr"
+  s.add_dependency "neography"
+  s.add_dependency "activesupport"
+  s.add_dependency "activemodel"
+  s.add_development_dependency "rspec", ">= 2.11"
+  s.add_development_dependency "net-http-spy", "0.2.1"
+  #s.add_development_dependency "rake", ">= 0.8.7"
+  s.add_development_dependency "coveralls"
+
+end

data/lib/active_node/associations/association.rb

@@ -0,0 +1,44 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveNode
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+
+      delegate :options, :to => :reflection
+
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+
+        reset
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+        @stale_state = nil
+      end
+
+      # Returns the class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+    end
+  end
+end

data/lib/active_node/associations/builder/association.rb

@@ -0,0 +1,70 @@
+module ActiveNode::Associations::Builder
+  class Association #:nodoc:
+    class << self
+      attr_accessor :valid_options
+    end
+
+    self.valid_options = [:class_name]
+
+    attr_reader :model, :name, :options, :reflection
+
+    def self.build(*args)
+      new(*args).build
+    end
+
+    def initialize(model, name, options)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      @model   = model
+      @name    = name
+      @options = options
+    end
+
+    def mixin
+      @model
+    end
+
+    include Module.new { def build; end }
+
+    def build
+      validate_options
+      define_accessors
+      @reflection = model.create_reflection(macro, name, options, model)
+      super # provides an extension point
+      @reflection
+    end
+
+    def macro
+      raise NotImplementedError
+    end
+
+    def valid_options
+      Association.valid_options
+    end
+
+    def validate_options
+      options.assert_valid_keys(valid_options)
+    end
+
+    def define_accessors
+      define_readers
+      define_writers
+    end
+
+    def define_readers
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          association(:#{name}).reader(*args)
+        end
+      CODE
+    end
+
+    def define_writers
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
+        end
+      CODE
+    end
+  end
+end

data/lib/active_node/associations/builder/collection_association.rb

@@ -0,0 +1,25 @@
+require 'active_node/associations'
+
+module ActiveNode::Associations::Builder
+  class CollectionAssociation < Association #:nodoc:
+    def define_readers
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
+
+    def define_writers
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+      CODE
+    end
+  end
+end

data/lib/active_node/associations/builder/has_many.rb

@@ -0,0 +1,11 @@
+module ActiveNode::Associations::Builder
+  class HasMany < CollectionAssociation #:nodoc:
+    def macro
+      :has_many
+    end
+
+    def valid_options
+      super + [:direction, :type]
+    end
+  end
+end

data/lib/active_node/associations/collection_association.rb

@@ -0,0 +1,73 @@
+module ActiveNode
+  module Associations
+    # = Active Record Association Collection
+    #
+    # CollectionAssociation is an abstract class that provides common stuff to
+    # ease the implementation of association proxies that represent
+    # collections. See the class hierarchy in AssociationProxy.
+    #
+    #   CollectionAssociation:
+    #     HasAndBelongsToManyAssociation => has_and_belongs_to_many
+    #     HasManyAssociation => has_many
+    #       HasManyThroughAssociation + ThroughAssociation => has_many :through
+    #
+    # CollectionAssociation class provides common methods to the collections
+    # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
+    # +:through association+ option.
+    #
+    # You need to be careful with assumptions regarding the target: The proxy
+    # does not fetch records from the database until it needs them, but new
+    # ones created with +build+ are added to the target. So, the target may be
+    # non-empty and still lack children waiting to be read from the database.
+    # If you look directly to the database you cannot assume that's the entire
+    # collection because new records may have been added to the target, etc.
+    #
+    # If you need to work on all current children, new and existing records,
+    # +load_target+ and the +loaded+ flag are your friends.
+    class CollectionAssociation < Association #:nodoc:
+
+      # Implements the reader method, e.g. foo.items for Foo.has_many :items
+      def reader(force_reload = false)
+        @target ||= load_target
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(records)
+        @dirty = true
+        @target = records
+      end
+
+      # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
+      def ids_reader
+        reader.map(&:id)
+      end
+
+      # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
+      def ids_writer(ids)
+        writer klass.find(ids.reject(&:blank?).map!(&:to_i))
+      end
+
+      def load_target
+        owner.send(reflection.direction, reflection.type, reflection.klass)
+      end
+
+      def save
+        return unless @dirty
+        #delete all relations missing in new target
+        owner.node.rels(reflection.type).send(reflection.direction).each do |rel|
+          rel.del unless ids_reader.include? rel.other_node(owner.node).neo_id.to_i
+        end
+        original_target = owner.node.send(reflection.direction, reflection.type)
+        original_target_ids = original_target.map(&:neo_id).map(&:to_i)
+        #add relations missing in old target
+        @target.each { |n| original_target << n.node unless original_target_ids.include? n.id }
+      end
+
+      def reset
+        super
+        @target = owner.new_record? ? [] : nil
+        @dirty = false
+      end
+    end
+  end
+end

data/lib/active_node/associations/has_many_association.rb

@@ -0,0 +1,11 @@
+module ActiveNode
+  # = Active Record Has Many Association
+  module Associations
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+    end
+  end
+end

data/lib/active_node/associations.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/module/remove_method'
+
+module ActiveNode
+  module Associations # :nodoc:
+    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
+
+    autoload :Association,           'active_node/associations/association'
+    autoload :CollectionAssociation, 'active_node/associations/collection_association'
+    autoload :HasManyAssociation,              'active_node/associations/has_many_association'
+
+    module Builder #:nodoc:
+      autoload :Association,           'active_node/associations/builder/association'
+      autoload :CollectionAssociation, 'active_node/associations/builder/collection_association'
+
+      autoload :HasMany,             'active_node/associations/builder/has_many'
+    end
+
+
+    # Clears out the association cache.
+    def clear_association_cache #:nodoc:
+      @association_cache.clear if persisted?
+    end
+
+    # :nodoc:
+    attr_reader :association_cache
+
+    # Returns the association instance for the given name, instantiating it if it doesn't already exist
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        reflection  = self.class.reflect_on_association(name)
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    private
+      # Returns the specified association instance if it responds to :loaded?, nil otherwise.
+      def association_instance_get(name)
+        @association_cache[name.to_sym]
+      end
+
+      # Set the specified association instance.
+      def association_instance_set(name, association)
+        @association_cache[name] = association
+      end
+
+    module ClassMethods
+      def has_many(name, options = {})
+        Builder::HasMany.build(self, name, options)
+      end
+    end
+  end
+end

data/lib/active_node/base.rb

@@ -0,0 +1,14 @@
+require 'active_attr'
+require 'active_node/errors'
+
+module ActiveNode
+  class Base
+    include ActiveAttr::Model
+    include Persistence
+    include Validations
+    include Callbacks
+    include Associations
+    include Reflection
+    include Core
+  end
+end

data/lib/active_node/callbacks.rb

@@ -0,0 +1,45 @@
+module ActiveNode
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :after_initialize, :after_find, :after_touch, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
+    ]
+
+    module ClassMethods
+      include ActiveModel::Callbacks
+    end
+
+    included do
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :touch, :only => :after
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+
+    def destroy include_relationships=false
+      run_callbacks(:destroy) { super include_relationships }
+    end
+
+    def touch(*) #:nodoc:
+      run_callbacks(:touch) { super }
+    end
+
+  private
+
+    def create_or_update #:nodoc:
+      run_callbacks(:save) { super }
+    end
+
+    def create_record #:nodoc:
+      run_callbacks(:create) { super }
+    end
+
+    def update_record(*) #:nodoc:
+      run_callbacks(:update) { super }
+    end
+  end
+end

data/lib/active_node/core.rb

@@ -0,0 +1,10 @@
+module ActiveNode
+  module Core
+    extend ActiveSupport::Concern
+
+    def initialize(attributes = nil)
+      @association_cache = {}
+      super attributes
+    end
+  end
+end

data/lib/active_node/errors.rb

@@ -0,0 +1,13 @@
+module ActiveNode
+
+  # = Active Node Errors
+  #
+  # Generic Active Node exception class.
+  class ActiveNodeError < StandardError
+  end
+
+  # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
+  # saved because record is invalid.
+  class RecordNotSaved < ActiveNodeError
+  end
+end

data/lib/active_node/persistence.rb

@@ -0,0 +1,106 @@
+module ActiveNode
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def find ids
+        ids.is_a?(Enumerable) ? ids.map { |id| find(id) } : new_instance(Neography::Node.load(ids))
+      end
+
+      def all
+        result = Neography::Node.find(:node_auto_index, :type, type)
+        (result.is_a?(Enumerable) ? result : [result]).map { |node| new_instance(node) }.compact
+      end
+
+      def type
+        name.underscore
+      end
+
+      def wrap node, klass=nil
+        node.is_a?(Enumerable) ?
+            node.map { |n| wrap(n, klass) } :
+            node.is_a?(Neography::Node) && (active_node_class(node.type.camelize, klass)).try(:new, node) || node
+      end
+
+      def active_node_class(class_name, default_klass=nil)
+        klass = Module.const_get(class_name) rescue nil
+        klass && klass < ActiveNode::Base && klass || default_klass
+      end
+
+      private
+      def new_instance node
+        node && new(node)
+      end
+    end
+
+    attr_reader :node
+    #protected :node
+
+    delegate :neo_id, to: :node, allow_nil: true
+    def id
+      neo_id && neo_id.to_i
+    end
+
+    alias :to_param :id
+    alias :persisted? :id
+    alias :[] :send
+
+    def initialize hash={}
+      @node, hash = hash, hash.send(:table) if hash.is_a? Neography::Node
+      super hash
+    end
+
+    def new_record?
+      !id
+    end
+
+    def save(*)
+      create_or_update
+    end
+
+    alias save! save
+
+    def destroy include_relationships=false
+      destroyable = destroy_associations include_relationships
+      node.del if destroyable
+      @destroyed = destroyable
+    end
+
+    def destroy!
+      destroy true
+    end
+
+    def incoming(types=nil, klass=nil)
+      node && self.class.wrap(node.incoming(types), klass)
+    end
+
+    def outgoing(types=nil, klass=nil)
+      node && self.class.wrap(node.outgoing(types), klass)
+    end
+
+    private
+    def destroy_associations include_associations
+      rels = node.rels
+      return false unless rels.empty? || include_associations
+      rels.each { |rel| rel.del }
+      true
+    end
+
+    def nullify_blanks! attrs
+      attrs.each { |k, v| attrs[k]=nil if attrs[k].blank? }
+    end
+
+    def create_or_update
+      write; true
+      association_cache.values.each &:save
+    end
+
+    def write
+      if @node
+        nullify_blanks!(attributes).each { |k, v| @node[k]=v }
+      else
+        @node = Neography::Node.create nullify_blanks!(attributes).merge(type: self.class.type)
+      end
+    end
+  end
+end

data/lib/active_node/reflection.rb

@@ -0,0 +1,235 @@
+module ActiveNode
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      def create_reflection(macro, name, options, model)
+        case macro
+        when :has_many, :has_one
+          klass = options[:through] ? ThroughReflection : AssociationReflection
+          reflection = klass.new(macro, name, options, model)
+        end
+
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.grep(AssociationReflection)
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflection = reflections[association]
+        reflection if reflection.is_a?(AssociationReflection)
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+
+    # Base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    #
+    #   MacroReflection
+    #     AggregateReflection
+    #     AssociationReflection
+    #       ThroughReflection
+    class MacroReflection
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      attr_reader :scope
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      attr_reader :model
+
+
+      def initialize(macro, name, options, model)
+        @macro         = macro
+        @name          = name
+        @options       = options
+        @model = model
+      end
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      def direction
+        @direction ||= (options[:direction] || :outgoing)
+      end
+
+      def type
+        @type ||= (options[:type] || name.to_s.singularize)
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +model+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        super ||
+          other_aggregation.kind_of?(self.class) &&
+          name == other_aggregation.name &&
+          other_aggregation.options &&
+          model == other_aggregation.model
+      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+
+    # 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
+
+      def initialize(*args)
+        super
+        @collection = [:has_many].include?(macro)
+      end
+
+      # Returns a new, unsaved instance of the associated class. +attributes+ will
+      # be passed to the class's constructor.
+      def build_association(attributes, &block)
+        klass.new(attributes, &block)
+      end
+
+      def through_reflection
+        nil
+      end
+
+      def source_reflection
+        nil
+      end
+
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def chain
+        [self]
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>validate: false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      def association_class
+        case macro
+        when :has_many
+          if options[:through]
+            Associations::HasManyThroughAssociation
+          else
+            Associations::HasManyAssociation
+          end
+        when :has_one
+          if options[:through]
+            Associations::HasOneThroughAssociation
+          else
+            Associations::HasOneAssociation
+          end
+        end
+      end
+
+      private
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
+        end
+    end
+
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
+    class ThroughReflection < AssociationReflection #:nodoc:
+    end
+  end
+end

data/lib/active_node/validations.rb

@@ -0,0 +1,81 @@
+module ActiveNode
+  # = Active Node RecordInvalid
+  #
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
+  # +record+ method to retrieve the record which did not validate.
+  #
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  class RecordInvalid < ActiveNodeError
+    attr_reader :record # :nodoc:
+    def initialize(record) # :nodoc:
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid"))
+    end
+  end
+
+  # = Active Node Validations
+  #
+  # Active Node includes the majority of its validations from <tt>ActiveModel::Validations</tt>
+  # all of which accept the <tt>:on</tt> argument to define the context where the
+  # validations are active. Active Node will always supply either the context of
+  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # <tt>new_record?</tt>.
+
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+      # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes)
+          yield(object) if block_given?
+          object.save!
+          object
+        end
+      end
+    end
+
+    # The validation process on save can be skipped by passing <tt>validate: false</tt>.
+    # The regular Base#save method is replaced with this when the validations
+    # module is mixed in, which it is by default.
+    def save(options={})
+      perform_validations(options) ? super : false
+    end
+
+    # Attempts to save the record just like Base#save but will raise a +RecordInvalid+
+    # exception instead of returning +false+ if the record is not valid.
+    def save!(options={})
+      perform_validations(options) ? super : raise(RecordInvalid.new(self))
+    end
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, +false+ otherwise.
+    #
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    protected
+
+    def perform_validations(options={}) # :nodoc:
+      options[:validate] == false || valid?(options[:context])
+    end
+  end
+end

data/lib/active_node/version.rb

@@ -0,0 +1,3 @@
+module ActiveNode
+  VERSION = "0.0.2.alpha"
+end

data/lib/active_node.rb

@@ -0,0 +1,17 @@
+require "active_support/dependencies/autoload"
+
+module ActiveNode
+  extend ActiveSupport::Autoload
+  autoload :Base
+  autoload :Callbacks
+  autoload :Core
+  autoload :Persistence
+  autoload :Validations
+  autoload :Reflection
+  autoload :VERSION
+
+  eager_autoload do
+    autoload :ActiveNodeError, 'active_node/errors'
+    autoload :Associations
+  end
+end

data/spec/functional/associations_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe ActiveNode::Associations do
+  describe "#save" do
+    it "should have empty association" do
+      client = Client.new(name: 'a')
+      client.save
+      client.users.should be_empty
+    end
+
+    it "should not have empty association" do
+      user = NeoUser.new(name: 'Heinrich')
+      user.save
+      client = Client.new(name: 'a', users: [user])
+      client.save
+      client.users.should == [user]
+    end
+
+    it "can set association by id" do
+      user = NeoUser.new(name: 'Heinrich')
+      user.save
+      client = Client.new(name: 'a', user_ids: [user.id])
+      client.save
+      client.users.should == [user]
+      client.user_ids.should == [user.id]
+      client.users.first.clients.first.should == client
+    end
+
+    it "can remove associated objects" do
+      user = NeoUser.new(name: 'Heinrich')
+      user.save
+      client = Client.new(name: 'a', user_ids: [user.id])
+      client.save
+      client.user_ids = []
+      client.save
+      client.users.should be_empty
+      client.user_ids.should be_empty
+    end
+
+    it "can remove some of the associated objects" do
+      child1 = Person.create!
+      child2 = Person.create!
+      person = Person.create! child_ids: [child1.id, child2.id]
+      person = Person.find(person.id)
+      person.children.count.should == 2
+      person.child_ids = [child2.id]
+      person.save
+      Person.find(person.id).children.should == [child2]
+    end
+
+    it "can remove and add some of the associated objects" do
+      child1 = Person.create!
+      child2 = Person.create!
+      person = Person.create! child_ids: [child1.id, child2.id]
+      person = Person.find(person.id)
+      person.children.count.should == 2
+      child3 = Person.create!
+      person.child_ids = [child2.id, child3.id]
+      person.save
+      Person.find(person.id).children.should == [child2, child3]
+    end
+
+    it 'can handle self referencing' do
+      person = Person.new
+      person.save
+      person.people = [person]
+      person.save
+      person.people.first == person
+      Person.all.count.should == 1
+    end
+
+    it 'can handle reference to the same class' do
+      id = Person.create!(children: [Person.create!, Person.create!]).id
+      Person.find(id).children.size.should == 2
+    end
+  end
+end

data/spec/functional/persistence_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe ActiveNode::Persistence do
+  describe "#save" do
+    it "should save not conventionally named object" do
+      NeoUser.new(name: 'Heinrich').save.should be_true
+      NeoUser.all.map(&:name).should == ['Heinrich']
+    end
+
+    it 'should destroy node' do
+      user = NeoUser.create!(name: 'abc')
+      NeoUser.all.count.should == 1
+      user.destroy.should be_true
+      NeoUser.all.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
+    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
+    end
+  end
+end

data/spec/functional/validations_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ActiveNode::Validations do
+  describe "#save" do
+    it "should not save invalid object" do
+      Client.new.save.should be_false
+    end
+
+    it "should save invalid object" do
+      Client.new(name: 'abc7').save.should be_true
+      Client.all.first.name.should == 'abc7'
+    end
+  end
+end

data/spec/models/client.rb

@@ -0,0 +1,8 @@
+class Client < ActiveNode::Base
+  attribute :name, type: String
+
+  #has_many :phases
+  has_many :users, type: :client, direction: :incoming, class_name: 'NeoUser'
+
+  validates :name, presence: true
+end

data/spec/models/neo_user.rb

@@ -0,0 +1,9 @@
+class NeoUser < ActiveNode::Base
+  attribute :name, type: String
+  has_many :clients
+  validates :name, presence: true
+
+  def self.type
+    'user'
+  end
+end

data/spec/models/person.rb

@@ -0,0 +1,5 @@
+class Person < ActiveNode::Base
+  has_many :people
+  has_many :children, class_name: "Person"
+  #has_one :father, type: :child, direction: :incoming, class_name: "Person"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,67 @@
+#require 'rubygems'
+#require 'bundler/setup'
+require 'active_node'
+#
+#require "active_node/version"
+#require "active_model/version"
+#require 'active_support'
+#require 'active_model/validator'
+#require 'active_model/validations'
+#require 'active_model'
+#require 'active_attr'
+require 'neography'
+require 'benchmark'
+#require 'matchers'
+require 'coveralls'
+Coveralls.wear!
+
+# If you want to see more, uncomment the next few lines
+# require 'net-http-spy'
+# Net::HTTP.http_logger_options = {:body => true}    # just the body
+# Net::HTTP.http_logger_options = {:verbose => true} # see everything
+
+Dir[File.dirname(__FILE__) + '/models/*.rb'].each {|file| require file }
+
+def generate_text(length=8)
+  chars = 'abcdefghjkmnpqrstuvwxyz'
+  key = ''
+  length.times { |i| key << chars[rand(chars.length)] }
+  key
+end
+
+RSpec.configure do |c|
+  c.filter_run_excluding :slow => true, :gremlin => true
+  #c.around(:each) do
+  #  Neography::Rest.new.execute_query("START n0=node(0),nx=node(*) MATCH n0-[r0?]-(),nx-[rx?]-() WHERE nx <> n0 DELETE r0,rx,nx")
+  #end
+  c.before(:each) do
+    @neo=Neography::Rest.new
+    @neo.execute_query("START n0=node(0),nx=node(*) MATCH n0-[r0?]-(),nx-[rx?]-() WHERE nx <> n0 DELETE r0,rx,nx")
+    @neo.set_node_auto_index_status(true)
+    @neo.add_node_auto_index_property('type')
+  end
+end
+
+
+def json_content_type
+  {"Content-Type"=>"application/json"}
+end
+
+def error_response(attributes)
+  request_uri = double()
+  request_uri.stub(:request_uri).and_return("")
+  
+  http_header = double()
+  http_header.stub(:request_uri).and_return(request_uri)
+  
+  stub(
+    http_header: http_header,
+    code: attributes[:code],
+    body: {
+    message:   attributes[:message],
+    exception: attributes[:exception],
+    stacktrace: attributes[:stacktrace]
+  }.reject { |k,v| v.nil? }.to_json
+  )
+end
+

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: active_node
+version: !ruby/object:Gem::Version
+  version: 0.0.2.alpha
+  prerelease: 6
+platform: ruby
+authors:
+- Heinrich Klobuczek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: neography
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: net-http-spy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActiveRecord style Object Graph Mapping for neo4j
+email:
+- heinrich@mail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- Rakefile
+- active_node.gemspec
+- lib/active_node.rb
+- lib/active_node/associations.rb
+- lib/active_node/associations/association.rb
+- lib/active_node/associations/builder/association.rb
+- lib/active_node/associations/builder/collection_association.rb
+- lib/active_node/associations/builder/has_many.rb
+- lib/active_node/associations/collection_association.rb
+- lib/active_node/associations/has_many_association.rb
+- lib/active_node/base.rb
+- lib/active_node/callbacks.rb
+- lib/active_node/core.rb
+- lib/active_node/errors.rb
+- lib/active_node/persistence.rb
+- lib/active_node/reflection.rb
+- lib/active_node/validations.rb
+- lib/active_node/version.rb
+- spec/functional/associations_spec.rb
+- spec/functional/persistence_spec.rb
+- spec/functional/validations_spec.rb
+- spec/models/client.rb
+- spec/models/neo_user.rb
+- spec/models/person.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: active_node
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: ActiveRecord style Object Graph Mapping for neo4j
+test_files:
+- spec/functional/associations_spec.rb
+- spec/functional/persistence_spec.rb
+- spec/functional/validations_spec.rb
+- spec/models/client.rb
+- spec/models/neo_user.rb
+- spec/models/person.rb
+- spec/spec_helper.rb