Class: Neo4j::Embedded::EmbeddedNode

Inherits:
Object
  • Object
show all
Defined in:
lib/neo4j-embedded/embedded_node.rb

Class Method Summary collapse

Class Method Details

.extend_java_class(java_clazz) ⇒ Object

This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/neo4j-embedded/embedded_node.rb', line 53

def extend_java_class(java_clazz)
  java_clazz.class_eval do
    include Neo4j::Embedded::Property
    include Neo4j::EntityEquality
    include Neo4j::Core::ActiveEntity
    extend Neo4j::Core::TxMethods

    def inspect
      "EmbeddedNode neo_id: #{neo_id}"
    end

    def exist?
      !!graph_database.get_node_by_id(neo_id)
    rescue Java::OrgNeo4jGraphdb.NotFoundException
      false
    end
    tx_methods :exist?

    def labels
      _labels.iterator.map{|x| x.name.to_sym}
    end
    tx_methods :labels

    alias_method :_labels, :getLabels

    def _java_label(label_name)
      Java::OrgNeo4jGraphdb.DynamicLabel.label(label_name)
    end

    def _add_label(*label_name)
      label_name.each do |name|
        addLabel(_java_label(name))
      end
    end

    alias_method :add_label, :_add_label
    tx_methods :add_label

    def _remove_label(*label_name)
      label_name.each do |name|
        removeLabel(_java_label(name))
      end
    end

    alias_method :remove_label, :_remove_label
    tx_methods :remove_label

    def set_label(*label_names)
      label_as_symbols = label_names.map(&:to_sym)
      to_keep = labels & label_as_symbols
      to_remove = labels - to_keep
      _remove_label(*to_remove)
      to_add = label_as_symbols - to_keep
      _add_label(*to_add)
    end
    tx_methods :set_label

    def del
      _rels.each { |r| r.del }
      delete
      nil
    end
    tx_methods :del

    def create_rel(type, other_node, props = nil)
      rel = create_relationship_to(other_node.neo4j_obj, ToJava.type_to_java(type))
      props.each_pair { |k, v| rel[k] = v } if props
      rel
    end
    tx_methods :create_rel


    def rels(match={})
      RelsIterator.new(self, match)
    end

    def nodes(match={})
      NodesIterator.new(self, match)
    end

    def node(match={})
      rel = _rel(match)
      rel && rel.other_node(self).wrapper
    end
    tx_methods :node

    def rel?(match={})
      _rels(match).has_next
    end
    tx_methods :rel?

    def rel(match={})
      _rel(match)
    end
    tx_methods :rel

    def _rel(match={})
      dir = match[:dir] || :both
      rel_type = match[:type]

      rel = if rel_type
               get_single_relationship(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir))
            else
               iter = get_relationships(ToJava.dir_to_java(dir)).iterator
               if (iter.has_next)
                 first = iter.next
                 raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
                 first
               end
             end

      between_id = match[:between] && match[:between].neo_id

      if (rel && between_id)
        rel.other_node(self).neo_id == between_id ? rel : nil
      else
        rel
      end
    end

    def _rels(match={})
      dir = match[:dir] || :both
      rel_type = match[:type]

      rels = if rel_type
        get_relationships(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir)).iterator
      else
        get_relationships(ToJava.dir_to_java(dir)).iterator
      end

      between_id = match[:between] && match[:between].neo_id

      if (between_id)
        rels.find_all{|r| r.end_node.neo_id == between_id || r.start_node.neo_id == between_id}
      else
        rels
      end

    end

    def class
      Neo4j::Node
    end

    include Neo4j::Node::Wrapper
  end
end