gitlab-ci-yaml_lint 0.1.0

data/gitlab_lib/gitlab/ci/config/entry/coverage.rb

@@ -0,0 +1,22 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents Coverage settings.
+        #
+        class Coverage < Node
+          include Validatable
+
+          validations do
+            validates :config, regexp: true
+          end
+
+          def value
+            @config[1...-1]
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/entry/environment.rb

@@ -0,0 +1,83 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents an environment.
+        #
+        class Environment < Node
+          include Validatable
+
+          ALLOWED_KEYS = %i[name url action on_stop].freeze
+
+          validations do
+            validate do
+              unless hash? || string?
+                errors.add(:config, 'should be a hash or a string')
+              end
+            end
+
+            validates :name, presence: true
+            validates :name,
+              type: {
+                with: String,
+                message: Gitlab::Regex.environment_name_regex_message
+              }
+
+            validates :name,
+              format: {
+                with: Gitlab::Regex.environment_name_regex,
+                message: Gitlab::Regex.environment_name_regex_message
+              }
+
+            with_options if: :hash? do
+              validates :config, allowed_keys: ALLOWED_KEYS
+
+              validates :url,
+                        length: { maximum: 255 },
+                        allow_nil: true
+
+              validates :action,
+                        inclusion: { in: %w[start stop], message: 'should be start or stop' },
+                        allow_nil: true
+
+              validates :on_stop, type: String, allow_nil: true
+            end
+          end
+
+          def hash?
+            @config.is_a?(Hash)
+          end
+
+          def string?
+            @config.is_a?(String)
+          end
+
+          def name
+            value[:name]
+          end
+
+          def url
+            value[:url]
+          end
+
+          def action
+            value[:action] || 'start'
+          end
+
+          def on_stop
+            value[:on_stop]
+          end
+
+          def value
+            case @config
+            when String then { name: @config, action: 'start' }
+            when Hash then @config
+            else {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/entry/factory.rb

@@ -0,0 +1,73 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Factory class responsible for fabricating entry objects.
+        #
+        class Factory
+          InvalidFactory = Class.new(StandardError)
+
+          def initialize(entry)
+            @entry = entry
+            @metadata = {}
+            @attributes = {}
+          end
+
+          def value(value)
+            @value = value
+            self
+          end
+
+          def metadata(metadata)
+            @metadata.merge!(metadata)
+            self
+          end
+
+          def with(attributes)
+            @attributes.merge!(attributes)
+            self
+          end
+
+          def create!
+            raise InvalidFactory unless defined?(@value)
+
+            ##
+            # We assume that unspecified entry is undefined.
+            # See issue #18775.
+            #
+            if @value.nil?
+              Entry::Unspecified.new(
+                fabricate_unspecified
+              )
+            else
+              fabricate(@entry, @value)
+            end
+          end
+
+          private
+
+          def fabricate_unspecified
+            ##
+            # If entry has a default value we fabricate concrete node
+            # with default value.
+            #
+            if @entry.default.nil?
+              fabricate(Entry::Undefined)
+            else
+              fabricate(@entry, @entry.default)
+            end
+          end
+
+          def fabricate(entry, value = nil)
+            entry.new(value, @metadata).tap do |node|
+              node.key = @attributes[:key]
+              node.parent = @attributes[:parent]
+              node.description = @attributes[:description]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/entry/global.rb

@@ -0,0 +1,72 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # This class represents a global entry - root Entry for entire
+        # GitLab CI Configuration file.
+        #
+        class Global < Node
+          include Configurable
+
+          entry :before_script, Entry::Script,
+            description: 'Script that will be executed before each job.'
+
+          entry :image, Entry::Image,
+            description: 'Docker image that will be used to execute jobs.'
+
+          entry :services, Entry::Services,
+            description: 'Docker images that will be linked to the container.'
+
+          entry :after_script, Entry::Script,
+            description: 'Script that will be executed after each job.'
+
+          entry :variables, Entry::Variables,
+            description: 'Environment variables that will be used.'
+
+          entry :stages, Entry::Stages,
+            description: 'Configuration of stages for this pipeline.'
+
+          entry :types, Entry::Stages,
+            description: 'Deprecated: stages for this pipeline.'
+
+          entry :cache, Entry::Cache,
+            description: 'Configure caching between build jobs.'
+
+          helpers :before_script, :image, :services, :after_script,
+                  :variables, :stages, :types, :cache, :jobs
+
+          def compose!(_deps = nil)
+            super(self) do
+              compose_jobs!
+              compose_deprecated_entries!
+            end
+          end
+
+          private
+
+          def compose_jobs!
+            factory = Entry::Factory.new(Entry::Jobs)
+              .value(@config.except(*self.class.nodes.keys))
+              .with(key: :jobs, parent: self,
+                    description: 'Jobs definition for this pipeline')
+
+            @entries[:jobs] = factory.create!
+          end
+
+          def compose_deprecated_entries!
+            ##
+            # Deprecated `:types` key workaround - if types are defined and
+            # stages are not defined we use types definition as stages.
+            #
+            if types_defined? && !stages_defined?
+              @entries[:stages] = @entries[:types]
+            end
+
+            @entries.delete(:types)
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/entry/hidden.rb

@@ -0,0 +1,22 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents a hidden CI/CD key.
+        #
+        class Hidden < Node
+          include Validatable
+
+          validations do
+            validates :config, presence: true
+          end
+
+          def relevant?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/entry/image.rb

@@ -0,0 +1,47 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents a Docker image.
+        #
+        class Image < Node
+          include Validatable
+
+          ALLOWED_KEYS = %i[name entrypoint].freeze
+
+          validations do
+            validates :config, hash_or_string: true
+            validates :config, allowed_keys: ALLOWED_KEYS
+
+            validates :name, type: String, presence: true
+            validates :entrypoint, array_of_strings: true, allow_nil: true
+          end
+
+          def hash?
+            @config.is_a?(Hash)
+          end
+
+          def string?
+            @config.is_a?(String)
+          end
+
+          def name
+            value[:name]
+          end
+
+          def entrypoint
+            value[:entrypoint]
+          end
+
+          def value
+            return { name: @config } if string?
+            return @config if hash?
+
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/entry/job.rb

@@ -0,0 +1,157 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents a concrete CI/CD job.
+        #
+        class Job < Node
+          include Configurable
+          include Attributable
+
+          ALLOWED_KEYS = %i[tags script only except type image services allow_failure
+                            type stage when artifacts cache dependencies before_script
+                            after_script variables environment coverage retry].freeze
+
+          validations do
+            validates :config, allowed_keys: ALLOWED_KEYS
+            validates :config, presence: true
+            validates :script, presence: true
+            validates :name, presence: true
+            validates :name, type: Symbol
+
+            with_options allow_nil: true do
+              validates :tags, array_of_strings: true
+              validates :allow_failure, boolean: true
+              validates :retry, numericality: { only_integer: true,
+                                                greater_than_or_equal_to: 0,
+                                                less_than_or_equal_to: 2 }
+              validates :when,
+                inclusion: { in: %w[on_success on_failure always manual],
+                             message: 'should be on_success, on_failure, ' \
+                                      'always or manual' }
+
+              validates :dependencies, array_of_strings: true
+            end
+          end
+
+          entry :before_script, Entry::Script,
+            description: 'Global before script overridden in this job.'
+
+          entry :script, Entry::Commands,
+            description: 'Commands that will be executed in this job.'
+
+          entry :stage, Entry::Stage,
+            description: 'Pipeline stage this job will be executed into.'
+
+          entry :type, Entry::Stage,
+            description: 'Deprecated: stage this job will be executed into.'
+
+          entry :after_script, Entry::Script,
+            description: 'Commands that will be executed when finishing job.'
+
+          entry :cache, Entry::Cache,
+            description: 'Cache definition for this job.'
+
+          entry :image, Entry::Image,
+            description: 'Image that will be used to execute this job.'
+
+          entry :services, Entry::Services,
+            description: 'Services that will be used to execute this job.'
+
+          entry :only, Entry::Policy,
+            description: 'Refs policy this job will be executed for.'
+
+          entry :except, Entry::Policy,
+            description: 'Refs policy this job will be executed for.'
+
+          entry :variables, Entry::Variables,
+            description: 'Environment variables available for this job.'
+
+          entry :artifacts, Entry::Artifacts,
+            description: 'Artifacts configuration for this job.'
+
+          entry :environment, Entry::Environment,
+               description: 'Environment configuration for this job.'
+
+          entry :coverage, Entry::Coverage,
+               description: 'Coverage configuration for this job.'
+
+          helpers :before_script, :script, :stage, :type, :after_script,
+                  :cache, :image, :services, :only, :except, :variables,
+                  :artifacts, :commands, :environment, :coverage, :retry
+
+          attributes :script, :tags, :allow_failure, :when, :dependencies, :retry
+
+          def compose!(deps = nil)
+            super do
+              if type_defined? && !stage_defined?
+                @entries[:stage] = @entries[:type]
+              end
+
+              @entries.delete(:type)
+            end
+
+            inherit!(deps)
+          end
+
+          def name
+            @metadata[:name]
+          end
+
+          def value
+            @config.merge(to_hash.compact)
+          end
+
+          def commands
+            (before_script_value.to_a + script_value.to_a).join("\n")
+          end
+
+          def manual_action?
+            self.when == 'manual'
+          end
+
+          def ignored?
+            allow_failure.nil? ? manual_action? : allow_failure
+          end
+
+          private
+
+          def inherit!(deps)
+            return unless deps
+
+            self.class.nodes.each_key do |key|
+              global_entry = deps[key]
+              job_entry = self[key]
+
+              if global_entry.specified? && !job_entry.specified?
+                @entries[key] = global_entry
+              end
+            end
+          end
+
+          def to_hash
+            { name: name,
+              before_script: before_script_value,
+              script: script_value,
+              commands: commands,
+              image: image_value,
+              services: services_value,
+              stage: stage_value,
+              cache: cache_value,
+              only: only_value,
+              except: except_value,
+              variables: variables_defined? ? variables_value : nil,
+              environment: environment_defined? ? environment_value : nil,
+              environment_name: environment_defined? ? environment_value[:name] : nil,
+              coverage: coverage_defined? ? coverage_value : nil,
+              retry: retry_defined? ? retry_value.to_i : nil,
+              artifacts: artifacts_value,
+              after_script: after_script_value,
+              ignore: ignored? }
+          end
+        end
+      end
+    end
+  end
+end