Module: Neo4j::Core::Property

Included in:
Node, Relationship
Defined in:
lib/neo4j-core/property/java.rb,
lib/neo4j-core/property/property.rb

Defined Under Namespace

Modules: Java

Instance Method Summary collapse

Instance Method Details

#[](key) ⇒ Object

Returns the value of the given key or nil if the property does not exist.

Returns:

  • the value of the given key or nil if the property does not exist.



66
67
68
69
70
 
# File 'lib/neo4j-core/property/property.rb', line 66

def [](key)
  return unless property?(key)
  val = get_property(key.to_s)
  val.class.superclass == ArrayJavaProxy ? val.to_a : val
end

#[]=(key, value) ⇒ Object

Sets the property of this node. Property keys are always strings. Valid property value types are the primitives(String, Fixnum, Float, FalseClass, TrueClass) or array of those primitives.

Gotchas

  • Values in the array must be of the same type.

  • You can not delete or add one item in the array (e.g. person.phones.delete(‘123’)) but instead you must create a new array instead.

Parameters:

  • key (String, Symbol) —

    of the property to set

  • value (String, Fixnum, Float, true, false, Array) —

    to set



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/neo4j-core/property/property.rb', line 81

def []=(key, value)
  k = key.to_s
  if value.nil?
    remove_property(k)
  elsif (Array === value)
    case value[0]
      when NilClass
        set_property(k, [].to_java(:string))
      when String
        set_property(k, value.to_java(:string))
      when Float
        set_property(k, value.to_java(:double))
      when FalseClass, TrueClass
        set_property(k, value.to_java(:boolean))
      when Fixnum
        set_property(k, value.to_java(:long))
      else
        raise "Not allowed to store array with value #{value[0]} type #{value[0].class}"
    end
  else
    set_property(k, value)
  end
end

#neo_id ⇒ Fixnum

Ids are garbage collected over time so they are only guaranteed to be unique during a specific time span: if the node is deleted, it’s likely that a new node at some point will get the old id. Note: this makes node ids brittle as public APIs.

Returns:

  • (Fixnum) —

    the unique id of this node.



18
19
20
 
# File 'lib/neo4j-core/property/property.rb', line 18

def neo_id
  getId
end

#property?(key) ⇒ true false

Returns true if the given key exist as a property.

Parameters:

  • the (#to_s) —

    property we want to check if it exist.

Returns:

  • (true false) —

    true if the given key exist as a property.



24
25
26
 
# File 'lib/neo4j-core/property/property.rb', line 24

def property?(key)
  has_property?(key.to_s)
end

#props ⇒ Hash

Returns all properties plus the id of the node with the key _neo_id.

Returns:

  • (Hash) —

    all properties plus the id of the node with the key _neo_id



6
7
8
9
10
11
12
 
# File 'lib/neo4j-core/property/property.rb', line 6

def props
  ret = {"_neo_id" => neo_id}
  property_keys.each do |key|
    ret[key] = get_property(key)
  end
  ret
end

#protected_keys ⇒ Object 



61
62
63
 
# File 'lib/neo4j-core/property/property.rb', line 61

def protected_keys

end

#update(struct_or_hash, options = {}) ⇒ Object

Updates this node/relationship’s properties by using the provided struct/hash. If the option {:strict => true} is given, any properties present on the node but not present in the hash will be removed from the node, except ‘_neo_id’ and ‘_classname’ (defined in Neo4j::Node.protected_keys). The option {:protected_keys => array of strings} is similar to the <code<:strict</code> option, except that it allows you to specify which keys will be protected from being updated or deleted. If neither the protected nor strict option is given then all properties starting with ‘_’ will never be touched.

Parameters:

  • struct_or_hash (Hash, :each_pair) —

    the key and value to be set

  • options (Hash) (defaults to: {}) —

    further options defining the context of the update

Options Hash (options):

  • :strict (Boolean) —

    any properties present on the node but not present in the hash will be removed from the node if true

  • :protected_keys (Array<String>) —

    the keys that never will be touched

Returns:

  • self



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/neo4j-core/property/property.rb', line 40

def update(struct_or_hash, options={})
  protected_keys = self.class.protected_keys if options[:strict]
  protected_keys ||= options[:protected_keys].map(&:to_s) if options[:protected_keys]
  keys_to_delete = props.keys - protected_keys if protected_keys

  struct_or_hash.each_pair do |k, value|
    key = k.to_s
    # do not allow special properties to be mass assigned
    if protected_keys
      keys_to_delete.delete(key)
      next if protected_keys.include?(key)
    else
      next if key[0..0] == '_'
    end

    self[key] = value
  end
  keys_to_delete.each { |key| remove_property(key) } if protected_keys
  self
end