buildkite-builder 1.0.0.beta.1

data/lib/buildkite/builder/manifest/rule.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'pathname'
+
+module Buildkite
+  module Builder
+    class Manifest::Rule
+      GLOB_OPTIONS = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+
+      attr_reader :exclude
+      attr_reader :glob
+
+      def initialize(root, pattern)
+        @root = Pathname.new(root)
+        @exclude = false
+        @glob = @root
+
+        if pattern[0] == '!'
+          @exclude = true
+          pattern = pattern[1..-1]
+        end
+
+        if pattern.start_with?('/')
+          pattern = pattern[1..-1]
+        else
+          @glob = @glob.join('**')
+        end
+
+        @glob = @glob.join(pattern).to_s
+      end
+
+      def files
+        @files ||= begin
+          matched = Dir.glob(glob, GLOB_OPTIONS)
+          matched.map! { |file| Pathname.new(file) }
+          matched.reject!(&:directory?)
+          matched.map! { |file| file.relative_path_from(Builder.root) }
+          SortedSet.new(matched)
+        end
+      end
+
+      def match?(file)
+        file = Pathname.new(file)
+        file = @root.join(file) unless file.absolute?
+
+        File.fnmatch?(glob, file.to_s, GLOB_OPTIONS)
+      end
+    end
+  end
+end

data/lib/buildkite/builder/processors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Builder
+    module Processors
+      autoload :Abstract, File.expand_path('processors/abstract', __dir__)
+    end
+  end
+end

data/lib/buildkite/builder/processors/abstract.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Builder
+    module Processors
+      class Abstract
+        include LoggingUtils
+        using Rainbow
+
+        def self.process(runner)
+          new(runner).run
+        end
+
+        def initialize(runner)
+          @runner = runner
+        end
+
+        def run
+          _log_run { process }
+        end
+
+        private
+
+        attr_reader :runner
+
+        def process
+          raise NotImplementedError
+        end
+
+        def log
+          runner.log
+        end
+
+        def pipeline
+          runner.pipeline
+        end
+
+        def buildkite
+          @buildkite ||= begin
+            unless Buildkite.env
+              raise 'Must be in Buildkite environment to access the Buildkite API'
+            end
+
+            Buildkite::Pipelines::Api.new(Buildkite.env.api_token)
+          end
+        end
+
+        def pipeline_steps(*types)
+          steps = pipeline.steps
+          types = types.flatten
+          steps = steps.select { |step| types.include?(step.class.to_sym) } if types.any?
+          steps
+        end
+
+        def _log_run
+          log.info "\nProcessing ".color(:dimgray) + self.class.name.color(:springgreen)
+
+          results = benchmark('└──'.color(:springgreen) + ' Finished in %s'.color(:dimgray)) do
+            formatter = log.formatter
+            log.formatter = proc do |_severity, _datetime, _progname, msg|
+              '│'.color(:springgreen) + " #{msg}\n"
+            end
+
+            begin
+              yield
+            ensure
+              log.formatter = formatter
+            end
+          end
+
+          log.info results
+        end
+      end
+    end
+  end
+end

data/lib/buildkite/builder/rainbow.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../../vendor/rainbow/lib/rainbow/refinement'
+
+module Buildkite
+  module Builder
+    Rainbow = ::Rainbow
+  end
+end

data/lib/buildkite/builder/runner.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'pathname'
+require 'tempfile'
+
+module Buildkite
+  module Builder
+    class Runner
+      include Definition::Helper
+      include LoggingUtils
+      using Rainbow
+
+      PIPELINES_PATH = Pathname.new('.buildkite/pipelines').freeze
+      PIPELINE_DEFINITION_PATH = Pathname.new('pipeline.rb').freeze
+
+      attr_reader :options
+
+      # This entrypoint is for running on CI. It expects certain environment variables to
+      # be set.
+      def self.run
+        new(
+          upload: true,
+          pipeline: Buildkite.env.pipeline_slug
+        ).run
+      end
+
+      def initialize(**options)
+        @options = {
+          verbose: true,
+        }.merge(options)
+      end
+
+      def run
+        log.info "#{'+++ ' if Buildkite.env}🧰 " + 'Buildkite-builder'.color(:springgreen) + " ─ #{@options[:pipeline].yellow}"
+
+        results = benchmark("\nDone (%s)".color(:springgreen)) do
+          load_manifests
+          load_templates
+          load_processors
+          load_pipeline
+          run_processors
+        end
+        log.info results
+
+        upload! if options[:upload]
+        # Always return the pipeline.
+
+        pipeline
+      end
+
+      def pipeline
+        @pipeline ||= Buildkite::Pipelines::Pipeline.new
+      end
+
+      def pipeline_definition
+        @pipeline_definition ||= begin
+          expected = Definition::Pipeline
+          load_definition(Buildkite::Builder.root.join(".buildkite/pipelines/#{options[:pipeline]}").join(PIPELINE_DEFINITION_PATH), expected)
+        end
+      end
+
+      def log
+        @log ||= begin
+          Logger.new(options[:verbose] ? $stdout : StringIO.new).tap do |lgr|
+            lgr.formatter = proc do |_severity, _datetime, _progname, msg|
+              "#{msg}\n"
+            end
+          end
+        end
+      end
+
+      private
+
+      def upload!
+        Tempfile.create(['pipeline', '.yml']) do |file|
+          file.sync = true
+          file.write(pipeline.to_yaml)
+
+          log.info '+++ :paperclip: Uploading artifact'
+          Buildkite::Pipelines::Command.artifact!(:upload, file.path)
+          log.info '+++ :pipeline: Uploading pipeline'
+          Buildkite::Pipelines::Command.pipeline!(:upload, file.path)
+        end
+      end
+
+      def load_manifests
+        Loaders::Manifests.load(options[:pipeline]).each do |name, asset|
+          Manifest[name] = asset
+        end
+      end
+
+      def load_templates
+        Loaders::Templates.load(options[:pipeline]).each do |name, asset|
+          pipeline.template(name, &asset)
+        end
+      end
+
+      def load_processors
+        Loaders::Processors.load(options[:pipeline])
+      end
+
+      def run_processors
+        pipeline.processors.each do |processor|
+          processor.process(self)
+        end
+      end
+
+      def load_pipeline
+        pipeline.instance_eval(&pipeline_definition)
+      end
+    end
+  end
+end

data/lib/buildkite/env.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Buildkite
+  class Env
+    BUILDKITE = 'BUILDKITE'
+    PREFIX = "#{BUILDKITE}_"
+
+    module Fallback
+      def method_missing(method_name, *_args, &_block) # rubocop:disable Style/MethodMissingSuper
+        env_name = "#{PREFIX}#{method_name.to_s.gsub(/\?\z/, '').upcase}"
+
+        if method_name.to_s.end_with?('?')
+          @env.key?(env_name)
+        elsif @env.key?(env_name)
+          @env.fetch(env_name)
+        else
+          raise NoMethodError, "undefined method #{method_name} for #{self} because ENV[\"#{env_name}\"] is not defined"
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.end_with?('?') || @env.key?("#{PREFIX}#{method_name.upcase}") || super
+      end
+    end
+    include Fallback
+
+    def self.load(env)
+      new(env) if env[BUILDKITE]
+    end
+
+    def initialize(env)
+      @env = env
+    end
+
+    def default_branch?
+      pipeline_default_branch == branch
+    end
+
+    def pull_request
+      super == 'false' ? false : Integer(super)
+    end
+
+    # Integer methods
+    %w(
+      build_number
+    ).each do |meth|
+      define_method(meth) do
+        Integer(super())
+      end
+    end
+  end
+end

data/lib/buildkite/pipelines.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buildkite
+  module Pipelines
+    autoload :Api, File.expand_path('pipelines/api', __dir__)
+    autoload :Attributes, File.expand_path('pipelines/attributes', __dir__)
+    autoload :Command, File.expand_path('pipelines/command', __dir__)
+    autoload :Helpers, File.expand_path('pipelines/helpers', __dir__)
+    autoload :Pipeline, File.expand_path('pipelines/pipeline', __dir__)
+    autoload :Plugin, File.expand_path('pipelines/plugin', __dir__)
+    autoload :Steps, File.expand_path('pipelines/steps', __dir__)
+  end
+end

data/lib/buildkite/pipelines/api.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Buildkite
+  module Pipelines
+    class Api
+      BASE_URI = URI('https://api.buildkite.com/v2').freeze
+      URI_PARTS = {
+        organization: 'organizations',
+        pipeline: 'pipelines',
+        pipelines: 'pipelines',
+        build: 'builds',
+        builds: 'builds',
+        access_token: 'access-token',
+      }.freeze
+
+      def initialize(token)
+        @token = token
+      end
+
+      def get_access_token
+        uri = uri_for(access_token: nil)
+        JSON.parse(get_request(uri).body)
+      end
+
+      def list_pipelines(organization)
+        raise NotImplementedError
+      end
+
+      def get_pipeline(organization, pipeline)
+        response = get_request(
+          uri_for(
+            organization: organization,
+            pipeline: pipeline
+          )
+        )
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        end
+      end
+
+      def create_pipeline(organization, params)
+        uri = uri_for(
+          organization: organization,
+          pipelines: nil
+        )
+        JSON.parse(post_request(uri, params).body)
+      end
+
+      def get_pipeline_builds(organization, pipeline, **params)
+        uri = uri_for(params.merge(
+          organization: organization,
+          pipeline: pipeline,
+          builds: nil
+        ))
+        JSON.parse(get_request(uri).body)
+      end
+
+      def get_build(organization, pipeline, build)
+        uri = uri_for(
+          organization: organization,
+          pipeline: pipeline,
+          build: build
+        )
+        JSON.parse(get_request(uri).body)
+      end
+
+      def create_build(organization, pipeline)
+        raise NotImplementedError
+      end
+
+      def cancel_build(organization, pipeline, build)
+        raise NotImplementedError
+      end
+
+      def rebuild_build(organization, pipeline, build)
+        raise NotImplementedError
+      end
+
+      private
+
+      def get_request(uri)
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          request = prepare_request(Net::HTTP::Get.new(uri))
+          http.request(request)
+        end
+      end
+
+      def post_request(uri, data)
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          request = prepare_request(Net::HTTP::Post.new(uri))
+          request.content_type = 'application/json'
+          request.body = data.to_json
+          http.request(request)
+        end
+      end
+
+      def uri_for(options)
+        uri_parts = URI_PARTS.each_with_object([]) do |(resource, path), parts|
+          if options.key?(resource)
+            parts << [path, options.delete(resource)].compact
+          end
+        end
+        uri = URI(uri_parts.flatten.unshift(BASE_URI).join('/'))
+        uri.query = URI.encode_www_form(options) if options.any?
+        uri
+      end
+
+      def prepare_request(request)
+        request['Authorization'] = "Bearer #{@token}"
+        request['Accept'] = 'application/json'
+        request
+      end
+    end
+  end
+end