activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/shared/filtered_hash.rb

@@ -0,0 +1,79 @@
+module Neo4j::Shared
+  class FilteredHash
+    class InvalidHashFilterType < Neo4j::Error; end
+    VALID_SYMBOL_INSTRUCTIONS = [:all, :none]
+    VALID_HASH_INSTRUCTIONS = [:on]
+    VALID_INSTRUCTIONS_TYPES = [Hash, Symbol]
+
+    attr_reader :base, :instructions, :instructions_type
+
+    def initialize(base, instructions)
+      @base = base
+      @instructions = instructions
+      @instructions_type = instructions.class
+      validate_instructions!(instructions)
+    end
+
+    def filtered_base
+      case instructions
+      when Symbol
+        filtered_base_by_symbol
+      when Hash
+        filtered_base_by_hash
+      end
+    end
+
+    private
+
+    def filtered_base_by_symbol
+      case instructions
+      when :all
+        [base, {}]
+      when :none
+        [{}, base]
+      end
+    end
+
+    def filtered_base_by_hash
+      behavior_key = instructions.keys.first
+      filter_keys = keys_array(behavior_key)
+      [filter(filter_keys, :with), filter(filter_keys, :without)]
+    end
+
+    def key?(filter_keys, key)
+      filter_keys.include?(key)
+    end
+
+    def filter(filter_keys, key)
+      filtering = key == :with
+      base.select { |k, _v| key?(filter_keys, k) == filtering }
+    end
+
+    def keys_array(key)
+      instructions[key].is_a?(Array) ? instructions[key] : [instructions[key]]
+    end
+
+    def validate_instructions!(instructions)
+      fail InvalidHashFilterType, "Filtering instructions #{instructions} are invalid" unless VALID_INSTRUCTIONS_TYPES.include?(instructions.class)
+      clazz = instructions_type.name.downcase
+      return if send(:"valid_#{clazz}_instructions?", instructions)
+      fail InvalidHashFilterType, "Invalid instructions #{instructions}, valid options for #{clazz}: #{send(:"valid_#{clazz}_instructions")}"
+    end
+
+    def valid_symbol_instructions?(instructions)
+      valid_symbol_instructions.include?(instructions)
+    end
+
+    def valid_hash_instructions?(instructions)
+      valid_hash_instructions.include?(instructions.keys.first)
+    end
+
+    def valid_symbol_instructions
+      VALID_SYMBOL_INSTRUCTIONS
+    end
+
+    def valid_hash_instructions
+      VALID_HASH_INSTRUCTIONS
+    end
+  end
+end

data/lib/neo4j/shared/identity.rb

@@ -0,0 +1,34 @@
+module Neo4j
+  module Shared
+    module Identity
+      def ==(other)
+        other.class == self.class && other.id == id
+      end
+      alias eql? ==
+
+      # Returns an Enumerable of all (primary) key attributes
+      # or nil if model.persisted? is false
+      def to_key
+        _persisted_obj ? [id] : nil
+      end
+
+      # @return [Integer, nil] the neo4j id of the node if persisted or nil
+      def neo_id
+        _persisted_obj ? _persisted_obj.neo_id : nil
+      end
+
+      def id
+        if self.class.id_property_name
+          send(self.class.id_property_name)
+        else
+          # ActiveRel
+          neo_id
+        end
+      end
+
+      def hash
+        id.hash
+      end
+    end
+  end
+end

data/lib/neo4j/shared/initialize.rb

@@ -0,0 +1,64 @@
+module Neo4j::Shared
+  module Initialize
+    extend ActiveSupport::Concern
+
+    # 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.
+    # @return self
+    def wrapper
+      self
+    end
+
+    private
+
+    def convert_and_assign_attributes(properties)
+      @attributes ||= Hash[self.class.attributes_nil_hash]
+      stringify_attributes!(@attributes, properties)
+      self.default_properties = properties if respond_to?(:default_properties=)
+      self.class.declared_properties.convert_properties_to(self, :ruby, @attributes)
+    end
+
+    def stringify_attributes!(attr, properties)
+      properties.each_pair do |k, v|
+        key = self.class.declared_properties.string_key(k)
+        attr[key.freeze] = v
+      end
+    end
+
+    # We should be using #clear_changes_information
+    # but right now we don't use `ActiveModel` attributes correctly and so it doesn't work
+    # Once we set @attribute correctly from using class ActiveModel::Attribute
+    # we will no longer need to explicitly call following method and can safely remove it
+    def changed_attributes_clear!
+      return if changed_attributes.nil?
+
+      # with ActiveModel 6.0.0 we have to clear attribute changes with clear_attribute_changes
+      clear_attribute_changes(self.attributes.keys)
+
+      # changed_attributes is frozen starting with ActiveModel 5.2.0
+      # Not a good long term solution
+      if changed_attributes.frozen?
+        @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      else
+        changed_attributes && changed_attributes.clear
+      end
+    end
+
+    # Once we set @attribute correctly from using class ActiveModel::Attribute
+    # we will no longer need to explicitly call following method and can safely remove it
+    def changed_attributes_selective_clear!(hash_to_clear)
+      # with ActiveModel 6.0.0 we have to clear attribute changes with clear_attribute_change
+      hash_to_clear.each_key { |k| clear_attribute_change(k) } if defined?(ActiveModel::ForcedMutationTracker)
+
+      # changed_attributes is frozen starting with ActiveModel 5.2.0
+      # Not a good long term solution
+      if changed_attributes.frozen?
+        attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new(changed_attributes)
+        hash_to_clear.each_key { |k| attributes_changed_by_setter.delete(k) }
+        @attributes_changed_by_setter = attributes_changed_by_setter
+      else
+        hash_to_clear.each_key { |k| changed_attributes.delete(k) }
+      end
+    end
+  end
+end

data/lib/neo4j/shared/marshal.rb

@@ -0,0 +1,23 @@
+module Neo4j
+  module Shared
+    module Marshal
+      extend ActiveSupport::Concern
+
+      def marshal_dump
+        marshal_instance_variables.map(&method(:instance_variable_get))
+      end
+
+      def marshal_load(array)
+        marshal_instance_variables.zip(array).each do |var, value|
+          instance_variable_set(var, value)
+        end
+      end
+
+      private
+
+      def marshal_instance_variables
+        self.class::MARSHAL_INSTANCE_VARIABLES
+      end
+    end
+  end
+end

data/lib/neo4j/shared/mass_assignment.rb

@@ -0,0 +1,64 @@
+module Neo4j::Shared
+  # MassAssignment allows you to bulk set and update attributes
+  #
+  # Including MassAssignment into your model gives it a set of mass assignment
+  # methods, similar to those found in ActiveRecord.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::MassAssignment
+  #   end
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module MassAssignment
+    extend ActiveSupport::Concern
+    # Mass update a model's attributes
+    #
+    # @example Assigning a hash
+    #   person.assign_attributes(:first_name => "Chris", :last_name => "Griego")
+    #   person.first_name #=> "Chris"
+    #   person.last_name #=> "Griego"
+    #
+    # @param [Hash{#to_s => Object}, #each] attributes Attributes used to
+    #   populate the model
+    # @param [Hash, #[]] options Options that affect mass assignment
+    def assign_attributes(new_attributes = nil)
+      return unless new_attributes.present?
+      new_attributes.each do |name, value|
+        writer = :"#{name}="
+        if respond_to?(writer)
+          send(writer, value)
+        else
+          add_undeclared_property(name, value)
+        end
+      end
+    end
+
+    def add_undeclared_property(_, _); end
+
+    # Mass update a model's attributes
+    #
+    # @example Assigning a hash
+    #   person.attributes = { :first_name => "Chris", :last_name => "Griego" }
+    #   person.first_name #=> "Chris"
+    #   person.last_name #=> "Griego"
+    #
+    # @param (see #assign_attributes)
+    def attributes=(new_attributes)
+      assign_attributes(new_attributes)
+    end
+
+    # Initialize a model with a set of attributes
+    #
+    # @example Initializing with a hash
+    #   person = Person.new(:first_name => "Chris", :last_name => "Griego")
+    #   person.first_name #=> "Chris"
+    #   person.last_name #=> "Griego"
+    #
+    # @param (see #assign_attributes)
+    def initialize(attributes = nil)
+      assign_attributes(attributes)
+      super()
+    end
+  end
+end

data/lib/neo4j/shared/permitted_attributes.rb

@@ -0,0 +1,28 @@
+module Neo4j::Shared
+  module PermittedAttributes
+    extend ActiveSupport::Concern
+    include ActiveModel::ForbiddenAttributesProtection
+
+    def process_attributes(attributes)
+      attributes = sanitize_input_parameters(attributes)
+      super(attributes)
+    end
+
+    def attributes=(attributes)
+      attributes = sanitize_input_parameters(attributes)
+      super(attributes)
+    end
+
+    protected
+
+    # Check if an argument is a string or an ActionController::Parameters
+    def hash_or_parameter?(args)
+      args.is_a?(Hash) || args.respond_to?(:to_unsafe_h)
+    end
+
+    def sanitize_input_parameters(attributes)
+      attributes = sanitize_for_mass_assignment(attributes)
+      attributes.respond_to?(:symbolize_keys) ? attributes.symbolize_keys : attributes
+    end
+  end
+end

data/lib/neo4j/shared/persistence.rb

@@ -0,0 +1,282 @@
+module Neo4j::Shared
+  # rubocop:disable Metrics/ModuleLength
+  module Persistence
+    # rubocop:enable Metrics/ModuleLength
+    extend ActiveSupport::Concern
+
+    # @return [Hash] Given a node's state, will call the appropriate `props_for_{action}` method.
+    def props_for_persistence
+      _persisted_obj ? props_for_update : props_for_create
+    end
+
+    def update_model
+      return if skip_update?
+      props = props_for_update
+      neo4j_query(query_as(:n).set(n: props))
+      _persisted_obj.props.merge!(props)
+      changed_attributes_clear!
+    end
+
+    def skip_update?
+      changed_attributes.blank?
+    end
+
+    # Returns a hash containing:
+    # * All properties and values for insertion in the database
+    # * A `uuid` (or equivalent) key and value
+    # * Timestamps, if the class is set to include them.
+    # Note that the UUID is added to the hash but is not set on the node.
+    # The timestamps, by comparison, are set on the node prior to addition in this hash.
+    # @return [Hash]
+    def props_for_create
+      inject_timestamps!
+      props_with_defaults = inject_defaults!(props)
+      converted_props = props_for_db(props_with_defaults)
+      return converted_props unless self.class.respond_to?(:default_property_values)
+      inject_primary_key!(converted_props)
+    end
+
+    # @return [Hash] Properties and values, type-converted and timestamped for the database.
+    def props_for_update
+      update_magic_properties
+      changed_props = attributes.select { |k, _| changed_attributes.include?(k) }
+      changed_props.symbolize_keys!
+      inject_defaults!(changed_props)
+      props_for_db(changed_props)
+    end
+
+    # Increments a numeric attribute by a centain amount
+    # @param [Symbol, String] name of the attribute to increment
+    # @param [Integer, Float] amount to increment
+    def increment(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] += by
+      self
+    end
+
+    # Convenience method to increment numeric attribute and #save at the same time
+    # @param [Symbol, String] name of the attribute to increment
+    # @param [Integer, Float] amount to increment
+    def increment!(attribute, by = 1)
+      increment(attribute, by).update_attribute(attribute, self[attribute])
+    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)
+      fail 'not_implemented'
+    end
+
+    # Convenience method to set attribute and #save at the same time
+    # @param [Symbol, String] attribute of the attribute to update
+    # @param [Object] value to set
+    def update_attribute(attribute, value)
+      write_attribute(attribute, value)
+      self.save
+    end
+
+    # Convenience method to set attribute and #save! at the same time
+    # @param [Symbol, String] attribute of the attribute to update
+    # @param [Object] value to set
+    def update_attribute!(attribute, value)
+      write_attribute(attribute, value)
+      self.save!
+    end
+
+    def create_or_update
+      # since the same model can be created or updated twice from a relationship we have to have this guard
+      @_create_or_updating = true
+      apply_default_values
+      result = _persisted_obj ? update_model : create_model
+      current_transaction = Neo4j::ActiveBase.current_transaction
+
+      current_transaction.mark_failed if result == false && current_transaction
+
+      result != false
+    rescue => e
+      current_transaction.mark_failed if current_transaction
+      raise e
+    ensure
+      @_create_or_updating = nil
+    end
+
+    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.respond_to?(:call) ? value.call : value) if self.send(key).nil?
+      end
+    end
+
+    def touch
+      fail 'Cannot touch on a new record object' unless persisted?
+      update_attribute!(:updated_at, Time.now) if respond_to?(:updated_at=)
+    end
+
+    # Returns +true+ if the record is persisted, i.e. it's not a new record and it was not destroyed
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    # Returns +true+ if the record hasn't been saved to Neo4j yet.
+    def new_record?
+      !_persisted_obj
+    end
+
+    alias new? new_record?
+
+    def destroy
+      freeze
+
+      destroy_query.exec if _persisted_obj
+
+      @_deleted = true
+
+      self
+    end
+
+    def exist?
+      return if !_persisted_obj
+
+      neo4j_query(query_as(:n).return('ID(n)')).any?
+    end
+
+    # Returns +true+ if the object was destroyed.
+    def destroyed?
+      @_deleted
+    end
+
+    # @return [Hash] all defined and none nil properties
+    def props
+      attributes.reject { |_, v| v.nil? }.symbolize_keys
+    end
+
+    # @return true if the attributes hash has been frozen
+    def frozen?
+      @attributes.frozen?
+    end
+
+    def freeze
+      @attributes.freeze
+      self
+    end
+
+    def reload
+      return self if new_record?
+      association_proxy_cache.clear if respond_to?(:association_proxy_cache)
+      changed_attributes_clear!
+      unless reload_from_database
+        @_deleted = true
+        freeze
+      end
+      self
+    end
+
+    def reload_from_database
+      reloaded = self.class.load_entity(neo_id)
+      reloaded ? init_on_reload(reloaded._persisted_obj) : nil
+    end
+
+    # 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.
+    def update(attributes)
+      self.class.run_transaction do |tx|
+        self.attributes = process_attributes(attributes)
+        saved = save
+        tx.mark_failed unless saved
+        saved
+      end
+    end
+    alias update_attributes update
+
+    def update_db_property(field, value)
+      update_db_properties(field => value)
+      true
+    end
+    alias update_column update_db_property
+
+    def update_db_properties(hash)
+      fail ::Neo4j::Error, 'can not update on a new record object' unless persisted?
+      self.class.run_transaction do
+        db_values = props_for_db(hash)
+        neo4j_query(query_as(:n).set(n: db_values))
+        db_values.each_pair { |k, v| self.public_send(:"#{k}=", v) }
+        _persisted_obj.props.merge!(db_values)
+        changed_attributes_selective_clear!(db_values)
+        true
+      end
+    end
+    alias update_columns update_db_properties
+
+    # Same as {#update_attributes}, but raises an exception if saving fails.
+    def update!(attributes)
+      self.class.run_transaction do
+        self.attributes = process_attributes(attributes)
+        save!
+      end
+    end
+    alias update_attributes! update!
+
+    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
+
+    module ClassMethods
+      def run_transaction(run_in_tx = true)
+        Neo4j::ActiveBase.run_transaction(run_in_tx) { |tx| yield tx }
+      end
+    end
+
+    protected
+
+    def increment_by_query!(match_query, attribute, by, element_name = :n)
+      new_attribute = match_query.with(element_name)
+                                 .set("#{element_name}.`#{attribute}` = COALESCE(#{element_name}.`#{attribute}`, 0) + {by}")
+                                 .params(by: by).limit(1)
+                                 .pluck("#{element_name}.`#{attribute}`").first
+      return false unless new_attribute
+      self[attribute] = new_attribute
+
+      if defined? ActiveModel::ForcedMutationTracker
+        # with ActiveModel 6.0.0 set_attribute_was is removed
+        # so we mark attribute's previous value using attr_will_change method
+        clear_attribute_change(attribute)
+      else
+        set_attribute_was(attribute, new_attribute)
+      end
+      true
+    end
+
+    private
+
+    def props_for_db(props_hash)
+      self.class.declared_properties.convert_properties_to(self, :db, props_hash)
+    end
+
+    def model_cache_key
+      self.class.model_name.cache_key
+    end
+
+    def update_magic_properties
+      self.updated_at = DateTime.now if respond_to?(:updated_at=) && (updated_at.nil? || (changed? && !updated_at_changed?))
+    end
+
+    def inject_timestamps!
+      now = DateTime.now
+      self.created_at ||= now if respond_to?(:created_at=)
+      self.updated_at ||= now if respond_to?(:updated_at=)
+    end
+
+    def set_timestamps
+      warning = 'This method has been replaced with `inject_timestamps!` and will be removed in a future version'.freeze
+      ActiveSupport::Deprecation.warn warning, caller
+      inject_timestamps!
+    end
+  end
+end