more refactoring to import export reader

lib/gitlab/import_export/attributes_finder.rb

@@ -11,8 +11,9 @@ module Gitlab
         parsed_hash.empty? ? model_object : { model_object => parsed_hash }
       end
 
-      def find_attributes_only(value)
-        find_included(value).merge(find_excluded(value))
+      def parse(model_object)
+        parsed_hash = find_attributes_only(model_object)
+        yield parsed_hash unless parsed_hash.empty?
       end
 
       def find_included(value)
@@ -27,6 +28,10 @@ module Gitlab
 
       private
 
+      def find_attributes_only(value)
+        find_included(value).merge(find_excluded(value))
+      end
+
       def key_from_hash(value)
         value.is_a?(Hash) ? value.keys.first : value
       end

lib/gitlab/import_export/import_export_reader.rb

@@ -1,13 +1,13 @@
 module Gitlab
   module ImportExport
     class ImportExportReader
-      #FIXME
 
       def initialize(config: 'lib/gitlab/import_export/import_export.yml')
         config_hash = YAML.load_file(config).with_indifferent_access
         @tree = config_hash[:project_tree]
         @attributes_parser = Gitlab::ImportExport::AttributesFinder.new(included_attributes: config_hash[:included_attributes],
                                                                         excluded_attributes: config_hash[:excluded_attributes])
+        @json_config_hash = {}
       end
 
       def project_tree
@@ -19,51 +19,49 @@ module Gitlab
       def build_hash(model_list)
         model_list.map do |model_object_hash|
           if model_object_hash.is_a?(Hash)
-            process_model_object(model_object_hash)
+            build_json_config_hash(model_object_hash)
           else
             @attributes_parser.find(model_object_hash)
           end
         end
       end
 
-      def process_model_object(model_object_hash, included_classes_hash = {})
+      def build_json_config_hash(model_object_hash)
         model_object_hash.values.flatten.each do |model_object|
           current_key = model_object_hash.keys.first
-          model_object = process_current_class(model_object_hash, included_classes_hash, model_object)
-          if included_classes_hash[current_key]
-            add_to_class(current_key, included_classes_hash, model_object)
-          else
-            add_new_class(current_key, included_classes_hash, model_object)
-          end
+
+          @attributes_parser.parse(current_key) { |hash| @json_config_hash[current_key] ||= hash }
+
+          handle_model_object(current_key, model_object)
         end
-        included_classes_hash
+        @json_config_hash
       end
 
-      def process_current_class(hash, included_classes_hash, value)
-        value = value.is_a?(Hash) ? process_model_object(hash, included_classes_hash) : value
-        attributes_hash = @attributes_parser.find_attributes_only(hash.keys.first)
-        included_classes_hash[hash.keys.first] ||= attributes_hash unless attributes_hash.empty?
-        value
+      def handle_model_object(current_key, model_object)
+        if @json_config_hash[current_key]
+          add_model_value(current_key, model_object)
+        else
+          create_model_value(current_key, model_object)
+        end
       end
 
-      def add_new_class(current_key, included_classes_hash, value)
-        attributes_hash = @attributes_parser.find_attributes_only(value)
+      def create_model_value(current_key, value)
         parsed_hash = { include: value }
-        unless attributes_hash.empty?
-          if value.is_a?(Hash)
-            parsed_hash = { include: value.merge(attributes_hash) }
-          else
-            parsed_hash = { include: { value => attributes_hash } }
-          end
+
+        @attributes_parser.parse(value) do |hash|
+            parsed_hash = { include: hash_or_merge(value, hash) }
         end
-        included_classes_hash[current_key] = parsed_hash
+        @json_config_hash[current_key] = parsed_hash
       end
 
-      def add_to_class(current_key, included_classes_hash, value)
-        attributes_hash = @attributes_parser.find_attributes_only(value)
-        value = { value => attributes_hash } unless attributes_hash.empty?
-        old_values = included_classes_hash[current_key][:include]
-        included_classes_hash[current_key][:include] = ([old_values] + [value]).compact.flatten
+      def add_model_value(current_key, value)
+        @attributes_parser.parse(value) { |hash| value = { value => hash } }
+        old_values = @json_config_hash[current_key][:include]
+        @json_config_hash[current_key][:include] = ([old_values] + [value]).compact.flatten
+      end
+
+      def hash_or_merge(value, hash)
+        value.is_a?(Hash) ? value.merge(hash) : hash
       end
     end
   end