activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/active_node/labels/index.rb

@@ -0,0 +1,37 @@
+module Neo4j::ActiveNode::Labels
+  module Index
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      extend Forwardable
+
+      def_delegators :declared_properties, :indexed_properties
+
+      # Creates a Neo4j index on given property
+      #
+      # This can also be done on the property directly, see Neo4j::ActiveNode::Property::ClassMethods#property.
+      #
+      # @param [Symbol] property the property we want a Neo4j index on
+      #
+      # @example
+      #   class Person
+      #      include Neo4j::ActiveNode
+      #      property :name
+      #      index :name
+      #    end
+      def index(property)
+        return if Neo4j::ModelSchema.defined_constraint?(self, property)
+
+        Neo4j::ModelSchema.add_defined_index(self, property)
+      end
+
+      # Creates a neo4j constraint on this class for given property
+      #
+      # @example
+      #   Person.constraint :name, type: :unique
+      def constraint(property, _constraints = {type: :unique})
+        Neo4j::ModelSchema.add_defined_constraint(self, property)
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/labels/reloading.rb

@@ -0,0 +1,21 @@
+module Neo4j::ActiveNode::Labels
+  module Reloading
+    extend ActiveSupport::Concern
+
+    MODELS_TO_RELOAD = []
+
+    def self.reload_models!
+      MODELS_TO_RELOAD.each(&:constantize)
+      MODELS_TO_RELOAD.clear
+    end
+
+    module ClassMethods
+      def before_remove_const
+        associations.each_value(&:queue_model_refresh!)
+        MODELS_FOR_LABELS_CACHE.clear
+        WRAPPED_CLASSES.each { |c| MODELS_TO_RELOAD << c.name }
+        WRAPPED_CLASSES.clear
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/node_list_formatter.rb

@@ -0,0 +1,13 @@
+module Neo4j::ActiveNode
+  class NodeListFormatter
+    def initialize(list, max_elements = 5)
+      @list = list
+      @max_elements = max_elements
+    end
+
+    def inspect
+      return @list.inspect if !@max_elements || @list.length <= @max_elements
+      "[#{@list.take(5).map!(&:inspect).join(', ')}, ...]"
+    end
+  end
+end

data/lib/neo4j/active_node/node_wrapper.rb

@@ -0,0 +1,54 @@
+require 'active_support/inflector'
+require 'neo4j/core/node'
+
+wrapping_proc = proc do |node|
+  found_class = Neo4j::NodeWrapping.class_to_wrap(node.labels)
+  next node if not found_class
+
+  found_class.new.tap do |wrapped_node|
+    wrapped_node.init_on_load(node, node.props)
+  end
+end
+Neo4j::Driver::Types::Node.wrapper_callback(wrapping_proc)
+
+module Neo4j
+  module NodeWrapping
+    # Only load classes once for performance
+    CONSTANTS_FOR_LABELS_CACHE = {}
+
+    class << self
+      def class_to_wrap(labels)
+        load_classes_from_labels(labels)
+        Neo4j::ActiveNode::Labels.model_for_labels(labels).tap do |model_class|
+          populate_constants_for_labels_cache(model_class, labels)
+        end
+      end
+
+      private
+
+      def load_classes_from_labels(labels)
+        labels.each { |label| constant_for_label(label) }
+      end
+
+      def constant_for_label(label)
+        CONSTANTS_FOR_LABELS_CACHE[label] || CONSTANTS_FOR_LABELS_CACHE[label] = constantized_label(label)
+      end
+
+      def constantized_label(label)
+        "#{association_model_namespace}::#{label}".constantize
+      rescue NameError, LoadError
+        nil
+      end
+
+      def populate_constants_for_labels_cache(model_class, labels)
+        labels.each do |label|
+          CONSTANTS_FOR_LABELS_CACHE[label] = model_class if CONSTANTS_FOR_LABELS_CACHE[label].nil?
+        end
+      end
+
+      def association_model_namespace
+        Neo4j::Config.association_model_namespace_string
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/orm_adapter.rb

@@ -0,0 +1,82 @@
+require 'orm_adapter'
+
+module Neo4j
+  module ActiveNode
+    module ClassMethods
+      include OrmAdapter::ToAdapter
+    end
+
+    class OrmAdapter < ::OrmAdapter::Base
+      module ClassMethods
+        include ActiveModel::Callbacks
+      end
+
+      def column_names
+        klass._decl_props.keys
+      end
+
+      def i18n_scope
+        :neo4j
+      end
+
+      # Get an instance by id of the model
+      def get!(id)
+        klass.find(wrap_key(id)).tap do |node|
+          fail 'No record found' if node.nil?
+        end
+      end
+
+      # Get an instance by id of the model
+      def get(id)
+        klass.find_by(klass.id_property_name => wrap_key(id))
+      end
+
+      # Find the first instance matching conditions
+      def find_first(options = {})
+        conditions, order = extract_conditions!(options)
+        extract_id!(conditions)
+        order = hasherize_order(order)
+
+        result = klass.where(conditions)
+        result = result.order(order) unless order.empty?
+        result.first
+      end
+
+      # Find all models matching conditions
+      def find_all(options = {})
+        conditions, order, limit, offset = extract_conditions!(options)
+        extract_id!(conditions)
+        order = hasherize_order(order)
+
+        result = klass.where(conditions)
+        result = result.order(order) unless order.empty?
+        result = result.skip(offset) if offset
+        result = result.limit(limit) if limit
+        result.to_a
+      end
+
+      # Create a model using attributes
+      def create!(attributes = {})
+        klass.create!(attributes)
+      end
+
+      # @see OrmAdapter::Base#destroy
+      def destroy(object)
+        object.destroy && true if valid_object?(object)
+      end
+
+      private
+
+      def hasherize_order(order)
+        (order || []).map { |clause| Hash[*clause] }
+      end
+
+      def extract_id!(conditions)
+        id = conditions.delete(:id)
+        return if not id
+
+        conditions[klass.id_property_name.to_sym] = id
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/persistence.rb

@@ -0,0 +1,187 @@
+module Neo4j::ActiveNode
+  module Persistence
+    class RecordInvalidError < RuntimeError
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(', '))
+      end
+    end
+
+    extend ActiveSupport::Concern
+    extend Forwardable
+    include Neo4j::Shared::Persistence
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise the existing record gets updated.
+    # If perform_validation is true validations run.
+    # If any of them fail the action is cancelled and save returns false.
+    # If the flag is false validations are bypassed altogether.
+    # See ActiveRecord::Validations for more information.
+    # There's a series of callbacks associated with save.
+    # If any of the before_* callbacks return false the action is cancelled and save returns false.
+    def save(*)
+      cascade_save do
+        association_proxy_cache.clear
+        create_or_update
+      end
+    end
+
+    # Increments concurrently a numeric attribute by a centain amount
+    # @param [Symbol, String] name of the attribute to increment
+    # @param [Integer, Float] amount to increment
+    def concurrent_increment!(attribute, by = 1)
+      increment_by_query! query_as(:n), attribute, by
+    end
+
+    # 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.
+    #
+    # @raise a RecordInvalidError if there is a problem during save.
+    # @param (see Neo4j::Rails::Validations#save)
+    # @return nil
+    # @see #save
+    # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
+    # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
+    def save!(*args)
+      save(*args) or fail(RecordInvalidError, self) # rubocop:disable Style/AndOr
+    end
+
+    # Creates a model with values matching those of the instance attributes and returns its id.
+    # @private
+    # @return true
+    def create_model
+      node = _create_node(props_for_create)
+      init_on_load(node, node.props)
+      @deferred_nodes = nil
+      true
+    end
+
+    # TODO: This does not seem like it should be the responsibility of the node.
+    # Creates an unwrapped node in the database.
+    # @param [Hash] node_props The type-converted properties to be added to the new node.
+    # @param [Array] labels The labels to use for creating the new node.
+    # @return [Neo4j::Node] A CypherNode or EmbeddedNode
+    def _create_node(node_props, labels = labels_for_create)
+      query = "CREATE (n:`#{Array(labels).join('`:`')}`) SET n = {props} RETURN n"
+      neo4j_query(query, {props: node_props}, wrap_level: :core_entity).to_a[0].n
+    end
+
+    # As the name suggests, this inserts the primary key (id property) into the properties hash.
+    # The method called here, `default_property_values`, is a holdover from an earlier version of the gem. It does NOT
+    # contain the default values of properties, it contains the Default Property, which we now refer to as the ID Property.
+    # It will be deprecated and renamed in a coming refactor.
+    # @param [Hash] converted_props A hash of properties post-typeconversion, ready for insertion into the DB.
+    def inject_primary_key!(converted_props)
+      self.class.default_property_values(self).tap do |destination_props|
+        destination_props.merge!(converted_props) if converted_props.is_a?(Hash)
+      end
+    end
+
+    # @return [Array] Labels to be set on the node during a create event
+    def labels_for_create
+      self.class.mapped_label_names
+    end
+
+    private
+
+    def destroy_query
+      query_as(:n).break.optional_match('(n)-[r]-()').delete(:n, :r)
+    end
+
+    # The pending associations are cleared during the save process, so it's necessary to
+    # build the processable hash before it begins. If there are nodes and associations that
+    # need to be created after the node is saved, a new transaction is started.
+    def cascade_save
+      self.class.run_transaction(pending_deferred_creations?) do
+        yield.tap { process_unpersisted_nodes! }
+      end
+    end
+
+    module ClassMethods
+      # Creates and saves a new node
+      # @param [Hash] props the properties the new node should have
+      def create(props = {})
+        new(props).tap do |obj|
+          yield obj if block_given?
+          obj.save
+        end
+      end
+
+      # Same as #create, but raises an error if there is a problem during save.
+      def create!(props = {})
+        new(props).tap do |o|
+          yield o if block_given?
+          o.save!
+        end
+      end
+
+      def merge(match_attributes, optional_attrs = {})
+        options = [:on_create, :on_match, :set]
+        optional_attrs.assert_valid_keys(*options)
+
+        optional_attrs.default = {}
+        on_create_attrs, on_match_attrs, set_attrs = optional_attrs.values_at(*options)
+
+        new_query.merge(n: {self.mapped_label_names => match_attributes})
+                 .on_create_set(on_create_clause(on_create_attrs))
+                 .on_match_set(on_match_clause(on_match_attrs))
+                 .break.set(n: set_attrs)
+                 .pluck(:n).first
+      end
+
+      def find_or_create(find_attributes, set_attributes = {})
+        on_create_attributes = set_attributes.reverse_merge(find_attributes.merge(self.new(find_attributes).props_for_create))
+
+        new_query.merge(n: {self.mapped_label_names => find_attributes})
+                 .on_create_set(n: on_create_attributes)
+                 .pluck(:n).first
+      end
+
+      # Finds the first node with the given attributes, or calls create if none found
+      def find_or_create_by(attributes, &block)
+        find_by(attributes) || create(attributes, &block)
+      end
+
+      # Same as #find_or_create_by, but calls #create! so it raises an error if there is a problem during save.
+      def find_or_create_by!(attributes, &block)
+        find_by(attributes) || create!(attributes, &block)
+      end
+
+      def find_or_initialize_by(attributes)
+        find_by(attributes) || new(attributes).tap { |o| yield(o) if block_given? }
+      end
+
+      def load_entity(id)
+        query = query_base_for(id, :n).return(:n)
+        result = neo4j_query(query).first
+        result && result.n
+      end
+
+      def query_base_for(neo_id, var = :n)
+        Neo4j::ActiveBase.new_query.match(var).where(var => {neo_id: neo_id})
+      end
+
+      private
+
+      def on_create_clause(clause)
+        if clause.is_a?(Hash)
+          {n: clause.merge(self.new(clause).props_for_create)}
+        else
+          clause
+        end
+      end
+
+      def on_match_clause(clause)
+        if clause.is_a?(Hash)
+          {n: clause.merge(attributes_nil_hash.key?('updated_at') ? {updated_at: Time.new.to_i} : {})}
+        else
+          clause
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/property.rb

@@ -0,0 +1,60 @@
+module Neo4j::ActiveNode
+  module Property
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Property
+
+    def initialize(attributes = nil)
+      super(attributes)
+      @attributes ||= Hash[self.class.attributes_nil_hash]
+    end
+
+    module ClassMethods
+      # Extracts keys from attributes hash which are associations of the model
+      # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
+      def extract_association_attributes!(attributes)
+        return unless contains_association?(attributes)
+        attributes.each_with_object({}) do |(key, _), result|
+          result[key] = attributes.delete(key) if self.association_key?(key)
+        end
+      end
+
+      def association_key?(key)
+        association_method_keys.include?(key.to_sym)
+      end
+
+      private
+
+      def contains_association?(attributes)
+        return false unless attributes
+        attributes.each_key { |k| return true if association_key?(k) }
+        false
+      end
+
+      # All keys which could be association setter methods (including _id/_ids)
+      def association_method_keys
+        @association_method_keys ||=
+          associations_keys.map(&:to_sym) +
+          associations.values.map do |association|
+            if association.type == :has_one
+              "#{association.name}_id"
+            elsif association.type == :has_many
+              "#{association.name.to_s.singularize}_ids"
+            end.to_sym
+          end
+      end
+    end
+
+    private
+
+    def inspect_attributes
+      id_property_name = self.class.id_property_name.to_s
+
+      attribute_pairs = attributes.except(id_property_name).sort.map do |key, value|
+        [key, (value.is_a?(String) && value.size > 100) ? value.dup[0..100] : value]
+      end
+
+      attribute_pairs.unshift([id_property_name, self.send(id_property_name)])
+      attribute_pairs
+    end
+  end
+end