Module: Neo4j::Shared::TypeConverters

Included in:
DeclaredProperties, TypeConverters
Defined in:
lib/neo4j/shared/type_converters.rb

Defined Under Namespace

Classes: BaseConverter, BigDecimalConverter, Boolean, BooleanConverter, DateConverter, DateTimeConverter, EnumConverter, FloatConverter, IntegerConverter, JSONConverter, ObjectConverter, StringConverter, TimeConverter, YAMLConverter

Constant Summary collapse

CONVERTERS = 
{}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.converter_for(type) ⇒ Object 



416
417
418
 
# File 'lib/neo4j/shared/type_converters.rb', line 416

def converter_for(type)
  type.respond_to?(:db_type) ? type : CONVERTERS[type]
end

.formatted_for_db?(found_converter, value) ⇒ Boolean

Attempts to determine whether conversion should be skipped because the object is already of the anticipated output type.

Parameters:

  • found_converter (#convert_type) —

    An object that responds to #convert_type, hinting that it is a type converter.

  • value —

    The value for conversion.

Returns:



423
424
425
426
 
# File 'lib/neo4j/shared/type_converters.rb', line 423

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

.included(_) ⇒ Object 



389
390
391
392
393
394
 
# File 'lib/neo4j/shared/type_converters.rb', line 389

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

.register_converter(converter) ⇒ Object 



428
429
430
 
# File 'lib/neo4j/shared/type_converters.rb', line 428

def register_converter(converter)
  CONVERTERS[converter.convert_type] = converter
end

.to_other(direction, value, type) ⇒ Object

Parameters:

  • direction (Symbol) —

    either :to_ruby or :to_other



408
409
410
411
412
413
414
 
# File 'lib/neo4j/shared/type_converters.rb', line 408

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

.typecast_attribute(typecaster, value) ⇒ Object 



396
397
398
399
400
 
# File 'lib/neo4j/shared/type_converters.rb', line 396

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

.typecaster_for(primitive_type) ⇒ Object 



402
403
404
405
 
# File 'lib/neo4j/shared/type_converters.rb', line 402

def typecaster_for(primitive_type)
  return nil if primitive_type.nil?
  CONVERTERS[primitive_type]
end

Instance Method Details

#convert_properties_to(obj, medium, properties) ⇒ Object

Modifies a hash’s values to be of types acceptable to Neo4j or matching what the user defined using ‘type` in property definitions.

Parameters:

  • obj (Neo4j::Shared::Property) —

    A node or rel that mixes in the Property module

  • medium (Symbol) —

    Indicates the type of conversion to perform.

  • properties (Hash) —

    A hash of symbol-keyed properties for conversion.



335
336
337
338
339
340
341
 
# File 'lib/neo4j/shared/type_converters.rb', line 335

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

#convert_property(key, value, direction) ⇒ Object

Converts a single property from its current format to its db- or Ruby-expected output type.

Parameters:

  • key (Symbol) —

    A property declared on the model

  • value —

    The value intended for conversion

  • direction (Symbol) —

    Either :to_ruby or :to_db, indicates the type of conversion to perform



347
348
349
 
# File 'lib/neo4j/shared/type_converters.rb', line 347

def convert_property(key, value, direction)
  converted_property(primitive_type(key.to_sym), value, direction)
end

#supports_array?(key) ⇒ Boolean

Returns:



351
352
353
354
 
# File 'lib/neo4j/shared/type_converters.rb', line 351

def supports_array?(key)
  type = primitive_type(key.to_sym)
  type.respond_to?(:supports_array?) && type.supports_array?
end

#typecast_attribute(typecaster, value) ⇒ Object 



360
361
362
 
# File 'lib/neo4j/shared/type_converters.rb', line 360

def typecast_attribute(typecaster, value)
  Neo4j::Shared::TypeConverters.typecast_attribute(typecaster, value)
end

#typecaster_for(value) ⇒ Object 



356
357
358
 
# File 'lib/neo4j/shared/type_converters.rb', line 356

def typecaster_for(value)
  Neo4j::Shared::TypeConverters.typecaster_for(value)
end