activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/active_node/reflection.rb

@@ -0,0 +1,86 @@
+module Neo4j::ActiveNode
+  # A reflection contains information about an association.
+  # They are often used in connection with form builders to determine associated classes.
+  # This module contains methods related to the creation and retrieval of reflections.
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Adds methods to the class related to creating and retrieving reflections.
+    module ClassMethods
+      # @param macro [Symbol] the association type, :has_many or :has_one
+      # @param name [Symbol] the association name
+      # @param association_object [Neo4j::ActiveNode::HasN::Association] the association object created in the course of creating this reflection
+      def create_reflection(macro, name, association_object, model)
+        self.reflections = self.reflections.merge(name => AssociationReflection.new(macro, name, association_object))
+        association_object.add_destroy_callbacks(model)
+      end
+
+      private :create_reflection
+      # @param association [Symbol] an association declared on the model
+      # @return [Neo4j::ActiveNode::Reflection::AssociationReflection] of the given association
+      def reflect_on_association(association)
+        reflections[association.to_sym]
+      end
+
+      # Returns an array containing one reflection for each association declared in the model.
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+    end
+
+    # The actual reflection object that contains information about the given association.
+    # These should never need to be created manually, they will always be created by declaring a :has_many or :has_one association on a model.
+    class AssociationReflection
+      # The name of the association
+      attr_reader :name
+
+      # The type of association
+      attr_reader :macro
+
+      # The association object referenced by this reflection
+      attr_reader :association
+
+      def initialize(macro, name, association)
+        @macro        = macro
+        @name         = name
+        @association  = association
+      end
+
+      # Returns the target model
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the name of the target model
+      def class_name
+        @class_name ||= association.target_class.name
+      end
+
+      def rel_klass
+        @rel_klass ||= rel_class_name.constantize
+      end
+
+      def rel_class_name
+        @rel_class_name ||= association.relationship_class.name.to_s
+      end
+
+      def type
+        @type ||= association.relationship_type
+      end
+
+      def collection?
+        macro == :has_many
+      end
+
+      def validate?
+        true
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/rels.rb

@@ -0,0 +1,11 @@
+module Neo4j::ActiveNode
+  module Rels
+    extend Forwardable
+    def_delegators :_rels_delegator, :rel?, :rel, :rels, :node, :nodes, :create_rel
+
+    def _rels_delegator
+      fail "Can't access relationship on a non persisted node" unless _persisted_obj
+      _persisted_obj
+    end
+  end
+end

data/lib/neo4j/active_node/scope.rb

@@ -0,0 +1,166 @@
+require 'active_support/per_thread_registry'
+
+module Neo4j::ActiveNode
+  module Scope
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Similar to ActiveRecord scope
+      #
+      # @example without argument
+      #   class Person
+      #     include Neo4j::ActiveNode
+      #     property :name
+      #     property :score
+      #     has_many :out, :friends, type: :has_friend, model_class: self
+      #     scope :top_students, -> { where(score: 42)}") }
+      #   end
+      #   Person.top_students.to_a
+      #   a_person.friends.top_students.to_a
+      #   a_person.friends.friends.top_students.to_a
+      #   a_person.friends.top_students.friends.to_a
+      #
+      # @example Argument for scopes
+      #   Person.scope :level, ->(num) { where(level_num: num)}
+      #
+      # @example Argument as a cypher identifier
+      #   class Person
+      #     include Neo4j::ActiveNode
+      #     property :name
+      #     property :score
+      #     has_many :out, :friends, type: :has_friend, model_class: self
+      #     scope :great_students, ->(identifier) { where("#{identifier}.score > 41") }
+      #   end
+      #   Person.as(:all_people).great_students(:all_people).to_a
+      #
+      # @see http://guides.rubyonrails.org/active_record_querying.html#scopes
+      def scope(name, proc)
+        scopes[name.to_sym] = proc
+
+        klass = class << self; self; end
+        klass.instance_eval do
+          define_method(name) do |*query_params|
+            eval_context = ScopeEvalContext.new(self, current_scope || self.query_proxy)
+            proc = full_scopes[name.to_sym]
+            _call_scope_context(eval_context, query_params, proc)
+          end
+        end
+
+        define_method(name) do |*query_params|
+          as(:n).public_send(name, *query_params)
+        end
+      end
+
+      # rubocop:disable Naming/PredicateName
+      def has_scope?(name)
+        ActiveSupport::Deprecation.warn 'has_scope? is deprecated and may be removed from future releases, use scope? instead.', caller
+
+        scope?(name)
+      end
+      # rubocop:enable Naming/PredicateName
+
+      # @return [Boolean] true if model has access to scope with this name
+      def scope?(name)
+        full_scopes.key?(name.to_sym)
+      end
+
+      # @return [Hash] of scopes assigned to this model. Keys are scope name, value is scope callable.
+      def scopes
+        @scopes ||= {}
+      end
+
+      # @return [Hash] of scopes available to this model. Keys are scope name, value is scope callable.
+      def full_scopes
+        self.ancestors.find_all { |a| a.respond_to?(:scopes) }.reverse.inject({}) do |scopes, a|
+          scopes.merge(a.scopes)
+        end
+      end
+
+      def _call_scope_context(eval_context, query_params, proc)
+        eval_context.instance_exec(*query_params.fill(nil, query_params.length..proc.arity - 1), &proc)
+      end
+
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+      end
+
+      def current_scope=(scope) #:nodoc:
+        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+      end
+
+      def all(new_var = nil)
+        var = new_var || (current_scope ? current_scope.node_identity : :n)
+        if current_scope
+          current_scope.new_link(var)
+        else
+          self.as(var)
+        end
+      end
+    end
+
+    class ScopeEvalContext
+      def initialize(target, query_proxy)
+        @query_proxy = query_proxy
+        @target = target
+      end
+
+      def identity
+        query_proxy_or_target.identity
+      end
+
+      Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
+        define_method(method) do |*args|
+          @target.all.scoping do
+            query_proxy_or_target.public_send(method, *args)
+          end
+        end
+      end
+
+      # method_missing is not delegated to super class but to aggregated class
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(name, *params, &block)
+        query_proxy_or_target.public_send(name, *params, &block)
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      private
+
+      def query_proxy_or_target
+        @query_proxy_or_target ||= @query_proxy || @target
+      end
+    end
+
+
+    # Stolen from ActiveRecord
+    # https://github.com/rails/rails/blob/08754f12e65a9ec79633a605e986d0f1ffa4b251/activerecord/lib/active_record/scoping.rb#L57
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        return if VALID_SCOPE_TYPES.include?(scope_type)
+
+        fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/unpersisted.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module ActiveNode
+    module Unpersisted
+      # The values in this Hash are returned and used outside by reference
+      # so any modifications to the Array should be in-place
+      def deferred_create_cache
+        @deferred_create_cache ||= {}
+      end
+
+      def defer_create(association_name, object, options = {})
+        clear_deferred_nodes_for_association(association_name) if options[:clear]
+
+        deferred_nodes_for_association(association_name) << object
+      end
+
+      def deferred_nodes_for_association(association_name)
+        deferred_create_cache[association_name.to_sym] ||= []
+      end
+
+      def pending_deferred_creations?
+        !deferred_create_cache.values.all?(&:empty?)
+      end
+
+      def clear_deferred_nodes_for_association(association_name)
+        deferred_nodes_for_association(association_name.to_sym).clear
+      end
+
+      private
+
+      def process_unpersisted_nodes!
+        deferred_create_cache.dup.each do |association_name, nodes|
+          association_proxy = association_proxy(association_name)
+
+          nodes.each do |node|
+            if node.respond_to?(:changed?)
+              node.save if node.changed? || !node.persisted?
+              fail "Unable to defer node persistence, could not save #{node.inspect}" unless node.persisted?
+            end
+
+            association_proxy << node
+          end
+        end
+
+        @deferred_create_cache = {}
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/validations.rb

@@ -0,0 +1,59 @@
+module Neo4j
+  module ActiveNode
+    # This mixin replace the original save method and performs validation before the save.
+    module Validations
+      extend ActiveSupport::Concern
+      include Neo4j::Shared::Validations
+
+
+      # @return [Boolean] true if valid
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
+        errors.empty?
+      end
+
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
+        end
+      end
+
+
+      class UniquenessValidator < ::ActiveModel::EachValidator
+        def initialize(options)
+          super(options.reverse_merge(case_sensitive: true))
+        end
+
+        def validate_each(record, attribute, value)
+          return unless found(record, attribute, value).exists?
+
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value))
+        end
+
+        def found(record, attribute, value)
+          conditions = scope_conditions(record)
+
+          # TODO: Added as find(:name => nil) throws error
+          value = '' if value.nil?
+
+          conditions[attribute] = options[:case_sensitive] ? value : /#{Regexp.escape(value.to_s)}/i
+
+          found = record.class.as(:result).where(conditions)
+          found = found.where_not(neo_id: record.neo_id) if record._persisted_obj
+          found
+        end
+
+        def message(instance)
+          super || 'has already been taken'
+        end
+
+        def scope_conditions(instance)
+          Array(options[:scope] || []).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel.rb

@@ -0,0 +1,67 @@
+module Neo4j
+  # Makes Neo4j Relationships more or less act like ActiveRecord objects.
+  # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
+  module ActiveRel
+    extend ActiveSupport::Concern
+
+    MARSHAL_INSTANCE_VARIABLES = [:@attributes, :@rel_type, :@_persisted_obj]
+
+    include Neo4j::Shared
+    include Neo4j::ActiveRel::Initialize
+    include Neo4j::Shared::Identity
+    include Neo4j::Shared::Marshal
+    include Neo4j::Shared::SerializedProperties
+    include Neo4j::ActiveRel::Property
+    include Neo4j::ActiveRel::Persistence
+    include Neo4j::ActiveRel::Validations
+    include Neo4j::ActiveRel::Callbacks
+    include Neo4j::ActiveRel::Query
+    include Neo4j::ActiveRel::Types
+    include Neo4j::Shared::Enum
+    include Neo4j::Shared::PermittedAttributes
+
+    class FrozenRelError < Neo4j::Error; end
+
+    def initialize(from_node = nil, to_node = nil, args = nil)
+      load_nodes(node_or_nil(from_node), node_or_nil(to_node))
+      resolved_args = hash_or_nil(from_node, args)
+      symbol_args = sanitize_input_parameters(resolved_args)
+      super(symbol_args)
+    end
+
+    def node_cypher_representation(node)
+      node_class = node.class
+      id_name = node_class.id_property_name
+      labels = ':' + node_class.mapped_label_names.join(':')
+
+      "(#{labels} {#{id_name}: #{node.id.inspect}})"
+    end
+
+    def neo4j_obj
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
+    end
+
+    included do
+      include Neo4j::Timestamps if Neo4j::Config[:record_timestamps]
+
+      def self.inherited(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
+        super
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:active_rel, self)
+
+    private
+
+    def node_or_nil(node)
+      node.is_a?(Neo4j::ActiveNode) || node.is_a?(Integer) ? node : nil
+    end
+
+    def hash_or_nil(node_or_hash, hash_or_nil)
+      hash_or_parameter?(node_or_hash) ? node_or_hash : hash_or_nil
+    end
+  end
+end

data/lib/neo4j/active_rel/callbacks.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module ActiveRel
+    module Callbacks #:nodoc:
+      extend ActiveSupport::Concern
+      include Neo4j::Shared::Callbacks
+
+      def save(*args)
+        unless _persisted_obj || (from_node.respond_to?(:neo_id) && to_node.respond_to?(:neo_id))
+          fail Neo4j::ActiveRel::Persistence::RelInvalidError, 'from_node and to_node must be node objects'
+        end
+        super(*args)
+      end
+    end
+  end
+end