ActiveNode

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>.

• Rels
• Query
  • ClassMethods
  • QueryProxy
    • Link
  • QueryProxyMethods
    • InvalidParameterError
  • QueryProxyEnumerable
  • QueryProxyEagerLoading
  • QueryProxyFindInBatches
• HasN
  • NonPersistedNodeError
  • AssociationProxy
  • ClassMethods
  • Association
• Scope
  • ClassMethods
  • ScopeEvalContext
  • ScopeRegistry
• Labels
  • InvalidQueryError
  • RecordNotFound
  • ClassMethods
• Property
  • ClassMethods
• Callbacks
• Dependent
  • QueryProxyMethods
  • AssociationMethods
• Reflection
  • ClassMethods
  • AssociationReflection
• Initialize
• Persistence
  • RecordInvalidError
  • ClassMethods
• IdProperty
  • TypeMethods
  • ClassMethods
• Validations
  • ClassMethods
  • UniquenessValidator
• ClassMethods
• OrmAdapter
  • ClassMethods
• QueryMethods
  • InvalidParameterError

Constants

• WRAPPED_CLASSES
• MODELS_FOR_LABELS_CACHE
• USES_CLASSNAME

Files

• lib/neo4j/active_node.rb:23
• lib/neo4j/active_node/rels.rb:1
• lib/neo4j/active_node/query.rb:2
• lib/neo4j/active_node/has_n.rb:1
• lib/neo4j/active_node/scope.rb:3
• lib/neo4j/active_node/labels.rb:2
• lib/neo4j/active_node/property.rb:1
• lib/neo4j/active_node/callbacks.rb:2
• lib/neo4j/active_node/dependent.rb:2
• lib/neo4j/active_node/reflection.rb:1
• lib/neo4j/active_node/persistence.rb:1
• lib/neo4j/active_node/id_property.rb:1
• lib/neo4j/active_node/validations.rb:2
• lib/neo4j/active_node/orm_adapter.rb:4
• lib/neo4j/active_node/query_methods.rb:2
• lib/neo4j/active_node/query/query_proxy.rb:2
• lib/neo4j/active_node/has_n/association.rb:4
• lib/neo4j/active_node/query/query_proxy_link.rb:2
• lib/neo4j/active_node/query/query_proxy_methods.rb:2
• lib/neo4j/active_node/query/query_proxy_enumerable.rb:2
• lib/neo4j/active_node/dependent/query_proxy_methods.rb:2
• lib/neo4j/active_node/dependent/association_methods.rb:2
• lib/neo4j/active_node/query/query_proxy_eager_loading.rb:2
• lib/neo4j/active_node/query/query_proxy_find_in_batches.rb:2

Methods

#==

+ show/hide code

def ==(other)
  other.class == self.class && other.id == id
end

#[]

Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr

+ show/hide code

def read_attribute(name)
  super(name)
rescue ActiveAttr::UnknownAttributeError
  nil
end

#_active_record_destroyed_behavior?

+ show/hide code

def _active_record_destroyed_behavior?
  fail 'Remove this workaround in 6.0.0' if Neo4j::VERSION >= '6.0.0'

  !!Neo4j::Config[:_active_record_destroyed_behavior]
end

#_create_node

+ show/hide code

def _create_node(*args)
  session = self.class.neo4j_session
  props = self.class.default_property_values(self)
  props.merge!(args[0]) if args[0].is_a?(Hash)
  set_classname(props)
  labels = self.class.mapped_label_names
  session.create_node(props, labels)
end

#_destroyed_double_check?

These two methods should be removed in 6.0.0

+ show/hide code

def _destroyed_double_check?
  if _active_record_destroyed_behavior?
    true
  else
    (!new_record? && !exist?)
  end
end

#_persisted_obj

Returns the value of attribute _persisted_obj

+ show/hide code

def _persisted_obj
  @_persisted_obj
end

#_rels_delegator

+ show/hide code

def _rels_delegator
  fail "Can't access relationship on a non persisted node" unless _persisted_obj
  _persisted_obj
end

#add_label

adds one or more labels

+ show/hide code

def add_label(*label)
  @_persisted_obj.add_label(*label)
end

#apply_default_values

+ show/hide code

def apply_default_values
  return if self.class.declared_property_defaults.empty?
  self.class.declared_property_defaults.each_pair do |key, value|
    self.send("#{key}=", value) if self.send(key).nil?
  end
end

#as

Starts a new QueryProxy with the starting identifier set to the given argument and QueryProxy source_object set to the node instance. This method does not exist within QueryProxy and can only be used to start a new chain.

+ show/hide code

def as(node_var)
  self.class.query_proxy(node: node_var, source_object: self).match_to(self)
end

#association_proxy

+ show/hide code

def association_proxy(name, options = {})
  name = name.to_sym
  hash = [name, options.values_at(:node, :rel, :labels)].hash
  association_proxy_cache_fetch(hash) do
    if previous_association_proxy = self.instance_variable_get('@association_proxy')
      result_by_previous_id = previous_association_proxy_results_by_previous_id(previous_association_proxy, name)

      previous_association_proxy.result.inject(nil) do |proxy_to_return, object|
        proxy = fresh_association_proxy(name, options, result_by_previous_id[object.neo_id])

        object.association_proxy_cache[hash] = proxy

        (self == object ? proxy : proxy_to_return)
      end
    else
      fresh_association_proxy(name, options)
    end
  end
end

#association_proxy_cache

Returns the current AssociationProxy cache for the association cache. It is in the format { :association_name => AssociationProxy} This is so that we * don’t need to re-build the QueryProxy objects * also because the QueryProxy object caches it’s results * so we don’t need to query again * so that we can cache results from association calls or eager loading

+ show/hide code

def association_proxy_cache
  @association_proxy_cache ||= {}
end

#association_proxy_cache_fetch

+ show/hide code

def association_proxy_cache_fetch(key)
  association_proxy_cache.fetch(key) do
    value = yield
    association_proxy_cache[key] = value
  end
end

#association_query_proxy

+ show/hide code

def association_query_proxy(name, options = {})
  self.class.send(:association_query_proxy, name, {start_object: self}.merge!(options))
end

#cache_key

+ show/hide code

def cache_key
  if self.new_record?
    "#{model_cache_key}/new"
  elsif self.respond_to?(:updated_at) && !self.updated_at.blank?
    "#{model_cache_key}/#{neo_id}-#{self.updated_at.utc.to_s(:number)}"
  else
    "#{model_cache_key}/#{neo_id}"
  end
end

#called_by

Returns the value of attribute called_by

+ show/hide code

def called_by
  @called_by
end

#called_by=

Sets the attribute called_by

+ show/hide code

def called_by=(value)
  @called_by = value
end

#declared_property_manager

+ show/hide code

def declared_property_manager
  self.class.declared_property_manager
end

#default_properties

+ show/hide code

def default_properties
  @default_properties ||= Hash.new(nil)
  # keys = self.class.default_properties.keys
  # _persisted_obj.props.reject{|key| !keys.include?(key)}
end

#default_properties=

+ show/hide code

def default_properties=(properties)
  default_property_keys = self.class.default_properties_keys
  @default_properties = properties.select { |key| default_property_keys.include?(key) }
end

#default_property

+ show/hide code

def default_property(key)
  default_properties[key.to_sym]
end

#dependent_children

+ show/hide code

def dependent_children
  @dependent_children ||= []
end

#destroy

nodoc:

+ show/hide code

def destroy #:nodoc:
  tx = Neo4j::Transaction.new
  run_callbacks(:destroy) { super }
rescue
  @_deleted = false
  @attributes = @attributes.dup
  tx.mark_failed
  raise
ensure
  tx.close if tx
end

#destroyed?

Returns +true+ if the object was destroyed.

+ show/hide code

def destroyed?
  @_deleted || _destroyed_double_check?
end

#eql?

+ show/hide code

def ==(other)
  other.class == self.class && other.id == id
end

#exist?

+ show/hide code

def exist?
  _persisted_obj && _persisted_obj.exist?
end

#freeze

+ show/hide code

def freeze
  @attributes.freeze
  self
end

#frozen?

+ show/hide code

def frozen?
  @attributes.frozen?
end

#hash

+ show/hide code

def hash
  id.hash
end

#id

+ show/hide code

def id
  id = neo_id
  id.is_a?(Integer) ? id : nil
end

#init_on_load

called when loading the node from the database

+ show/hide code

def init_on_load(persisted_node, properties)
  self.class.extract_association_attributes!(properties)
  @_persisted_obj = persisted_node
  changed_attributes && changed_attributes.clear
  @attributes = convert_and_assign_attributes(properties)
end

#initialize

+ show/hide code

def initialize(attributes = {}, options = {})
  super(attributes, options)
  @attributes ||= self.class.attributes_nil_hash.dup
  send_props(@relationship_props) if _persisted_obj && !@relationship_props.nil?
end

#inspect

+ show/hide code

def inspect
  id_property_name = self.class.id_property_name.to_s
  attribute_pairs = attributes.except(id_property_name).sort.map { |key, value| "#{key}: #{value.inspect}" }
  attribute_pairs.unshift("#{id_property_name}: #{self.send(id_property_name).inspect}")
  attribute_descriptions = attribute_pairs.join(', ')
  separator = ' ' unless attribute_descriptions.empty?
  "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
end

#labels

+ show/hide code

def labels
  @_persisted_obj.labels
end

#neo4j_obj

+ show/hide code

def neo4j_obj
  _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
end

#neo_id

+ show/hide code

def neo_id
  _persisted_obj ? _persisted_obj.neo_id : nil
end

#new?

Returns +true+ if the record hasn’t been saved to Neo4j yet.

+ show/hide code

def new_record?
  !_persisted_obj
end

#new_record?

Returns +true+ if the record hasn’t been saved to Neo4j yet.

+ show/hide code

def new_record?
  !_persisted_obj
end

#persisted?

Returns +true+ if the record is persisted, i.e. it’s not a new record and it was not destroyed

+ show/hide code

def persisted?
  !new_record? && !destroyed?
end

#props

+ show/hide code

def props
  attributes.reject { |_, v| v.nil? }.symbolize_keys
end

#query_as

Returns a Query object with the current node matched the specified variable name

+ show/hide code

def query_as(node_var)
  self.class.query_as(node_var, false).where("ID(#{node_var})" => self.neo_id)
end

#read_attribute

Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr

+ show/hide code

def read_attribute(name)
  super(name)
rescue ActiveAttr::UnknownAttributeError
  nil
end

#read_attribute_for_validation

Implements the ActiveModel::Validation hook method.

+ show/hide code

def read_attribute_for_validation(key)
  respond_to?(key) ? send(key) : self[key]
end

#reload

+ show/hide code

def reload
  return self if new_record?
  association_proxy_cache.clear
  changed_attributes && changed_attributes.clear
  unless reload_from_database
    @_deleted = true
    freeze
  end
  self
end

#reload_from_database

+ show/hide code

def reload_from_database
  # TODO: - Neo4j::IdentityMap.remove_node_by_id(neo_id)
  if reloaded = self.class.load_entity(neo_id)
    send(:attributes=, reloaded.attributes)
  end
  reloaded
end

#remove_label

Removes one or more labels Be careful, don’t remove the label representing the Ruby class.

+ show/hide code

def remove_label(*label)
  @_persisted_obj.remove_label(*label)
end

#save

The validation process on save can be skipped by passing false. The regular Model#save method is replaced with this when the validations module is mixed in, which it is by default.

+ show/hide code

def save(options = {})
  result = perform_validations(options) ? super : false
  if !result
    Neo4j::Transaction.current.failure if Neo4j::Transaction.current
  end
  result
end

#save!

Persist the object to the database. Validations and Callbacks are included by default but validation can be disabled by passing :validate => false to #save! Creates a new transaction.

+ show/hide code

def save!(*args)
  fail RecordInvalidError, self unless save(*args)
end

#send_props

+ show/hide code

def send_props(hash)
  hash.each { |key, value| self.send("#{key}=", value) }
end

#serializable_hash

+ show/hide code

def serializable_hash(*args)
  super.merge(id: id)
end

#serialized_properties

+ show/hide code

def serialized_properties
  self.class.serialized_properties
end

#to_key

Returns an Enumerable of all (primary) key attributes or nil if model.persisted? is false

+ show/hide code

def to_key
  _persisted_obj ? [id] : nil
end

#touch

nodoc:

+ show/hide code

def touch(*) #:nodoc:
  run_callbacks(:touch) { super }
end

#update

Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved. If saving fails because the resource is invalid then false will be returned.

+ show/hide code

def update(attributes)
  self.attributes = process_attributes(attributes)
  save
end

#update!

Same as {#update_attributes}, but raises an exception if saving fails.

+ show/hide code

def update!(attributes)
  self.attributes = process_attributes(attributes)
  save!
end

#update_attribute

Convenience method to set attribute and #save at the same time

+ show/hide code

def update_attribute(attribute, value)
  send("#{attribute}=", value)
  self.save
end

#update_attribute!

Convenience method to set attribute and #save! at the same time

+ show/hide code

def update_attribute!(attribute, value)
  send("#{attribute}=", value)
  self.save!
end

#update_attributes

Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved. If saving fails because the resource is invalid then false will be returned.

+ show/hide code

def update(attributes)
  self.attributes = process_attributes(attributes)
  save
end

#update_attributes!

Same as {#update_attributes}, but raises an exception if saving fails.

+ show/hide code

def update!(attributes)
  self.attributes = process_attributes(attributes)
  save!
end

#valid?

+ show/hide code

def valid?(context = nil)
  context     ||= (new_record? ? :create : :update)
  super(context)
  errors.empty?
end

#wrapper

Implements the Neo4j::Node#wrapper and Neo4j::Relationship#wrapper method so that we don’t have to care if the node is wrapped or not.

+ show/hide code

def wrapper
  self
end