gitlab-ci-yaml_lint 0.1.0

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

@@ -0,0 +1,22 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents a stage for a job.
+        #
+        class Stage < Node
+          include Validatable
+
+          validations do
+            validates :config, type: String
+          end
+
+          def self.default
+            'test'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents a configuration for pipeline stages.
+        #
+        class Stages < Node
+          include Validatable
+
+          validations do
+            validates :config, array_of_strings: true
+          end
+
+          def self.default
+            %w[build test deploy]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # This class represents an undefined entry.
+        #
+        class Undefined < Node
+          def initialize(*)
+            super(nil)
+          end
+
+          def value
+            nil
+          end
+
+          def valid?
+            true
+          end
+
+          def errors
+            []
+          end
+
+          def specified?
+            false
+          end
+
+          def relevant?
+            false
+          end
+
+          def inspect
+            "#<#{self.class.name}>"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # This class represents an unspecified entry.
+        #
+        # It decorates original entry adding method that indicates it is
+        # unspecified.
+        #
+        class Unspecified < SimpleDelegator
+          def specified?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        module Validatable
+          extend ActiveSupport::Concern
+
+          def self.included(node)
+            node.aspects.append -> do
+              @validator = self.class.validator.new(self)
+              @validator.validate(:new)
+            end
+          end
+
+          def errors
+            @validator.messages + descendants.flat_map(&:errors) # rubocop:disable Gitlab/ModuleWithInstanceVariables
+          end
+
+          class_methods do
+            def validator
+              @validator ||= Class.new(Entry::Validator).tap do |validator|
+                if defined?(@validations)
+                  @validations.each { |rules| validator.class_eval(&rules) }
+                end
+              end
+            end
+
+            private
+
+            def validations(&block)
+              (@validations ||= []).append(block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        class Validator < SimpleDelegator
+          include ActiveModel::Validations
+          include Entry::Validators
+
+          def initialize(entry)
+            super(entry)
+          end
+
+          def messages
+            errors.full_messages.map do |error|
+              "#{location} #{error}".downcase
+            end
+          end
+
+          def self.name
+            'Validator'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        module Validators
+          class AllowedKeysValidator < ActiveModel::EachValidator
+            def validate_each(record, attribute, value)
+              unknown_keys = record.config.try(:keys).to_a - options[:in]
+
+              if unknown_keys.any?
+                record.errors.add(:config, 'contains unknown keys: ' +
+                                            unknown_keys.join(', '))
+              end
+            end
+          end
+
+          class AllowedValuesValidator < ActiveModel::EachValidator
+            def validate_each(record, attribute, value)
+              unless options[:in].include?(value.to_s)
+                record.errors.add(attribute, "unknown value: #{value}")
+              end
+            end
+          end
+
+          class ArrayOfStringsValidator < ActiveModel::EachValidator
+            include LegacyValidationHelpers
+
+            def validate_each(record, attribute, value)
+              unless validate_array_of_strings(value)
+                record.errors.add(attribute, 'should be an array of strings')
+              end
+            end
+          end
+
+          class BooleanValidator < ActiveModel::EachValidator
+            include LegacyValidationHelpers
+
+            def validate_each(record, attribute, value)
+              unless validate_boolean(value)
+                record.errors.add(attribute, 'should be a boolean value')
+              end
+            end
+          end
+
+          class DurationValidator < ActiveModel::EachValidator
+            include LegacyValidationHelpers
+
+            def validate_each(record, attribute, value)
+              unless validate_duration(value)
+                record.errors.add(attribute, 'should be a duration')
+              end
+            end
+          end
+
+          class HashOrStringValidator < ActiveModel::EachValidator
+            def validate_each(record, attribute, value)
+              unless value.is_a?(Hash) || value.is_a?(String)
+                record.errors.add(attribute, 'should be a hash or a string')
+              end
+            end
+          end
+
+          class KeyValidator < ActiveModel::EachValidator
+            include LegacyValidationHelpers
+
+            def validate_each(record, attribute, value)
+              unless validate_string(value)
+                record.errors.add(attribute, 'should be a string or symbol')
+              end
+            end
+          end
+
+          class RegexpValidator < ActiveModel::EachValidator
+            include LegacyValidationHelpers
+
+            def validate_each(record, attribute, value)
+              unless validate_regexp(value)
+                record.errors.add(attribute, 'must be a regular expression')
+              end
+            end
+
+            private
+
+            def look_like_regexp?(value)
+              value.is_a?(String) && value.start_with?('/') &&
+                value.end_with?('/')
+            end
+
+            def validate_regexp(value)
+              look_like_regexp?(value) &&
+                Regexp.new(value.to_s[1...-1]) &&
+                true
+            rescue RegexpError
+              false
+            end
+          end
+
+          class ArrayOfStringsOrRegexpsValidator < RegexpValidator
+            def validate_each(record, attribute, value)
+              unless validate_array_of_strings_or_regexps(value)
+                record.errors.add(attribute, 'should be an array of strings or regexps')
+              end
+            end
+
+            private
+
+            def validate_array_of_strings_or_regexps(values)
+              values.is_a?(Array) && values.all?(&method(:validate_string_or_regexp))
+            end
+
+            def validate_string_or_regexp(value)
+              return false unless value.is_a?(String)
+              return validate_regexp(value) if look_like_regexp?(value)
+
+              true
+            end
+          end
+
+          class TypeValidator < ActiveModel::EachValidator
+            def validate_each(record, attribute, value)
+              type = options[:with]
+              raise unless type.is_a?(Class)
+
+              unless value.is_a?(type)
+                message = options[:message] || "should be a #{type.name}"
+                record.errors.add(attribute, message)
+              end
+            end
+          end
+
+          class VariablesValidator < ActiveModel::EachValidator
+            include LegacyValidationHelpers
+
+            def validate_each(record, attribute, value)
+              unless validate_variables(value)
+                record.errors.add(attribute, 'should be a hash of key value pairs')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents environment variables.
+        #
+        class Variables < Node
+          include Validatable
+
+          validations do
+            validates :config, variables: true
+          end
+
+          def self.default
+            {}
+          end
+
+          def value
+            Hash[@config.map { |key, value| [key.to_s, value.to_s] }]
+          end
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/config/loader.rb

@@ -0,0 +1,25 @@
+module Gitlab
+  module Ci
+    class Config
+      class Loader
+        FormatError = Class.new(StandardError)
+
+        def initialize(config)
+          @config = YAML.safe_load(config, [Symbol], [], true)
+        end
+
+        def valid?
+          @config.is_a?(Hash)
+        end
+
+        def load!
+          unless valid?
+            raise FormatError, 'Invalid configuration format'
+          end
+
+          @config.deep_symbolize_keys
+        end
+      end
+    end
+  end
+end

data/gitlab_lib/gitlab/ci/yaml_processor.rb

@@ -0,0 +1,189 @@
+module Gitlab
+  module Ci
+    class YamlProcessor
+      ValidationError = Class.new(StandardError)
+
+      include Gitlab::Ci::Config::Entry::LegacyValidationHelpers
+
+      attr_reader :cache, :stages, :jobs
+
+      def initialize(config)
+        @ci_config = Gitlab::Ci::Config.new(config)
+        @config = @ci_config.to_hash
+
+        unless @ci_config.valid?
+          raise ValidationError, @ci_config.errors.first
+        end
+
+        initial_parsing
+      rescue Gitlab::Ci::Config::Loader::FormatError => e
+        raise ValidationError, e.message
+      end
+
+      def builds
+        @jobs.map do |name, _|
+          build_attributes(name)
+        end
+      end
+
+      def build_attributes(name)
+        job = @jobs[name.to_sym] || {}
+
+        { stage_idx: @stages.index(job[:stage]),
+          stage: job[:stage],
+          commands: job[:commands],
+          tag_list: job[:tags] || [],
+          name: job[:name].to_s,
+          allow_failure: job[:ignore],
+          when: job[:when] || 'on_success',
+          environment: job[:environment_name],
+          coverage_regex: job[:coverage],
+          yaml_variables: yaml_variables(name),
+          options: {
+            image: job[:image],
+            services: job[:services],
+            artifacts: job[:artifacts],
+            cache: job[:cache],
+            dependencies: job[:dependencies],
+            before_script: job[:before_script],
+            script: job[:script],
+            after_script: job[:after_script],
+            environment: job[:environment],
+            retry: job[:retry]
+          }.compact }
+      end
+
+      def pipeline_stage_builds(stage, pipeline)
+        selected_jobs = @jobs.select do |_, job|
+          next unless job[:stage] == stage
+
+          only_specs = Gitlab::Ci::Build::Policy
+            .fabricate(job.fetch(:only, {}))
+          except_specs = Gitlab::Ci::Build::Policy
+            .fabricate(job.fetch(:except, {}))
+
+          only_specs.all? { |spec| spec.satisfied_by?(pipeline) } &&
+            except_specs.none? { |spec| spec.satisfied_by?(pipeline) }
+        end
+
+        selected_jobs.map { |_, job| build_attributes(job[:name]) }
+      end
+
+      def stage_seeds(pipeline)
+        seeds = @stages.uniq.map do |stage|
+          builds = pipeline_stage_builds(stage, pipeline)
+
+          Gitlab::Ci::Stage::Seed.new(pipeline, stage, builds) if builds.any?
+        end
+
+        seeds.compact
+      end
+
+      def self.validation_message(content)
+        return 'Please provide content of .gitlab-ci.yml' if content.blank?
+
+        begin
+          Gitlab::Ci::YamlProcessor.new(content)
+          nil
+        rescue ValidationError, Psych::SyntaxError => e
+          e.message
+        end
+      end
+
+      private
+
+      def initial_parsing
+        ##
+        # Global config
+        #
+        @before_script = @ci_config.before_script
+        @image = @ci_config.image
+        @after_script = @ci_config.after_script
+        @services = @ci_config.services
+        @variables = @ci_config.variables
+        @stages = @ci_config.stages
+        @cache = @ci_config.cache
+
+        ##
+        # Jobs
+        #
+        @jobs = @ci_config.jobs
+
+        @jobs.each do |name, job|
+          # logical validation for job
+
+          validate_job_stage!(name, job)
+          validate_job_dependencies!(name, job)
+          validate_job_environment!(name, job)
+        end
+      end
+
+      def yaml_variables(name)
+        variables = (@variables || {})
+          .merge(job_variables(name))
+
+        variables.map do |key, value|
+          { key: key.to_s, value: value, public: true }
+        end
+      end
+
+      def job_variables(name)
+        job = @jobs[name.to_sym]
+        return {} unless job
+
+        job[:variables] || {}
+      end
+
+      def validate_job_stage!(name, job)
+        return unless job[:stage]
+
+        unless job[:stage].is_a?(String) && job[:stage].in?(@stages)
+          raise ValidationError, "#{name} job: stage parameter should be #{@stages.join(", ")}"
+        end
+      end
+
+      def validate_job_dependencies!(name, job)
+        return unless job[:dependencies]
+
+        stage_index = @stages.index(job[:stage])
+
+        job[:dependencies].each do |dependency|
+          raise ValidationError, "#{name} job: undefined dependency: #{dependency}" unless @jobs[dependency.to_sym]
+
+          unless @stages.index(@jobs[dependency.to_sym][:stage]) < stage_index
+            raise ValidationError, "#{name} job: dependency #{dependency} is not defined in prior stages"
+          end
+        end
+      end
+
+      def validate_job_environment!(name, job)
+        return unless job[:environment]
+        return unless job[:environment].is_a?(Hash)
+
+        environment = job[:environment]
+        validate_on_stop_job!(name, environment, environment[:on_stop])
+      end
+
+      def validate_on_stop_job!(name, environment, on_stop)
+        return unless on_stop
+
+        on_stop_job = @jobs[on_stop.to_sym]
+        unless on_stop_job
+          raise ValidationError, "#{name} job: on_stop job #{on_stop} is not defined"
+        end
+
+        unless on_stop_job[:environment]
+          raise ValidationError, "#{name} job: on_stop job #{on_stop} does not have environment defined"
+        end
+
+        unless on_stop_job[:environment][:name] == environment[:name]
+          raise ValidationError, "#{name} job: on_stop job #{on_stop} have different environment name"
+        end
+
+        unless on_stop_job[:environment][:action] == 'stop'
+          raise ValidationError, "#{name} job: on_stop job #{on_stop} needs to have action stop defined"
+        end
+      end
+    end
+  end
+end