Working on reducing complexity of functions

lib/neo4j-core/query_clauses.rb

@@ -50,41 +50,53 @@ def from_string(value)
         end
 
         def node_from_key_and_value(key, value, options = {})
-          var, label_string, attributes = parse_node_from_key_and_value(key, value, options)
+          var = var_from_key_and_value(key, value, options[:prefer] || :var)
+          label = label_from_key_and_value(key, value, options[:prefer] || :var)
+          attributes = attributes_from_key_and_value(key, value)
 
-          "(#{var}#{format_label(label_string)}#{attributes_string(attributes)})"
+          "(#{var}#{format_label(label)}#{attributes_string(attributes)})"
         end
 
-        def parse_node_from_key_and_value(key, value, options = {})
-          var, label_string, attributes = nil
-
+        def var_from_key_and_value(key, value, prefer = :var)
           case value
-          when String, Symbol
-            var, label_string = [key, value]
-          when Class, Module
-            var, label_string = [key, defined?(value::CYPHER_LABEL) ? value::CYPHER_LABEL : value.name]
+          when String, Symbol, Class, Module
+            key
           when Hash
-            if !value.values.any? { |v| v.is_a?(Hash) }
-              case options[:prefer] || :var
-              when :var
-                var = key
-              when :label
-                label_string = key
-              end
+            if value.values.none? { |v| v.is_a?(Hash) }
+              key if prefer == :var
             else
-              var = key
+              key
             end
+          else
+            fail ArgError, value
+          end
+        end
 
-            if value.size == 1 && value.values.first.is_a?(Hash)
-              label_string, attributes = value.first
+        def label_from_key_and_value(key, value, prefer = :var)
+          case value
+          when String, Symbol
+            value
+          when Class, Module
+            defined?(value::CYPHER_LABEL) ? value::CYPHER_LABEL : value.name
+          when Hash
+            if value.values.map(&:class) == [Hash]
+              value.first.first
             else
-              attributes = value
+              key if value.values.none? { |v| v.is_a?(Hash) } && prefer == :label
             end
           else
             fail ArgError, value
           end
+        end
+
+        def attributes_from_key_and_value(key, value)
+          return nil unless value.is_a?(Hash)
 
-          [var, label_string, attributes]
+          if value.values.map(&:class) == [Hash]
+            value.first[1]
+          else
+            value
+          end
         end
 
         class << self

lib/neo4j-embedded/embedded_node.rb

@@ -149,13 +149,14 @@ def rel(match = {})
           tx_methods :rel
 
           def _rel(match = {})
-            dir = match[:dir] || :both
+            dir = ToJava.dir_to_java(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))
+                    get_single_relationship(ToJava.type_to_java(rel_type), dir)
                   else
-                    iter = get_relationships(ToJava.dir_to_java(dir)).iterator
+                    iter = get_relationships(dir).iterator
+
                     if iter.has_next
                       first = iter.next
                       fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
@@ -166,7 +167,7 @@ def _rel(match = {})
             between_id = match[:between] && match[:between].neo_id
 
             if rel && between_id
-              rel.other_node(self).neo_id == between_id ? rel : nil
+              rel if rel.other_node(self).neo_id == between_id
             else
               rel
             end

lib/neo4j-server/cypher_response.rb

@@ -76,14 +76,14 @@ def map_row_value(value, session)
       def hash_value_as_object(value, session)
         return value unless value['labels'] || value['type'] || transaction_response?
 
-        obj_type, data =  if transaction_response?
-                            add_transaction_entity_id
-                            [(mapped_rest_data['start'] ? CypherRelationship : CypherNode), mapped_rest_data]
-                          elsif value['labels'] || value['type']
-                            add_entity_id(value)
-                            [(value['labels'] ? CypherNode : CypherRelationship), value]
-                          end
-        obj_type.new(session, data).wrapper
+        is_node, data =  if transaction_response?
+                           add_transaction_entity_id
+                           [!mapped_rest_data['start'], mapped_rest_data]
+                         elsif value['labels'] || value['type']
+                           add_entity_id(value)
+                           [value['labels'], value]
+                         end
+        (is_node ? CypherNode : CypherRelationship).new(session, data).wrapper
       end
 
       attr_reader :struct
@@ -114,7 +114,7 @@ def first_data(id = nil)
       end
 
       def add_entity_id(data)
-        data.merge!('id' => data['self'].split('/')[-1].to_i)
+        data.merge!('id' => self.class.id_from_url(data['self']))
       end
 
       def add_transaction_entity_id
@@ -206,6 +206,12 @@ def rest_data_with_id
         rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
       end
 
+      class << self
+        def id_from_url(url)
+          url.split('/')[-1].to_i
+        end
+      end
+
       private
 
       attr_reader :row_index