buildkite-builder 1.0.0.beta.1

data/lib/buildkite/pipelines/attributes.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Buildkite
+  module Pipelines
+    module Attributes
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def get(attr)
+        attributes[validate(attr)]
+      end
+
+      def set(attr, value)
+        attributes[validate(attr)] = value
+      end
+
+      def has?(attr)
+        # Don't validate for has? calls.
+        attributes.key?(attr.to_s)
+      end
+
+      def permits?(attr)
+        self.class.permits?(attr)
+      end
+
+      def append(attr, value)
+        ensure_array_value(attr)
+        get(attr).push(*[value].flatten)
+        value
+      end
+
+      def prepend(attr, value)
+        ensure_array_value(attr)
+        get(attr).unshift(*[value].flatten)
+        value
+      end
+
+      def permitted_attributes
+        self.class.permitted_attributes
+      end
+
+      def unset(attr)
+        attributes.delete(validate(attr))
+      end
+
+      def to_h
+        permitted_attributes.each_with_object({}) do |attr, hash|
+          hash[attr] = get(attr) if has?(attr)
+        end
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          subclass.permitted_attributes.merge(permitted_attributes)
+        end
+
+        def permitted_attributes
+          @permitted_attributes ||= Set.new
+        end
+
+        def permits?(attr)
+          @permitted_attributes.include?(attr.to_s)
+        end
+
+        def attribute(attribute_name, **options)
+          unless permitted_attributes.add?(attribute_name.to_s)
+            raise "Step already defined attribute: #{attribute_name}"
+          end
+
+          method_name = options.fetch(:as, attribute_name)
+
+          # Define the main helper method that sets or appends the attribute value.
+          define_method(method_name) do |*value|
+            if value.empty?
+              get(attribute_name)
+            elsif options[:append]
+              append(attribute_name, *value)
+            else
+              set(attribute_name, *value)
+            end
+          end
+
+          # Define a helper method that is equivalent to `||=` or `Set#add?`. It will
+          # set the attribute iff it hasn't been already set. It will return true/false
+          # for whether or not the value was set.
+          define_method("#{method_name}?") do |*args|
+            if args.empty?
+              raise ArgumentError, "`#{method_name}?` must be called with arguments"
+            elsif has?(method_name)
+              false
+            else
+              public_send(method_name, *args)
+              true
+            end
+          end
+
+          if options[:append]
+            # If this attribute appends by default, then provide a bang(!) helper method
+            # that allows you to clear and set the value in one go.
+            define_method("#{method_name}!") do |*args|
+              unset(attribute_name)
+              public_send(method_name, *args)
+            end
+          end
+
+          Helpers.prepend_attribute_helper(self, attribute_name)
+        end
+      end
+
+      private
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def ensure_array_value(attr)
+        if has?(attr)
+          set(attr, [get(attr)]) unless get(attr).is_a?(Array)
+        else
+          set(attr, [])
+        end
+      end
+
+      def validate(attr)
+        attr = attr.to_s
+        unless permits?(attr)
+          raise "Attribute not permitted on #{self.class.name} step: #{attr}"
+        end
+
+        attr
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/command.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    class Command
+      BIN_PATH = 'buildkite-agent'
+
+      def self.pipeline!(*args)
+        abort unless pipeline(*args)
+      end
+
+      def self.pipeline(subcommand, *args)
+        new(:pipeline, subcommand, *args).run
+      end
+
+      def self.artifact!(*args)
+        abort unless artifact(*args)
+      end
+
+      def self.artifact(subcommand, *args)
+        new(:artifact, subcommand, *args).run
+      end
+
+      def initialize(command, subcommand, *args)
+        @command = command.to_s
+        @subcommand = subcommand.to_s
+        @options = extract_options(args)
+        @args = transform_args(args)
+      end
+
+      def run
+        system(*to_a)
+      end
+
+      private
+
+      def to_a
+        command = [BIN_PATH, @command, @subcommand]
+        command.concat(@options.to_a.flatten)
+        command.concat(@args)
+      end
+
+      def extract_options(args)
+        return {} unless args.first.is_a?(Hash)
+
+        args.shift.tap do |options|
+          options.transform_keys! do |key|
+            "--#{key.to_s.tr('_', '-')}"
+          end
+          options.transform_values!(&:to_s)
+        end
+      end
+
+      def transform_args(args)
+        args.map!(&:to_s)
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      ATTRIBUTE_HELPERS = {
+        block: :Block,
+        command: :Command,
+        depends_on: :DependsOn,
+        key: :Key,
+        label: :Label,
+        plugins: :Plugins,
+        retry: :Retry,
+        skip: :Skip,
+        soft_fail: :SoftFail,
+        timeout_in_minutes: :TimeoutInMinutes,
+      }.freeze
+
+      ATTRIBUTE_HELPERS.each do |name, mod|
+        autoload mod, File.expand_path("helpers/#{name}", __dir__)
+      end
+
+      def self.prepend_attribute_helper(step_class, attribute)
+        if ATTRIBUTE_HELPERS[attribute]
+          step_class.prepend(const_get(ATTRIBUTE_HELPERS[attribute]))
+        end
+      end
+
+      def self.sanitize(obj)
+        case obj
+        when Hash
+          obj.transform_keys(&:to_s).transform_values { |value| sanitize(value) }
+        when Array
+          obj.map { |value| sanitize(value) }
+        when Symbol, Pathname
+          obj.to_s
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/block.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Block
+        def block(*args, emoji: nil)
+          if emoji
+            emoji = Array(emoji).map { |name| ":#{name}:" }.join
+            args[0] = [emoji, args.first].compact.join(' ')
+          end
+
+          super(*args)
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Command
+        def command(*values)
+          return super if values.empty?
+
+          values.flatten.each do |value|
+            if value == :noop
+              super('true')
+            else
+              super(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/depends_on.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module DependsOn
+        def depends_on(*values)
+          values.flatten.each { |value| super(value) }
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/key.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Key
+        def identifier(arg)
+          key(arg)
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/label.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Label
+        def label(*args, emoji: nil)
+          if emoji
+            emoji = Array(emoji).map { |name| ":#{name}:" }.join
+            args[0] = [emoji, args.first].compact.join(' ')
+          end
+
+          super(*args)
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/plugins.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Plugins
+        def plugin(plugin_name, options = nil)
+          plugin_name = plugin_name.to_s
+          @plugins ||= {}
+
+          if @plugins.key?(plugin_name)
+            raise ArgumentError, "Plugin already used for command step: #{plugin_name}"
+          end
+
+          uri, version = pipeline.plugins.fetch(plugin_name)
+          new_plugin = Plugin.new(uri, version, options)
+          @plugins[plugin_name] = new_plugin
+
+          plugins(new_plugin.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/retry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Retry
+        def automatically_retry(status:, limit:)
+          retry_value = get(:retry)&.[](:automatic)
+
+          unless retry_value.is_a?(Array)
+            retry_value = []
+            self.retry(automatic: retry_value)
+          end
+
+          retry_value.push(exit_status: status, limit: limit)
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/skip.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module Skip
+        # A helper method to see if the step is skipped.
+        # Skipped steps are `true` or a non-empty string.
+        def skipped?
+          get(:skip) != false && !get(:skip).to_s.empty?
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/soft_fail.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module SoftFail
+        def soft_fail_on_status(*statuses)
+          statuses.each do |status|
+            soft_fail(exit_status: status)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/helpers/timeout_in_minutes.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    module Helpers
+      module TimeoutInMinutes
+        def timeout(*args)
+          timeout_in_minutes(*args)
+        end
+
+        def timeout?(*args)
+          timeout_in_minutes?(*args)
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines/pipeline.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Buildkite
+  module Pipelines
+    class Pipeline
+      attr_reader :steps
+      attr_reader :plugins
+      attr_reader :templates
+
+      def initialize(definition = nil, &block)
+        @env = {}
+        @steps = []
+        @plugins = {}
+        @templates = {}
+        @processors = []
+
+        instance_eval(&definition) if definition
+        instance_eval(&block) if block_given?
+      end
+
+      [
+        Steps::Block,
+        Steps::Command,
+        Steps::Input,
+        Steps::Trigger,
+      ].each do |type|
+        define_method(type.to_sym) do |template = nil, &block|
+          add(type, template, &block)
+        end
+      end
+
+      def env(*args)
+        if args.empty?
+          @env
+        elsif args.first.is_a?(Hash)
+          @env.merge!(args.first.transform_keys(&:to_s))
+        else
+          raise ArgumentError, 'value must be hash'
+        end
+      end
+
+      def skip(template = nil, &block)
+        step = add(Steps::Skip, template, &block)
+        # A skip step has a nil/noop command.
+        step.command(nil)
+        # Always set the skip attribute if it's in a falsey state.
+        step.skip(true) if !step.get(:skip) || step.skip.empty?
+        step
+      end
+
+      def wait(attributes = {}, &block)
+        step = add(Steps::Wait, &block)
+        step.wait(nil)
+        attributes.each do |key, value|
+          step.set(key, value)
+        end
+        step
+      end
+
+      def plugin(name, uri, version)
+        name = name.to_s
+
+        if plugins.key?(name)
+          raise ArgumentError, "Plugin already defined: #{name}"
+        end
+
+        @plugins[name] = [uri, version]
+      end
+
+      def template(name, &definition)
+        name = name.to_s
+
+        if templates.key?(name)
+          raise ArgumentError, "Template already defined: #{name}"
+        elsif !block_given?
+          raise ArgumentError, 'Template definition block must be given'
+        end
+
+        @templates[name.to_s] = definition
+      end
+
+      def processors(*processor_classes)
+        unless processor_classes.empty?
+          @processors.clear
+
+          processor_classes.flatten.each do |processor|
+            unless processor < Buildkite::Builder::Processors::Abstract
+              raise "#{processor} must inherit from Buildkite::Builder::Processors::Abstract"
+            end
+
+            @processors << processor
+          end
+        end
+
+        @processors
+      end
+
+      def to_h
+        pipeline = {}
+        if env.any?
+          pipeline[:env] = env
+        end
+        pipeline[:steps] = steps.map(&:to_h)
+
+        Helpers.sanitize(pipeline)
+      end
+
+      def to_yaml
+        YAML.dump(to_h)
+      end
+
+      private
+
+      def add(step_class, template = nil, &block)
+        steps.push(step_class.new(self, find_template(template), &block)).last
+      end
+
+      def find_template(name)
+        return unless name
+
+        templates[name.to_s] || begin
+          raise ArgumentError, "Template not defined: #{name}"
+        end
+      end
+    end
+  end
+end