neo4j_legacy 7.2.0.1

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,146 @@
+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 = nil, _ = nil|
+            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
+      end
+
+      # rubocop:disable Style/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 Style/PredicateName
+
+      def scope?(name)
+        full_scopes.key?(name.to_sym)
+      end
+
+      def scopes
+        @scopes ||= {}
+      end
+
+      def full_scopes
+        scopes.merge(self.superclass.respond_to?(:scopes) ? self.superclass.scopes : {})
+      end
+
+      def _call_scope_context(eval_context, query_params, proc)
+        if proc.arity == 1
+          eval_context.instance_exec(query_params, &proc)
+        else
+          eval_context.instance_exec(&proc)
+        end
+      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
+
+      Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
+        module_eval(%{
+            def #{method}(params={})
+              @target.all.scoping do
+                (@query_proxy || @target).#{method}(params)
+              end
+            end}, __FILE__, __LINE__)
+      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.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_node.rb

@@ -0,0 +1,105 @@
+module Neo4j
+  # Makes Neo4j nodes and relationships behave like ActiveRecord objects.
+  # By including this module in your class it will create a mapping for the node to your ruby class
+  # by using a Neo4j Label with the same name as the class. When the node is loaded from the database it
+  # will check if there is a ruby class for the labels it has.
+  # If there Ruby class with the same name as the label then the Neo4j node will be wrapped
+  # in a new object of that class.
+  #
+  # = ClassMethods
+  # * {Neo4j::ActiveNode::Labels::ClassMethods} defines methods like: <tt>index</tt> and <tt>find</tt>
+  # * {Neo4j::ActiveNode::Persistence::ClassMethods} defines methods like: <tt>create</tt> and <tt>create!</tt>
+  # * {Neo4j::ActiveNode::Property::ClassMethods} defines methods like: <tt>property</tt>.
+  #
+  # @example Create a Ruby wrapper for a Neo4j Node
+  #   class Company
+  #      include Neo4j::ActiveNode
+  #      property :name
+  #   end
+  #   company = Company.new
+  #   company.name = 'My Company AB'
+  #   Company.save
+  #
+  module ActiveNode
+    extend ActiveSupport::Concern
+
+    MARSHAL_INSTANCE_VARIABLES = [:@attributes, :@_persisted_obj, :@default_property_value]
+
+    include Neo4j::Shared
+    include Neo4j::Shared::Identity
+    include Neo4j::Shared::Marshal
+    include Neo4j::ActiveNode::Initialize
+    include Neo4j::ActiveNode::IdProperty
+    include Neo4j::Shared::SerializedProperties
+    include Neo4j::ActiveNode::Property
+    include Neo4j::ActiveNode::Reflection
+    include Neo4j::ActiveNode::Persistence
+    include Neo4j::ActiveNode::Validations
+    include Neo4j::ActiveNode::Callbacks
+    include Neo4j::ActiveNode::Query
+    include Neo4j::ActiveNode::Labels
+    include Neo4j::ActiveNode::Rels
+    include Neo4j::ActiveNode::Unpersisted
+    include Neo4j::ActiveNode::HasN
+    include Neo4j::ActiveNode::Scope
+    include Neo4j::ActiveNode::Dependent
+    include Neo4j::ActiveNode::Enum
+    include Neo4j::Shared::PermittedAttributes
+
+    def initialize(args = nil)
+      args = sanitize_input_parameters(args)
+      super(args)
+    end
+
+    def neo4j_obj
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
+    end
+
+    module ClassMethods
+      def nodeify(object)
+        if object.is_a?(::Neo4j::ActiveNode) || object.nil?
+          object
+        else
+          self.find(object)
+        end
+      end
+    end
+
+    included do
+      include Neo4j::Timestamps if Neo4j::Config[:record_timestamps]
+
+      def self.inherited(other)
+        Neo4j::ActiveNode::Labels.clear_wrapped_models
+
+        inherit_id_property(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
+
+        Neo4j::ActiveNode::Labels.add_wrapped_class(other)
+        super
+      end
+
+      def self.inherit_id_property(other)
+        Neo4j::Session.on_next_session_available do |_|
+          next if other.manual_id_property? || !self.id_property?
+          id_prop = self.id_property_info
+          conf = id_prop[:type].empty? ? {auto: :uuid} : id_prop[:type]
+          other.id_property id_prop[:name], conf
+        end
+      end
+
+      Neo4j::Session.on_next_session_available do |_|
+        next if manual_id_property?
+        id_property :uuid, auto: :uuid unless self.id_property?
+
+        name = Neo4j::Config[:id_property]
+        type = Neo4j::Config[:id_property_type]
+        value = Neo4j::Config[:id_property_type_value]
+        id_property(name, type => value) if name && type && value
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:active_node, self)
+  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

data/lib/neo4j/active_rel/initialize.rb

@@ -0,0 +1,28 @@
+module Neo4j::ActiveRel
+  module Initialize
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Initialize
+
+    # called when loading the rel from the database
+    # @param [Neo4j::Embedded::EmbeddedRelationship, Neo4j::Server::CypherRelationship] persisted_rel properties of this relationship
+    # @param [Neo4j::Relationship] from_node_id The neo_id of the starting node of this rel
+    # @param [Neo4j::Relationship] to_node_id The neo_id of the ending node of this rel
+    # @param [String] type the relationship type
+    def init_on_load(persisted_rel, from_node_id, to_node_id, type)
+      @rel_type = type
+      @_persisted_obj = persisted_rel
+      changed_attributes && changed_attributes.clear
+      @attributes = convert_and_assign_attributes(persisted_rel.props)
+      load_nodes(from_node_id, to_node_id)
+    end
+
+    def init_on_reload(unwrapped_reloaded)
+      @attributes = nil
+      init_on_load(unwrapped_reloaded,
+                   unwrapped_reloaded._start_node_id,
+                   unwrapped_reloaded._end_node_id,
+                   unwrapped_reloaded.rel_type)
+      self
+    end
+  end
+end

data/lib/neo4j/active_rel/persistence/query_factory.rb

@@ -0,0 +1,95 @@
+module Neo4j::ActiveRel::Persistence
+  # This class builds and executes a Cypher query, using information from the graph objects to determine
+  #   whether they need to be created simultaneously.
+  #   It keeps the rel instance from being responsible for inspecting the nodes or talking with Shared::QueryFactory.
+  class QueryFactory
+    NODE_SYMBOLS = [:from_node, :to_node]
+    attr_reader :from_node, :to_node, :rel, :unwrapped_rel
+
+    def initialize(from_node, to_node, rel)
+      @from_node = from_node
+      @to_node = to_node
+      @rel = rel
+    end
+
+    # TODO: This feels like it should also wrap the rel, but that is handled in Neo4j::ActiveRel::Persistence at the moment.
+    # Builds and executes the query using the objects giving during init.
+    # It holds the process:
+    #   * Execute node callbacks if needed
+    #   * Create and execute the query
+    #   * Mix the query response into the unpersisted objects given during init
+    def build!
+      node_before_callbacks! do
+        res = query_factory(rel, rel_id, iterative_query).query.unwrapped.return(*unpersisted_return_ids).first
+        node_symbols.each { |n| wrap!(send(n), res, n) }
+        @unwrapped_rel = res.send(rel_id)
+      end
+    end
+
+    private
+
+    def rel_id
+      @rel_id ||= rel.rel_identifier
+    end
+
+    # Node callbacks only need to be executed if the node is not persisted. We let the `conditional_callback` method do the work,
+    #   we only have to give it the type of callback we expect to be run and the condition which, if true, will prevent it from executing.
+    def node_before_callbacks!
+      validate_unpersisted_nodes!
+      from_node.conditional_callback(:create, from_node.persisted?) do
+        to_node.conditional_callback(:create, to_node.persisted?) do
+          yield
+        end
+      end
+    end
+
+    def validate_unpersisted_nodes!
+      node_symbols.each do |s|
+        obj = send(s)
+        next if obj.persisted?
+        fail RelCreateFailedError, "Cannot create rel with unpersisted, invalid #{s}" unless obj.valid?
+      end
+    end
+
+    # Each node must be either created or matched before the relationship can be created. This class does not know or care about
+    #   how that happens, it just knows that it needs a usable Neo4j::Core::Query object to do that.
+    # This method is "iterative" because it creates one factory for each node but the second builds upon the first.
+    def iterative_query
+      node_symbols.inject(false) do |iterative_query, sym|
+        obj = send(sym)
+        query_factory(obj, sym, iterative_query)
+      end
+    end
+
+    # Isolates the dependency to the shared class. This has an awareness of Neo4j::Core::Query and will match or create
+    #   based on the current state of the object passed in.
+    def query_factory(obj, sym, factory = false)
+      Neo4j::Shared::QueryFactory.create(obj, sym).tap do |factory_instance|
+        factory_instance.base_query = factory.blank? ? false : factory.query
+      end
+    end
+
+    # @return [Array<Symbol>] The Cypher identifiers that will be returned from the query.
+    # We only need to return objects from our query that were created during it, otherwise we impact performance.
+    def unpersisted_return_ids
+      [rel_id].tap do |result|
+        node_symbols.each { |k| result << k unless send(k).persisted? }
+      end
+    end
+
+    # @param [Neo4j::ActiveNode] node A node, persisted or unpersisted
+    # @param [Struct] res The result of calling `return` on a Neo4j::Core::Query object. It responds to the same keys
+    #   as our graph objects. If the object is unpersisted and was created during the query, the unwrapped node is mixed
+    #   in, making the object reflect as "persisted".
+    # @param [Symbol] key :from_node or :to_node, the object to request from the response.
+    def wrap!(node, res, key)
+      return if node.persisted? || !res.respond_to?(key)
+      unwrapped = res.send(key)
+      node.init_on_load(unwrapped, unwrapped.props)
+    end
+
+    def node_symbols
+      self.class::NODE_SYMBOLS
+    end
+  end
+end