boringbuilder 0.1.0.alpha.1

data/lib/boringbuilder/artifact.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module BoringBuilder
+  class Artifact
+    Entry = Data.define(:origin, :kind, :source, :destination) do
+      def to_h
+        { origin: origin, kind: kind, source: source.to_s, destination: destination }
+      end
+    end
+
+    attr_reader :root, :entries
+
+    def initialize(root: Dir.pwd)
+      @root = Pathname.new(root).expand_path
+      @entries = []
+    end
+
+    def directory(source, at: source)
+      add(:container, :directory, source, at)
+    end
+
+    def file(source, at: source)
+      add(:container, :file, source, at)
+    end
+
+    def host_path(source, at:)
+      path = Pathname.new(source).expand_path(root)
+      kind = path.file? ? :file : :directory
+      raise ConfigurationError, "Host artifact path does not exist: #{path}" unless path.exist?
+
+      add(:host, kind, path, at)
+    end
+
+    def empty?
+      entries.empty?
+    end
+
+    def full_container_root?
+      entries.one? && entries.first.origin == :container && entries.first.kind == :directory &&
+        entries.first.source == "/" && entries.first.destination == "/"
+    end
+
+    def export_directory(client, container)
+      return container.directory("/") if full_container_root?
+
+      entries.reduce(client.directory) do |directory, entry|
+        destination = entry.destination.delete_prefix("/")
+        source = source_for(entry, client, container)
+
+        if entry.kind == :file
+          directory.with_file(destination, source)
+        else
+          directory.with_directory(destination, source)
+        end
+      end
+    end
+
+    def to_a
+      entries.map(&:to_h)
+    end
+
+    private
+
+    def add(origin, kind, source, destination)
+      source = normalize_container_path(source, "source") if origin == :container
+      destination = normalize_container_path(destination, "destination")
+      entries << Entry.new(origin: origin, kind: kind, source: source, destination: destination)
+      self
+    end
+
+    def normalize_container_path(path, label)
+      value = path.to_s
+      clean = Pathname.new(value).cleanpath.to_s
+      return clean if value.start_with?("/") && clean == value
+
+      raise ConfigurationError, "Artifact #{label} must be a clean absolute path: #{path.inspect}"
+    end
+
+    def source_for(entry, client, container)
+      source = entry.source.to_s
+      owner = entry.origin == :container ? container : client.host
+      entry.kind == :file ? owner.file(source) : owner.directory(source)
+    end
+  end
+end

data/lib/boringbuilder/boring_cache.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class BoringCache
+    CLI_IMAGE = "ghcr.io/boringcache/base:bookworm-v1.19.4@" \
+                "sha256:84d1e168a50fd086ecd4fdb2fd96f689982a6f3c61454acd8c7189e336f8f3ae"
+    BUILD_IMAGE = "ghcr.io/boringcache/base:bookworm-build-v1.19.4@" \
+                  "sha256:df4461581214c0052157041238a67b8da420e1399e4024bc857c68c74a9721cb"
+    TOKEN_NAMES = %w[BORINGCACHE_RESTORE_TOKEN BORINGCACHE_SAVE_TOKEN].freeze
+    ENVIRONMENT_NAMES = %w[BORINGCACHE_API_URL BORINGCACHE_DEFAULT_WORKSPACE BORINGCACHE_WORKSPACE].freeze
+
+    attr_reader :project, :client, :environment
+
+    def initialize(project, client, environment: ENV)
+      @project = project
+      @client = client
+      @environment = environment
+    end
+
+    def enabled?
+      token? && (workspace? || project_config?)
+    end
+
+    def prepare(container, workdir: project.application_path)
+      return container unless enabled?
+
+      container = container.with_file("/usr/local/bin/boringcache", cli_file, permissions: 0o755)
+      container = container.with_file("#{workdir}/.boringcache.toml", project_config_file) if project_config?
+      container = with_environment(container)
+      with_secrets(container)
+    end
+
+    def wrap(command, entry: "bundler")
+      return command unless enabled?
+
+      wrapped(command, "--entry", entry)
+    end
+
+    def wrap_mount(command, tag:, path:)
+      wrap_mounts(command, tag => path)
+    end
+
+    def wrap_mounts(command, mounts)
+      return command unless enabled?
+
+      cache_arguments = mounts.flat_map { |tag, path| ["--manual-entry", "#{tag}:#{path}"] }
+      wrapped(command, *cache_arguments)
+    end
+
+    def mode
+      enabled? ? :boringcache : :local
+    end
+
+    def artifact_publishable?
+      save_token? && (workspace? || project_config?)
+    end
+
+    def prepare_artifact_publisher(container, workdir: "/workspace")
+      container = container.with_workdir(workdir)
+      container = container.with_file("#{workdir}/.boringcache.toml", project_config_file) if project_config?
+      container = with_environment(container)
+      with_secrets(container)
+    end
+
+    def cli_image
+      environment.fetch("BORINGBUILDER_BORINGCACHE_IMAGE", CLI_IMAGE)
+    end
+
+    def save_token?
+      !value("BORINGCACHE_SAVE_TOKEN").nil?
+    end
+
+    def workspace_configured?
+      workspace? || project_config?
+    end
+
+    private
+
+    def wrapped(command, *cache_arguments)
+      arguments = ["boringcache", "run", *cache_arguments, "--no-git"]
+      arguments << "--read-only" unless save_token?
+      [*arguments, "--", *command]
+    end
+
+    def token?
+      TOKEN_NAMES.any? { |name| value(name) }
+    end
+
+    def workspace?
+      %w[BORINGCACHE_DEFAULT_WORKSPACE BORINGCACHE_WORKSPACE].any? { |name| value(name) }
+    end
+
+    def project_config?
+      project.root.join(".boringcache.toml").file?
+    end
+
+    def project_config_file
+      project.source_file(client, ".boringcache.toml")
+    end
+
+    def cli_file
+      options = project.configuration.platform ? { platform: project.configuration.platform } : {}
+      client.container(options).from(cli_image).file("/usr/local/bin/boringcache")
+    end
+
+    def with_environment(container)
+      ENVIRONMENT_NAMES.reduce(container) do |result, name|
+        value(name) ? result.with_env_variable(name, value(name)) : result
+      end
+    end
+
+    def with_secrets(container)
+      TOKEN_NAMES.reduce(container) do |result, name|
+        value(name) ? result.with_secret_variable(name, secret(name)) : result
+      end
+    end
+
+    def secret(name)
+      client.set_secret(name, value(name))
+    end
+
+    def value(name)
+      environment[name].to_s.empty? ? nil : environment[name]
+    end
+  end
+end

data/lib/boringbuilder/build_progress.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class BuildProgress
+    SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
+    def self.silent
+      @silent ||= new(enabled: false)
+    end
+
+    def initialize(out: $stdout, enabled: true, animated: false)
+      @out = out
+      @enabled = enabled
+      @animated = animated
+      @step = 0
+    end
+
+    def step(name)
+      return yield unless @enabled
+
+      number = next_step
+      started_at = monotonic_time
+      @out.puts "##{number} #{name}"
+      @active_spinner = start_spinner(number, started_at)
+      result = yield
+      stop_active_spinner
+      @out.puts "##{number} DONE #{elapsed_since(started_at)}"
+      result
+    rescue StandardError
+      stop_active_spinner
+      @out.puts "##{number} ERROR #{elapsed_since(started_at)}" if number
+      raise
+    ensure
+      stop_active_spinner
+    end
+
+    def write(output = nil)
+      return unless @enabled
+
+      output = yield if block_given?
+      stop_active_spinner
+      text = output.to_s
+      text.each_line { |line| @out.print "    #{line}" }
+      @out.puts unless text.empty? || text.end_with?("\n")
+    end
+
+    private
+
+    def next_step
+      @step += 1
+    end
+
+    def start_spinner(number, started_at)
+      return unless @animated
+
+      Thread.new do
+        frame = 0
+        loop do
+          @out.print "\r##{number} #{SPINNER_FRAMES.fetch(frame % SPINNER_FRAMES.length)} #{elapsed_since(started_at)}"
+          @out.flush
+          frame += 1
+          sleep 0.1
+        end
+      rescue IOError
+        nil
+      end
+    end
+
+    def stop_spinner(thread)
+      return unless thread&.alive?
+
+      thread.kill
+      thread.join
+      @out.print "\r\e[2K"
+    end
+
+    def stop_active_spinner
+      stop_spinner(@active_spinner)
+      @active_spinner = nil
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def elapsed_since(started_at)
+      format("%.1fs", monotonic_time - started_at)
+    end
+  end
+end

data/lib/boringbuilder/builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dagger_ruby"
+
+module BoringBuilder
+  class Builder
+    attr_reader :configuration, :progress
+
+    def initialize(configuration, progress: BuildProgress.silent)
+      @configuration = configuration
+      @progress = progress
+    end
+
+    def build
+      project = Project.new(configuration).validate!
+      runtime = Runtime.new(configuration.runtime)
+      resolved_runtime = runtime.resolve
+      dagger_configuration = DaggerRuby::Config.new(
+        runtime: runtime.dagger_runtime(resolved_runtime),
+        progress: configuration.progress,
+        silent: configuration.progress.nil?
+      )
+
+      DaggerRuby.connection(dagger_configuration) do |client|
+        container = project.container(client, progress: progress)
+        Exporter.new(project, client, container, runtime: resolved_runtime, progress: progress).call
+      end
+    rescue DaggerRuby::DaggerError => e
+      message = e.message.sub(/\s*\[traceparent:[^\]]+\]\s*\z/, "")
+      raise BuildError, "Dagger build failed: #{message}"
+    end
+  end
+end

data/lib/boringbuilder/cli.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require "pathname"
+
+module BoringBuilder
+  class CLI
+    def self.start(argv = ARGV, **)
+      new(argv, **).start
+    end
+
+    def initialize(argv, out: $stdout, err: $stderr, builder_class: Builder, environment: ENV)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @builder_class = builder_class
+      @environment = environment
+    end
+
+    def run
+      return root_help if @argv.empty? || %w[help --help -h].include?(@argv.first)
+      return version if %w[version --version -v].include?(@argv.first)
+
+      command = @argv.shift
+      case command
+      when "build" then build
+      when "doctor" then doctor
+      when "init" then initialize_project
+      else raise ConfigurationError, "Unknown command '#{command}'. Use build, doctor, init, or version."
+      end
+    end
+
+    def start
+      run
+    rescue BoringBuilder::Error, OptionParser::ParseError => e
+      @err.puts "boringbuilder: #{e.message}"
+      1
+    end
+
+    private
+
+    def version
+      @out.puts BoringBuilder::VERSION
+      0
+    end
+
+    def root_help
+      @out.puts <<~HELP
+        Usage: boringbuilder COMMAND [options]
+
+        Commands:
+          build [PROJECT]  Build and export a deployment artifact
+          doctor          Check the selected container runtime
+          init [PROJECT]   Generate a Dagger Ruby build recipe
+          version         Print the gem version
+      HELP
+      0
+    end
+
+    def build
+      options = {}
+      config_file = :auto
+      dry_run = false
+      json = false
+      parser = build_parser(options, ->(value) { config_file = value }, -> { dry_run = true }) { json = true }
+      help_requested = catch(:boringbuilder_help) do
+        parser.parse!(@argv)
+        false
+      end
+      return 0 if help_requested
+      raise OptionParser::InvalidArgument, "expected at most one PROJECT directory" if @argv.length > 1
+
+      configuration = BoringBuilder.configuration(root: @argv.first || Dir.pwd, config: config_file, **options)
+      project = Project.new(configuration).validate!
+      if dry_run
+        @out.puts JSON.pretty_generate(project.plan)
+        return 0
+      end
+
+      print_build_start(project, json: json)
+      result = @builder_class.new(configuration, progress: build_progress(configuration, json: json)).build
+      json ? @out.puts(JSON.generate(result.to_h)) : print_result(result)
+      0
+    end
+
+    def build_parser(options, config_file, dry_run, &json)
+      OptionParser.new do |parser|
+        parser.banner = "Usage: boringbuilder build [options] [PROJECT]"
+        add_runtime_options(parser, options)
+        add_build_options(parser, options)
+        add_export_options(parser, options)
+        add_rails_options(parser, options)
+        parser.on("--config FILE", "Load a Ruby build recipe (default: config/boringbuilder.rb)") do |value|
+          config_file.call(value)
+        end
+        parser.on("--no-config", "Ignore config/boringbuilder.rb") { config_file.call(false) }
+        parser.on("--dry-run", "Print the resolved build plan") { dry_run.call }
+        parser.on("--json", "Print the build result as JSON") { json.call }
+        parser.on("-h", "--help", "Show this help") do
+          @out.puts(parser)
+          throw :boringbuilder_help, true
+        end
+      end
+    end
+
+    def add_runtime_options(parser, options)
+      parser.on("--runtime NAME", "auto, apple, or docker") { |value| options[:runtime] = value }
+      parser.on("--platform PLATFORM", "Target platform, for example linux/amd64") do |value|
+        options[:platform] = value
+      end
+      parser.on("--progress MODE", %w[auto plain tty], "Dagger progress: auto, plain, or tty") do |value|
+        options[:progress] = value
+      end
+    end
+
+    def add_build_options(parser, options)
+      parser.on("--command COMMAND", "Override the built-in Ruby image command") { |value| options[:command] = value }
+      parser.on("--port PORT", Integer, "Expose PORT for a built-in Ruby web application") do |value|
+        options[:port] = value
+      end
+    end
+
+    def add_export_options(parser, options)
+      parser.on("--format FORMAT", "directory, tar, tar.zst, oci, or docker") { |value| options[:format] = value }
+      parser.on("-o", "--output PATH", "Local artifact destination") { |value| options[:output] = value }
+      parser.on("--path SOURCE[=DESTINATION]",
+                "Export a container directory, optionally remapped (repeatable)") do |value|
+        (options[:paths] ||= []) << value
+      end
+      parser.on("--file SOURCE[=DESTINATION]", "Export a container file, optionally remapped (repeatable)") do |value|
+        (options[:files] ||= []) << value
+      end
+      parser.on("--host-path SOURCE=DESTINATION", "Add an explicit host file or directory (repeatable)") do |value|
+        (options[:host_paths] ||= []) << value
+      end
+      parser.on("--push IMAGE", "Publish the image to a registry") { |value| options[:publish] = value }
+      parser.on("--load IMAGE", "Load the image into the selected runtime") { |value| options[:load] = value }
+      parser.on("--exporter NAME", "Artifact exporter: auto, local, or boringcache") do |value|
+        options[:exporter] = value
+      end
+      parser.on("--artifact", "Use the BoringCache Artifact exporter") { options[:exporter] = :boringcache }
+      parser.on("--no-artifact", "Use the local artifact exporter") { options[:exporter] = :local }
+      parser.on("--artifact-name NAME", "Name the BoringCache Artifact") { |value| options[:artifact_name] = value }
+    end
+
+    def add_rails_options(parser, options)
+      parser.on("--base-image IMAGE", "Base image for the built-in Rails build") do |value|
+        options[:base_image] = value
+      end
+      parser.on("--[no-]assets", "Enable or disable Rails asset precompilation") { |value| options[:assets] = value }
+      parser.on("--[no-]bootsnap", "Enable or disable Bootsnap precompilation") { |value| options[:bootsnap] = value }
+    end
+
+    def doctor
+      options = { runtime: :auto }
+      parser = OptionParser.new do |command|
+        command.banner = "Usage: boringbuilder doctor [--runtime NAME]"
+        command.on("--runtime NAME", "auto, apple, or docker") { |value| options[:runtime] = value }
+        command.on("-h", "--help", "Show this help") do
+          @out.puts(command)
+          throw :boringbuilder_help, true
+        end
+      end
+      help_requested = catch(:boringbuilder_help) do
+        parser.parse!(@argv)
+        false
+      end
+      return 0 if help_requested
+      raise OptionParser::InvalidArgument, "doctor does not accept a PROJECT directory" unless @argv.empty?
+
+      runtime = Runtime.new(options[:runtime]).resolve
+      @out.puts "Dagger runtime ready: #{runtime}"
+      0
+    end
+
+    def initialize_project
+      options = { template: :auto, force: false }
+      parser = OptionParser.new do |command|
+        command.banner = "Usage: boringbuilder init [options] [PROJECT]"
+        command.on("--template NAME", Initializer::TEMPLATES.map(&:to_s),
+                   "Recipe template: auto, ruby, node, rust, go, or generic") do |value|
+          options[:template] = value
+        end
+        command.on("--force", "Replace an existing config/boringbuilder.rb") { options[:force] = true }
+        command.on("-h", "--help", "Show this help") do
+          @out.puts(command)
+          throw :boringbuilder_help, true
+        end
+      end
+      help_requested = catch(:boringbuilder_help) do
+        parser.parse!(@argv)
+        false
+      end
+      return 0 if help_requested
+      raise OptionParser::InvalidArgument, "expected at most one PROJECT directory" if @argv.length > 1
+
+      root = Pathname.new(@argv.first || Dir.pwd).expand_path
+      initializer = Initializer.new(root, template: options[:template])
+      path = initializer.call(force: options[:force])
+      @out.puts "Created #{path.relative_path_from(root)} (#{initializer.template_name})"
+      0
+    end
+
+    def print_result(result)
+      @out.puts "Built with Dagger on #{result.runtime}"
+      @out.puts "Exported #{result.format}: #{result.path}" if result.exported?
+      @out.puts "Image: #{result.reference}" if result.published?
+      @out.puts "Artifact: #{result.artifact_id} (#{result.artifact_name})" if result.artifact_published?
+    end
+
+    def print_build_start(project, json:)
+      return if json || !dagger_session?
+
+      cache = BoringCache.new(project, nil, environment: @environment).mode
+      pipeline = project.custom_pipeline? ? "custom pipeline" : project.framework.to_s
+      details = [pipeline, "#{project.configuration.runtime} runtime", "#{cache} cache",
+                 "#{project.configuration.format.to_s.tr('_', '.')} output"]
+
+      @out.puts "Building #{project.app_name} with Dagger"
+      @out.puts "  #{details.join(' · ')}"
+    end
+
+    def dagger_session?
+      @environment["DAGGER_SESSION_PORT"] && @environment["DAGGER_SESSION_TOKEN"]
+    end
+
+    def build_progress(configuration, json:)
+      enabled = !json && dagger_session? && configuration.progress.nil?
+      animated = enabled && @out.respond_to?(:tty?) && @out.tty?
+      BuildProgress.new(out: @out, enabled: enabled, animated: animated)
+    end
+  end
+end

data/lib/boringbuilder/config_file.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class ConfigFile
+    DEFAULT_PATH = "config/boringbuilder.rb"
+    THREAD_KEY = :boringbuilder_config_file
+
+    class << self
+      def resolve(root, requested = :auto)
+        return if requested == false || requested.nil?
+
+        path = root.join(requested == :auto ? DEFAULT_PATH : requested).expand_path
+        return path if path.file?
+        return if requested == :auto
+
+        raise ConfigurationError, "BoringBuilder config file does not exist: #{path}"
+      end
+
+      def load(path, configuration)
+        previous = Thread.current[THREAD_KEY]
+        state = { configuration: configuration, applied: false }
+        Thread.current[THREAD_KEY] = state
+        Kernel.load(path.to_s)
+        raise ConfigurationError, "#{path} must call BoringBuilder.configure" unless state[:applied]
+
+        configuration
+      ensure
+        Thread.current[THREAD_KEY] = previous
+      end
+
+      def configure
+        state = Thread.current[THREAD_KEY]
+        raise ConfigurationError, "BoringBuilder.configure is only available while loading a config file" unless state
+
+        state[:applied] = true
+        yield state.fetch(:configuration)
+      end
+    end
+  end
+end