neo4j_legacy 7.2.0.1

data/lib/neo4j/shared/type_converters.rb

@@ -0,0 +1,418 @@
+require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'active_support/core_ext/big_decimal/conversions'
+require 'active_support/core_ext/string/conversions'
+
+module Neo4j::Shared
+  class Boolean; end
+
+  module TypeConverters
+    CONVERTERS = {}
+
+    class Boolean; end
+
+    class BaseConverter
+      class << self
+        def converted?(value)
+          value.is_a?(db_type)
+        end
+      end
+
+      def supports_array?
+        false
+      end
+    end
+
+    class IntegerConverter < BaseConverter
+      class << self
+        def convert_type
+          Integer
+        end
+
+        def db_type
+          Integer
+        end
+
+        def to_db(value)
+          value.to_i
+        end
+
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class FloatConverter < BaseConverter
+      class << self
+        def convert_type
+          Float
+        end
+
+        def db_type
+          Float
+        end
+
+        def to_db(value)
+          value.to_f
+        end
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class BigDecimalConverter < BaseConverter
+      class << self
+        def convert_type
+          BigDecimal
+        end
+
+        def db_type
+          BigDecimal
+        end
+
+        def to_db(value)
+          case value
+          when Rational
+            value.to_f.to_d
+          when respond_to?(:to_d)
+            value.to_d
+          else
+            BigDecimal.new(value.to_s)
+          end
+        end
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class StringConverter < BaseConverter
+      class << self
+        def convert_type
+          String
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          value.to_s
+        end
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    class BooleanConverter < BaseConverter
+      FALSE_VALUES = %w(n N no No NO false False FALSE off Off OFF f F)
+
+      class << self
+        def converted?(value)
+          converted_values.include?(value)
+        end
+
+        def converted_values
+          [true, false]
+        end
+
+        def db_type
+          Neo4j::Shared::Boolean
+        end
+
+        alias_method :convert_type, :db_type
+
+        def to_db(value)
+          return false if FALSE_VALUES.include?(value)
+          case value
+          when TrueClass, FalseClass
+            value
+          when Numeric, /^\-?[0-9]/
+            !value.to_f.zero?
+          else
+            value.present?
+          end
+        end
+
+        alias_method :to_ruby, :to_db
+      end
+    end
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter < BaseConverter
+      class << self
+        def convert_type
+          Date
+        end
+
+        def db_type
+          Integer
+        end
+
+        def to_db(value)
+          Time.utc(value.year, value.month, value.day).to_i
+        end
+
+        def to_ruby(value)
+          value.respond_to?(:to_date) ? value.to_date : Time.at(value).utc.to_date
+        end
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter < BaseConverter
+      class << self
+        def convert_type
+          DateTime
+        end
+
+        def db_type
+          Integer
+        end
+
+        # Converts the given DateTime (UTC) value to an Integer.
+        # DateTime values are automatically converted to UTC.
+        def to_db(value)
+          value = value.new_offset(0) if value.respond_to?(:new_offset)
+
+          args = [value.year, value.month, value.day]
+          args += (value.class == Date ? [0, 0, 0] : [value.hour, value.min, value.sec])
+
+          Time.utc(*args).to_i
+        end
+
+        def to_ruby(value)
+          return value if value.is_a?(DateTime)
+          t = case value
+              when Time
+                return value.to_datetime.utc
+              when Integer
+                Time.at(value).utc
+              when String
+                return value.to_datetime
+              else
+                fail ArgumentError, "Invalid value type for DateType property: #{value.inspect}"
+              end
+
+          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        end
+      end
+    end
+
+    class TimeConverter < BaseConverter
+      class << self
+        def convert_type
+          Time
+        end
+
+        def db_type
+          Integer
+        end
+
+        # Converts the given DateTime (UTC) value to an Integer.
+        # Only utc times are supported !
+        def to_db(value)
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            value.utc.to_i
+          end
+        end
+
+        def to_ruby(value)
+          Time.at(value).utc
+        end
+      end
+    end
+
+    # Converts hash to/from YAML
+    class YAMLConverter < BaseConverter
+      class << self
+        def convert_type
+          Hash
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          Psych.dump(value)
+        end
+
+        def to_ruby(value)
+          Psych.load(value)
+        end
+      end
+    end
+
+    # Converts hash to/from JSON
+    class JSONConverter < BaseConverter
+      class << self
+        def convert_type
+          JSON
+        end
+
+        def db_type
+          String
+        end
+
+        def to_db(value)
+          value.to_json
+        end
+
+        def to_ruby(value)
+          JSON.parse(value, quirks_mode: true)
+        end
+      end
+    end
+
+    class EnumConverter
+      def initialize(enum_keys, options)
+        @enum_keys = enum_keys
+        @options = options
+      end
+
+      def converted?(value)
+        value.is_a?(db_type)
+      end
+
+      def supports_array?
+        true
+      end
+
+      def db_type
+        Integer
+      end
+
+      def convert_type
+        Symbol
+      end
+
+      def to_ruby(value)
+        @enum_keys.key(value) unless value.nil?
+      end
+
+      alias_method :call, :to_ruby
+
+      def to_db(value)
+        if value.is_a?(Array)
+          value.map(&method(:to_db))
+        else
+          @enum_keys[value.to_s.to_sym] || 0
+        end
+      end
+    end
+
+    class ObjectConverter < BaseConverter
+      class << self
+        def convert_type
+          Object
+        end
+
+        def to_ruby(value)
+          value
+        end
+      end
+    end
+
+
+    # Modifies a hash's values to be of types acceptable to Neo4j or matching what the user defined using `type` in property definitions.
+    # @param [Neo4j::Shared::Property] obj A node or rel that mixes in the Property module
+    # @param [Symbol] medium Indicates the type of conversion to perform.
+    # @param [Hash] properties A hash of symbol-keyed properties for conversion.
+    def convert_properties_to(obj, medium, properties)
+      direction = medium == :ruby ? :to_ruby : :to_db
+      properties.each_pair do |key, value|
+        next if skip_conversion?(obj, key, value)
+        properties[key] = convert_property(key, value, direction)
+      end
+    end
+
+    # Converts a single property from its current format to its db- or Ruby-expected output type.
+    # @param [Symbol] key A property declared on the model
+    # @param value The value intended for conversion
+    # @param [Symbol] direction Either :to_ruby or :to_db, indicates the type of conversion to perform
+    def convert_property(key, value, direction)
+      converted_property(primitive_type(key.to_sym), value, direction)
+    end
+
+    def supports_array?(key)
+      type = primitive_type(key.to_sym)
+      type.respond_to?(:supports_array?) && type.supports_array?
+    end
+
+    def typecaster_for(value)
+      Neo4j::Shared::TypeConverters.typecaster_for(value)
+    end
+
+    def typecast_attribute(typecaster, value)
+      Neo4j::Shared::TypeConverters.typecast_attribute(typecaster, value)
+    end
+
+    private
+
+    def converted_property(type, value, direction)
+      return nil if value.nil?
+      type.respond_to?(:db_type) || TypeConverters::CONVERTERS[type] ? TypeConverters.to_other(direction, value, type) : value
+    end
+
+    # If the attribute is to be typecast using a custom converter, which converter should it use? If no, returns the type to find a native serializer.
+    def primitive_type(attr)
+      case
+      when self.serialized_properties_keys.include?(attr)
+        serialized_properties[attr]
+      when self.magic_typecast_properties_keys.include?(attr)
+        self.magic_typecast_properties[attr]
+      else
+        self.fetch_upstream_primitive(attr)
+      end
+    end
+
+    # Returns true if the property isn't defined in the model or if it is nil
+    def skip_conversion?(obj, attr, value)
+      !obj.class.attributes[attr] || value.nil?
+    end
+
+    class << self
+      def included(_)
+        Neo4j::Shared::TypeConverters.constants.each do |constant_name|
+          constant = Neo4j::Shared::TypeConverters.const_get(constant_name)
+          register_converter(constant) if constant.respond_to?(:convert_type)
+        end
+      end
+
+      def typecast_attribute(typecaster, value)
+        fail ArgumentError, "A typecaster must be given, #{typecaster} is invalid" unless typecaster.respond_to?(:to_ruby)
+        return value if value.nil?
+        typecaster.to_ruby(value)
+      end
+
+      def typecaster_for(primitive_type)
+        return nil if primitive_type.nil?
+        CONVERTERS[primitive_type]
+      end
+
+      # @param [Symbol] direction either :to_ruby or :to_other
+      def to_other(direction, value, type)
+        fail "Unknown direction given: #{direction}" unless direction == :to_ruby || direction == :to_db
+        found_converter = converter_for(type)
+        return value unless found_converter
+        return value if direction == :to_db && formatted_for_db?(found_converter, value)
+        found_converter.send(direction, value)
+      end
+
+      def converter_for(type)
+        type.respond_to?(:db_type) ? type : CONVERTERS[type]
+      end
+
+      # Attempts to determine whether conversion should be skipped because the object is already of the anticipated output type.
+      # @param [#convert_type] found_converter An object that responds to #convert_type, hinting that it is a type converter.
+      # @param value The value for conversion.
+      def formatted_for_db?(found_converter, value)
+        return false unless found_converter.respond_to?(:db_type)
+        found_converter.respond_to?(:converted) ? found_converter.converted?(value) : value.is_a?(found_converter.db_type)
+      end
+
+      def register_converter(converter)
+        CONVERTERS[converter.convert_type] = converter
+      end
+    end
+  end
+end

data/lib/neo4j/shared/typecasted_attributes.rb

@@ -0,0 +1,98 @@
+module Neo4j::Shared
+  # TypecastedAttributes allows types to be declared for your attributes
+  #
+  # Types are declared by passing the :type option to the attribute class
+  # method. After a type is declared, attribute readers will convert any
+  # assigned attribute value to the declared type. If the assigned value
+  # cannot be cast, nil will be returned instead. You can access the original
+  # assigned value using the before_type_cast methods.
+  #
+  # See {Typecasting} for the currently supported types.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::TypecastedAttributes
+  #     attribute :age, :type => Integer
+  #   end
+  #
+  #   person = Person.new
+  #   person.age = "29"
+  #   person.age #=> 29
+  #   person.age_before_type_cast #=> "29"
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module TypecastedAttributes
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Attributes
+
+    included do
+      attribute_method_suffix '_before_type_cast'
+    end
+
+    # Read the raw attribute value
+    #
+    # @example Reading a raw age value
+    #   person.age = "29"
+    #   person.attribute_before_type_cast(:age) #=> "29"
+    #
+    # @param [String, Symbol, #to_s] name Attribute name
+    #
+    # @return [Object, nil] The attribute value before typecasting
+    def attribute_before_type_cast(name)
+      @attributes ||= {}
+      @attributes[name.to_s]
+    end
+
+    private
+
+    # Reads the attribute and typecasts the result
+    def attribute(name)
+      typecast_attribute(_attribute_typecaster(name), super)
+    end
+
+    def typecast_attribute(typecaster, value)
+      self.class.typecast_attribute(typecaster, value)
+    end
+
+    # Calculates an attribute type
+    #
+    # @private
+    def _attribute_type(attribute_name)
+      self.class._attribute_type(attribute_name)
+    end
+
+    # Resolve an attribute typecaster
+    #
+    # @private
+    def _attribute_typecaster(attribute_name)
+      type = _attribute_type(attribute_name)
+      caster = self.class.attributes[attribute_name].typecaster || Neo4j::Shared::TypeConverters.typecaster_for(type)
+      caster || fail(Neo4j::UnknownTypeConverterError, "Unable to cast to type #{type}")
+    end
+
+    module ClassMethods
+      # Returns the class name plus its attribute names and types
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      # @return [String] Human-readable presentation of the attributes
+      def inspect
+        inspected_attributes = attribute_names.sort.map { |name| "#{name}: #{_attribute_type(name)}" }
+        attributes_list = "(#{inspected_attributes.join(', ')})" unless inspected_attributes.empty?
+        "#{name}#{attributes_list}"
+      end
+
+      # Calculates an attribute type
+      #
+      # @private
+      def _attribute_type(attribute_name)
+        attributes[attribute_name].type || Object
+      end
+
+      def typecast_attribute(typecaster, value)
+        Neo4j::Shared::TypeConverters.typecast_attribute(typecaster, value)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/typecaster.rb

@@ -0,0 +1,53 @@
+module Neo4j
+  module Shared
+    # This module provides a convenient way of registering a custom Typecasting class. Custom Typecasters all follow a simple pattern.
+    #
+    # EXAMPLE:
+    #
+    # .. code-block:: ruby
+    #
+    #   class RangeConverter
+    #     class << self
+    #       def primitive_type
+    #         String
+    #       end
+    #
+    #       def convert_type
+    #         Range
+    #       end
+    #
+    #       def to_db(value)
+    #         value.to_s
+    #       end
+    #
+    #       def to_ruby(value)
+    #         ends = value.to_s.split('..').map { |d| Integer(d) }
+    #         ends[0]..ends[1]
+    #       end
+    #       alias_method :call, :to_ruby
+    #     end
+    #
+    #     include Neo4j::Shared::Typecaster
+    #   end
+    #
+    # This would allow you to use `property :my_prop, type: Range` in a model.
+    # Each method and the `alias_method` call is required. Make sure the module inclusion happens at the end of the file.
+    #
+    # `primitive_type` is used to fool ActiveAttr's type converters, which only recognize a few basic Ruby classes.
+    #
+    # `convert_type` must match the constant given to the `type` option.
+    #
+    # `to_db` provides logic required to transform your value into the class defined by `primitive_type`
+    #
+    # `to_ruby` provides logic to transform the DB-provided value back into the class expected by code using the property.
+    # In other words, it should match the `convert_type`.
+    #
+    # Note that `alias_method` is used to make `to_ruby` respond to `call`. This is to provide compatibility with ActiveAttr.
+
+    module Typecaster
+      def self.included(other)
+        Neo4j::Shared::TypeConverters.register_converter(other)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/validations.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module Shared
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      # Implements the ActiveModel::Validation hook method.
+      # @see http://rubydoc.info/docs/rails/ActiveModel/Validations:read_attribute_for_validation
+      def read_attribute_for_validation(key)
+        respond_to?(key) ? send(key) : self[key]
+      end
+
+      # 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.
+      # @param [Hash] options the options to create a message with.
+      # @option options [true, false] :validate if false no validation will take place
+      # @return [Boolean] true if it saved it successfully
+      def save(options = {})
+        result = perform_validations(options) ? super : false
+        if !result
+          Neo4j::Transaction.current.failure if Neo4j::Transaction.current
+        end
+        result
+      end
+
+      # @return [Boolean] true if valid
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
+        errors.empty?
+      end
+
+      private
+
+      def perform_validations(options = {})
+        perform_validation = case options
+                             when Hash
+                               options[:validate] != false
+                             end
+
+        if perform_validation
+          valid?(options.is_a?(Hash) ? options[:context] : nil)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/shared.rb

@@ -0,0 +1,51 @@
+module Neo4j
+  module Shared
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+
+    include ActiveModel::Conversion
+    begin
+    include ActiveModel::Serializers::Xml
+    rescue NameError; end # rubocop:disable Lint/HandleExceptions
+    include ActiveModel::Serializers::JSON
+
+    module ClassMethods
+      attr_writer :neo4j_session_name
+
+      def neo4j_session_name(name)
+        ActiveSupport::Deprecation.warn 'neo4j_session_name is deprecated and may be removed from future releases, use neo4j_session_name= instead.', caller
+
+        @neo4j_session_name = name
+      end
+
+      def neo4j_session
+        if @neo4j_session_name
+          Neo4j::Session.named(@neo4j_session_name) ||
+            fail("#{self.name} is configured to use a neo4j session named #{@neo4j_session_name}, but no such session is registered with Neo4j::Session")
+        else
+          Neo4j::Session.current!
+        end
+      end
+    end
+
+    included do
+      self.include_root_in_json = Neo4j::Config.include_root_in_json
+      @_declared_properties ||= Neo4j::Shared::DeclaredProperties.new(self)
+
+      def self.i18n_scope
+        :neo4j
+      end
+
+      def self.inherited(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
+        super
+      end
+    end
+
+    def declared_properties
+      self.class.declared_properties
+    end
+  end
+end

data/lib/neo4j/tasks/migration.rake

@@ -0,0 +1,24 @@
+require 'neo4j/migration'
+
+namespace :neo4j do
+  desc 'Run a script against the database to perform system-wide changes'
+  task :migrate, [:task_name, :subtask] => :environment do |_, args|
+    path = Rake.original_dir
+    migration_task = args[:task_name]
+    task_name_constant = migration_task.split('_').map(&:capitalize).join('')
+    begin
+      migration_class = "Neo4j::Migration::#{task_name_constant}".constantize
+    rescue NameError
+      load File.join(path, 'db', 'neo4j-migrate', "#{migration_task}.rb")
+      migration_class = "#{task_name_constant}".constantize
+    end
+    migration = migration_class.new(path)
+
+    subtask = args[:subtask]
+    if subtask
+      migration.send(subtask)
+    else
+      migration.migrate
+    end
+  end
+end

data/lib/neo4j/timestamps/created.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module Timestamps
+    # This mixin includes a created_at timestamp property
+    module Created
+      extend ActiveSupport::Concern
+      included { property :created_at }
+    end
+  end
+end

data/lib/neo4j/timestamps/updated.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module Timestamps
+    # This mixin includes a updated_at timestamp property
+    module Updated
+      extend ActiveSupport::Concern
+      included { property :updated_at }
+    end
+  end
+end