Use instance based approach for Normalizer

lib/gitlab/ci/config/normalizer.rb

@@ -4,21 +4,24 @@ module Gitlab
   module Ci
     class Config
       class Normalizer
-        class << self
-          def normalize_jobs(jobs_config)
-            parallelized_config, parallelized_jobs = parallelize_jobs(jobs_config)
-            parallelize_dependencies(parallelized_config, parallelized_jobs)
+        def initialize(jobs_config)
+          @jobs_config = jobs_config
+        end
+
+        def normalize_jobs
+          parallelized_jobs = parallelize_jobs
+          parallelize_dependencies(parallelized_jobs)
         end
 
         private
 
-          def parallelize_jobs(jobs_config)
+        def parallelize_jobs
           parallelized_jobs = {}
 
-            parallelized_config = jobs_config.map do |name, config|
+          @jobs_config = @jobs_config.map do |name, config|
             if config[:parallel]
               total = config[:parallel]
-                names = parallelize_job_names(name, total)
+              names = self.class.parallelize_job_names(name, total)
               parallelized_jobs[name] = names.map(&:first)
               Hash[names.collect { |job_name, index| [job_name.to_sym, config.merge(name: job_name, instance: index)] }]
             else
@@ -26,11 +29,11 @@ module Gitlab
             end
           end.reduce(:merge)
 
-            [parallelized_config, parallelized_jobs]
+          parallelized_jobs
         end
 
-          def parallelize_dependencies(jobs_config, parallelized_jobs)
-            jobs_config.map do |name, config|
+        def parallelize_dependencies(parallelized_jobs)
+          @jobs_config.map do |name, config|
             if config[:dependencies]
               deps = config[:dependencies].map do |dep|
                 if parallelized_jobs.keys.include?(dep.to_sym)
@@ -47,15 +50,8 @@ module Gitlab
           end.reduce(:merge)
         end
 
-          def parallelize_job_names(name, total)
-            jobs = []
-
-            1.upto(total) do |idx|
-              jobs << ["#{name} #{idx}/#{total}", idx]
-            end
-
-            jobs
-          end
+        def self.parallelize_job_names(name, total)
+          Array.new(total) { |index| ["#{name} #{index + 1}/#{total}", index + 1] }
         end
       end
     end

lib/gitlab/ci/yaml_processor.rb

@@ -104,7 +104,7 @@ module Gitlab
         ##
         # Jobs
         #
-        @jobs = Ci::Config::Normalizer.normalize_jobs(@ci_config.jobs)
+        @jobs = Ci::Config::Normalizer.new(@ci_config.jobs).normalize_jobs
 
         @jobs.each do |name, job|
           # logical validation for job

spec/lib/gitlab/ci/config/normalizer_spec.rb

@@ -8,7 +8,7 @@ describe Gitlab::Ci::Config::Normalizer do
   let(:config) { { job_name => job_config } }
 
   describe '.normalize_jobs' do
-    subject { described_class.normalize_jobs(config) }
+    subject { described_class.new(config).normalize_jobs }
 
     it 'does not have original job' do
       is_expected.not_to include(job_name)