lib/transcriber/resource/parser/embeddable.rb in transcriber-0.0.17 vs lib/transcriber/resource/parser/embeddable.rb in transcriber-0.0.18

@@ -1,51 +1,58 @@
 module Transcriber
   class Resource
     module Parser
       module Embeddable
         def parse(item, resource = nil)
-          value = nil
-          if fields
-            value = convert_input_keys.call(fields).map {|field| item[field]}
-          else
-            value = digg(item)
-            parsed_value = raw? ? value : resource_class.parse(value)
-            value = one? ? parsed_value.first : parsed_value
-          end
+          return parse_fields(item) if fields
+          value = digg(item)
+          parsed_value = raw? ? value : resource_class.parse(value)
+          one? ? parsed_value.first : parsed_value
         end
 
+        def parse_fields(item)
+          convert_input_keys.call(fields).map {|field| item[field]}
+        end
+
         def digg(input)
           input_path.inject(input) {|buffer, key| buffer = buffer[key]}
         end
 
         def from_hash(attrs)
           raw? ? attrs : super
         end
 
         def to_input(value, options = {})
-          input = {}
-          return input if value.nil?
+          return {} if value.nil?
+          fields ? to_multiple_input(value, options)
+                 : to_single_input(value)
+        end
 
+        private
+
+        def to_single_input(value)
+          input = {}
           path = input_path
 
           if path.any?
             last = path.pop
             key_input = path.inject(input) {|buffer, key| buffer[key] = {}; buffer[key]}
-
-            if fields
-              mapped_fields = convert_input_keys.call(fields)
-              value.each_with_index do |item, index|
-                input[mapped_fields[index]] = item
-              end
-            elsif raw?
-              key_input[last] = value
-            elsif one?
-              key_input[last] = value.to_input(options)
-            else
-              key_input[last] = value.map {|item| item.to_input(options)}
-            end
+            key_input[last] = raw? ? value
+                                   : one? ? value.to_input(options)
+                                          : value.map {|item| item.to_input(options)}
           else
             input.merge!(value.to_input(options))
+          end
+
+          input
+        end
+
+        def to_multiple_input(value, options)
+          input = {}
+          mapped_fields = convert_input_keys.call(fields)
+
+          value.each_with_index do |item, index|
+            input[mapped_fields[index]] = item
           end
 
           input
         end
       end