neo4j_legacy 7.2.0.1

data/lib/neo4j/shared/enum.rb

@@ -0,0 +1,148 @@
+module Neo4j::Shared
+  module Enum
+    extend ActiveSupport::Concern
+
+    class ConflictingEnumMethodError < Neo4j::Error; end
+
+    module ClassMethods
+      attr_reader :neo4j_enum_data
+
+      # Similar to ActiveRecord enum, maps an integer value on the database to
+      # a set of enum keys.
+      #
+      # @example Base example
+      #   class Media
+      #     include Neo4j::ActiveNode
+      #     enum type: [:image, :video, :unknown]
+      #   end
+      #   Media.types # => { :images => 0, :video => 1, :unknown => 2 }
+      #
+      #   media.video!
+      #   media.image? # => false
+      #   media.type # => :video
+      #
+      #   Media.videos # => All medias with type = 1 (:video)
+      #   Media.where(type: :video) # => All medias with type = 1 (:video)
+      #
+      # @example Prefix-ing an enum
+      #   Media.enum type: [:image, :video, :unknown], _prefix: :enum
+      #
+      #   media.enum_video!
+      #   media.enum_video? # => true
+      #
+      # @example Suffix-ing an enum
+      #   Media.enum type: [:image, :video, :unknown], _suffix: true
+      #
+      #   media.video_type!
+      #   media.video_type? # => true
+      #
+      # @example Disable index: :exact for enum elements
+      #   Media.enum type: [:image, :video, :unknown], _index: false
+      #
+      # @example Define a custom mapping for keys-numbers
+      #   Media.enum type: { image: 1, video: 2, unknown: 3 }
+      #
+      # @see http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html
+      def enum(parameters = {})
+        options, parameters = *split_options_and_parameters(parameters)
+        parameters.each do |property_name, enum_keys|
+          enum_keys = normalize_key_list enum_keys
+          @neo4j_enum_data ||= {}
+          @neo4j_enum_data[property_name] = enum_keys
+          define_property(property_name, enum_keys, options)
+          define_enum_methods(property_name, enum_keys, options)
+        end
+      end
+
+      protected
+
+      def normalize_key_list(enum_keys)
+        case enum_keys
+        when Hash
+          enum_keys
+        when Array
+          Hash[enum_keys.each_with_index.to_a]
+        else
+          fail ArgumentError, 'Invalid parameter for enum. Please provide an Array or an Hash.'
+        end
+      end
+
+      VALID_OPTIONS_FOR_ENUMS = [:_index, :_prefix, :_suffix, :_default]
+      DEFAULT_OPTIONS_FOR_ENUMS = {
+        _index: true
+      }
+
+      def split_options_and_parameters(parameters)
+        options = DEFAULT_OPTIONS_FOR_ENUMS.clone
+        new_parameters = {}
+        parameters.each do |k, v|
+          if VALID_OPTIONS_FOR_ENUMS.include? k
+            options[k] = v
+          else
+            new_parameters[k] = v
+          end
+        end
+        [options, new_parameters]
+      end
+
+      def define_property(property_name, enum_keys, options)
+        property_options = build_property_options(enum_keys, options)
+        property property_name, property_options
+        serialize property_name, Neo4j::Shared::TypeConverters::EnumConverter.new(enum_keys, property_options)
+      end
+
+      def build_property_options(_enum_keys, options = {})
+        {
+          default: options[:_default]
+        }
+      end
+
+      def define_enum_methods(property_name, enum_keys, options)
+        define_enum_methods_?(property_name, enum_keys, options)
+        define_enum_methods_!(property_name, enum_keys, options)
+        define_class_methods(property_name, enum_keys)
+      end
+
+      def define_class_methods(property_name, enum_keys)
+        plural_property_name = property_name.to_s.pluralize.to_sym
+        define_singleton_method(plural_property_name) do
+          enum_keys
+        end
+      end
+
+      def define_enum_methods_?(property_name, enum_keys, options)
+        enum_keys.keys.each do |enum_value|
+          method_name = build_method_name(enum_value, property_name, options)
+          check_enum_method_conflicts! property_name, :"#{method_name}?"
+          define_method("#{method_name}?") do
+            __send__(property_name).to_s.to_sym == enum_value
+          end
+        end
+      end
+
+      def define_enum_methods_!(property_name, enum_keys, options)
+        enum_keys.keys.each do |enum_value|
+          method_name = build_method_name(enum_value, property_name, options)
+          check_enum_method_conflicts! property_name, :"#{method_name}!"
+          define_method("#{method_name}!") do
+            __send__("#{property_name}=", enum_value)
+          end
+        end
+      end
+
+      def build_method_name(base_name, property_name, options)
+        method_name = base_name
+        method_name = "#{method_name}_#{property_name}" if options[:_suffix]
+        method_name = "#{options[:_prefix]}_#{method_name}" if options[:_prefix]
+        method_name
+      end
+
+      def check_enum_method_conflicts!(property_name, method_name)
+        fail ConflictingEnumMethodError,
+             "The enum `#{property_name}` is trying to define a `#{method_name}` method, "\
+             'that is already defined. Try to use options `:prefix` or `:suffix` '\
+             'to avoid conflicts.' if instance_methods(false).include?(method_name)
+      end
+    end
+  end
+end

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,28 @@
+module Neo4j::Shared
+  module Identity
+    def ==(other)
+      other.class == self.class && other.id == id
+    end
+    alias_method :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
+      id = neo_id
+      id.is_a?(Integer) ? id : nil
+    end
+
+    def hash
+      id.hash
+    end
+  end
+end

data/lib/neo4j/shared/initialize.rb

@@ -0,0 +1,28 @@
+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
+  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,58 @@
+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}="
+        send(writer, value) if respond_to?(writer)
+      end
+    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,231 @@
+module Neo4j::Shared
+  module Persistence
+    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 !changed_attributes || changed_attributes.empty?
+      _persisted_obj.update_props(props_for_update)
+      changed_attributes.clear
+    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)
+      send("#{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)
+      send("#{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
+      if result == false
+        Neo4j::Transaction.current.failure if Neo4j::Transaction.current
+        false
+      else
+        true
+      end
+    rescue => e
+      Neo4j::Transaction.current.failure if Neo4j::Transaction.current
+      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) 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_method :new?, :new_record?
+
+    def destroy
+      freeze
+      _persisted_obj && _persisted_obj.del
+      @_deleted = true
+    end
+
+    def exist?
+      _persisted_obj && _persisted_obj.exist?
+    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 && 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.attributes = process_attributes(attributes)
+      save
+    end
+    alias_method :update_attributes, :update
+
+    # Same as {#update_attributes}, but raises an exception if saving fails.
+    def update!(attributes)
+      self.attributes = process_attributes(attributes)
+      save!
+    end
+    alias_method :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
+
+    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
+      changed_attributes.delete(attribute)
+      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