boringbuilder 0.1.0.alpha.1

data/lib/boringbuilder/mise.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BoringBuilder
+  class Mise
+    DEFAULT_IMAGE = BoringCache::BUILD_IMAGE
+    CACHE_PATH = "/mise/cache"
+    INSTALL_COMMAND = %w[mise install].freeze
+    METADATA_FILES = %w[mise.toml .mise.toml .tool-versions mise.lock].freeze
+    ENVIRONMENT = {
+      "MISE_CACHE_DIR" => CACHE_PATH,
+      "MISE_DATA_DIR" => "/mise",
+      "MISE_INSTALLS_DIR" => "/mise/installs",
+      "MISE_SHIMS_DIR" => "/mise/shims",
+      "PATH" => "/mise/shims:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+    }.freeze
+
+    attr_reader :project, :pipeline
+
+    def initialize(project, pipeline)
+      @project = project
+      @pipeline = pipeline
+    end
+
+    def container(tools: {}, image: DEFAULT_IMAGE, workdir: project.application_path)
+      base = with_project_metadata(pipeline.container(image), at: workdir)
+      install(base, tools: tools, workdir: workdir).with_directory(workdir, pipeline.source)
+    end
+
+    def install(container, tools:, workdir:, only: nil)
+      container = with_environment(container)
+      container = container.with_workdir(workdir)
+                           .with_new_file("/etc/mise/config.toml", system_config(tools))
+      command = [*INSTALL_COMMAND, *Array(only).map(&:to_s)]
+      pipeline.run(
+        container,
+        command,
+        cache: "mise",
+        at: CACHE_PATH,
+        entry: "mise",
+        workdir: workdir,
+        name: "Prepare Mise toolchain"
+      )
+    end
+
+    def with_project_metadata(container, at: project.application_path)
+      METADATA_FILES.reduce(container) do |result, name|
+        path = project.root.join(name)
+        path.file? ? result.with_file("#{at}/#{name}", project.source_file(pipeline.client, name)) : result
+      end
+    end
+
+    def with_environment(container)
+      ENVIRONMENT.reduce(container) do |result, (name, value)|
+        result.with_env_variable(name, value)
+      end
+    end
+
+    private
+
+    def system_config(tools)
+      declarations = normalize_tools(tools).sort.map do |name, version|
+        "#{JSON.generate(name)} = #{JSON.generate(version)}"
+      end
+
+      <<~TOML
+        [tools]
+        #{declarations.join("\n")}
+
+        [settings]
+        paranoid = true
+      TOML
+    end
+
+    def normalize_tools(tools)
+      tools.to_h.each_with_object({}) do |(name, version), normalized|
+        name = name.to_s
+        version = version.to_s
+        raise ConfigurationError, "Mise tool names and versions cannot be empty" if name.empty? || version.empty?
+
+        normalized[name] = version
+      end
+    rescue NoMethodError, TypeError
+      raise ConfigurationError, "Mise tools must be a name-to-version map"
+    end
+  end
+end

data/lib/boringbuilder/pipeline.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class Pipeline
+    attr_reader :project, :client, :progress
+
+    def initialize(project, client, environment: ENV, progress: BuildProgress.silent)
+      @project = project
+      @client = client
+      @environment = environment
+      @progress = progress
+    end
+
+    def build
+      container = yield self
+      raise ConfigurationError, "The custom pipeline must return a Dagger container" unless container
+
+      sync_step(container, "Build application")
+    end
+
+    def container(image = nil)
+      result = client.container(container_options)
+      image ? result.from(image) : result
+    end
+
+    def source
+      project.source(client)
+    end
+
+    def mise(tools: {}, image: Mise::DEFAULT_IMAGE, workdir: project.application_path)
+      Mise.new(project, self).container(tools: tools, image: image, workdir: workdir)
+    end
+
+    def run(container, command, cache:, at: nil, entry: nil, workdir: project.application_path, sharing: :LOCKED,
+            name: "Run cached step", **options)
+      arguments = Array(command).map(&:to_s)
+      mounts = normalize_mounts(cache, at, entry)
+      validate_step!(arguments, mounts)
+
+      remote_cache = BoringCache.new(project, client, environment: @environment)
+      container = container.with_workdir(workdir.to_s)
+
+      result, executed = if remote_cache.enabled?
+                           container = remote_cache.prepare(container, workdir: workdir)
+                           command = if entry
+                                       remote_cache.wrap(arguments, entry: entry.to_s)
+                                     else
+                                       remote_cache.wrap_mounts(arguments, mounts)
+                                     end
+                           command_result = execute(container, command, options)
+                           final_result = entry ? command_result : remove_directories(command_result, mounts.values)
+                           [final_result, command_result]
+                         else
+                           run_with_local_cache(container, arguments, mounts, sharing, options)
+                         end
+
+      sync_step(result, name, output: -> { command_output(executed) })
+    end
+
+    def exec(container, command, name:, workdir: project.application_path, **options)
+      arguments = Array(command).map(&:to_s)
+      raise ConfigurationError, "step command cannot be empty" if arguments.empty?
+
+      result = execute(container.with_workdir(workdir.to_s), arguments, options)
+      sync_step(result, name, output: -> { command_output(result) })
+    end
+
+    def step(name, container)
+      result = yield container
+      raise ConfigurationError, "The pipeline step must return a Dagger container" unless result
+
+      sync_step(result, name)
+    end
+
+    private
+
+    def container_options
+      project.configuration.platform ? { platform: project.configuration.platform } : {}
+    end
+
+    def normalize_mounts(cache, at, entry)
+      return { cache.to_s => at.to_s } unless cache.is_a?(Hash)
+
+      raise ConfigurationError, "at and entry apply only to a single cache" if at || entry
+
+      cache.to_h { |name, path| [name.to_s, path.to_s] }
+    end
+
+    def mount_directly(container, mounts, sharing)
+      mounts.reduce(container) do |step, (name, path)|
+        step.with_mounted_cache(path, cache_volume(name), sharing: sharing)
+      end
+    end
+
+    def run_with_local_cache(container, arguments, mounts, sharing, options)
+      executed = execute(mount_directly(container, mounts, sharing), arguments, options)
+      [remove_local_mounts(executed, mounts), executed]
+    end
+
+    def execute(container, command, options)
+      options.empty? ? container.with_exec(command) : container.with_exec(command, options)
+    end
+
+    def command_output(container)
+      [container.stdout, container.stderr].map(&:strip).reject(&:empty?).join("\n")
+    end
+
+    def remove_local_mounts(container, mounts)
+      mounts.reduce(container) do |step, (_name, path)|
+        step.chain_operation("withoutMount", { "path" => path })
+            .with_exec(["rm", "-rf", path])
+      end
+    end
+
+    def remove_directories(container, paths)
+      container.with_exec(["rm", "-rf", *paths])
+    end
+
+    def cache_volume(name)
+      client.cache_volume("boringbuilder-#{project.app_name}-#{name}")
+    end
+
+    def sync_step(container, name, output: nil)
+      return container if container.equal?(@last_synced_container)
+
+      @last_synced_container = progress.step(name) do
+        progress.write { output.call } if output
+        container.sync
+      end
+    end
+
+    def validate_step!(arguments, mounts)
+      raise ConfigurationError, "cached command cannot be empty" if arguments.empty?
+      raise ConfigurationError, "at is required for a single cache" if mounts.values == [""]
+      raise ConfigurationError, "at least one cache is required" if mounts.empty?
+
+      mounts.each do |name, path|
+        validate_cache_name!(name)
+        validate_cache_path!(path)
+      end
+    end
+
+    def validate_cache_name!(name)
+      return if name.match?(/\A[a-zA-Z0-9][a-zA-Z0-9._-]*\z/)
+
+      raise ConfigurationError, "cache name may contain only letters, numbers, '.', '_', and '-'"
+    end
+
+    def validate_cache_path!(path)
+      clean = Pathname.new(path).cleanpath.to_s
+      return if path.start_with?("/") && path != "/" && clean == path
+
+      raise ConfigurationError, "cache path must be a clean absolute path other than '/'"
+    end
+  end
+end

data/lib/boringbuilder/project.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class Project
+    DEFAULT_EXCLUDES = %w[
+      .env
+      .env.*
+      .git
+      coverage
+      dist
+      log
+      node_modules
+      tmp
+      vendor/bundle
+    ].freeze
+
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def validate!
+      configuration.validate!
+      validate_lockfile!
+      validate_application!
+      validate_native_javascript!
+      Exporters::Resolver.new(self, nil).validate!
+      self
+    end
+
+    def container(client, progress: BuildProgress.silent)
+      return Pipeline.new(self, client, progress: progress).build(&configuration.pipeline) if custom_pipeline?
+
+      builder = rails? ? RailsBuild : RubyBuild
+      builder.new(self, client, progress: progress).container
+    end
+
+    def plan
+      ProjectPlan.new(self).to_h
+    end
+
+    def root
+      configuration.root
+    end
+
+    def app_name
+      @app_name ||= root.basename.to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+    end
+
+    def rails?
+      application.rails?
+    end
+
+    def ruby?
+      application.ruby?
+    end
+
+    def hanami?
+      application.hanami?
+    end
+
+    def framework
+      application.framework
+    end
+
+    def locked?
+      root.join("Gemfile.lock").file?
+    end
+
+    def ruby_version
+      @ruby_version ||= mise_ruby_version || tool_versions_ruby_version || ruby_version_file ||
+                        gemfile_ruby_version || locked_ruby_version || RUBY_VERSION
+    end
+
+    def assets?
+      return configuration.assets unless configuration.assets.nil?
+
+      root.join("app/assets").directory? || root.join("config/manifest.js").file?
+    end
+
+    def bootsnap?
+      return configuration.bootsnap unless configuration.bootsnap.nil?
+
+      root.join("Gemfile.lock").read.match?(/^    bootsnap \(/)
+    end
+
+    def artifact_paths
+      artifact.entries.filter_map { |entry| entry.source if entry.origin == :container }.map(&:to_s)
+    end
+
+    def application_path
+      application.path
+    end
+
+    def application_user
+      application.user
+    end
+
+    def runtime_environment
+      application.runtime_environment
+    end
+
+    def runtime_command
+      application.runtime_command
+    end
+
+    def runtime_entrypoint
+      application.runtime_entrypoint
+    end
+
+    def runtime_port
+      application.runtime_port
+    end
+
+    def web?
+      application.web?
+    end
+
+    def artifact
+      @artifact ||= begin
+        configured = configuration.artifact
+        add_configured_entries(configured)
+        add_default_entries(configured) if configured.empty?
+        configured
+      end
+    end
+
+    def output_path
+      return configuration.output if configuration.output
+
+      suffix = {
+        directory: "rootfs",
+        tar: "tar",
+        tar_zst: "tar.zst",
+        oci: "oci.tar",
+        docker: "docker.tar"
+      }.fetch(configuration.format)
+      platform = configuration.platform&.tr("/", "-") || "native"
+      root.join("dist", "#{app_name}-#{platform}.#{suffix}")
+    end
+
+    def source(client)
+      client.host.directory(root.to_s, exclude: DEFAULT_EXCLUDES, gitignore: true)
+    end
+
+    def source_file(client, path)
+      client.host.file(root.join(path).to_s)
+    end
+
+    def custom_pipeline?
+      !configuration.pipeline.nil?
+    end
+
+    private
+
+    def validate_lockfile!
+      return if custom_pipeline? || !ruby? || locked?
+
+      raise ConfigurationError, "Gemfile.lock is required for a reproducible Ruby build"
+    end
+
+    def validate_application!
+      return if custom_pipeline? || ruby?
+
+      raise ConfigurationError, "No conventional Ruby application or custom pipeline found in #{root}"
+    end
+
+    def add_configured_entries(artifact)
+      configuration.paths.each do |mapping|
+        source, destination = parse_mapping(mapping)
+        artifact.directory(source, at: destination)
+      end
+      configuration.files.each do |mapping|
+        source, destination = parse_mapping(mapping)
+        artifact.file(source, at: destination)
+      end
+      configuration.host_paths.each do |mapping|
+        source, destination = parse_mapping(mapping, destination_required: true)
+        artifact.host_path(source, at: destination)
+      end
+    end
+
+    def add_default_entries(artifact)
+      paths = custom_pipeline? ? ["/"] : [application_path, "/usr/local", "/mise"]
+      paths.each { |path| artifact.directory(path) }
+    end
+
+    def parse_mapping(mapping, destination_required: false)
+      source, destination = mapping.to_s.split("=", 2)
+      if source.to_s.empty? || (destination_required && destination.to_s.empty?)
+        raise ConfigurationError, "Artifact mapping must be SOURCE=DESTINATION: #{mapping.inspect}"
+      end
+
+      [source, destination || source]
+    end
+
+    def validate_native_javascript!
+      return if custom_pipeline? || !root.join("package.json").file?
+
+      raise ConfigurationError, <<~MESSAGE.strip
+        package.json was found. Define config/boringbuilder.rb with a custom Dagger pipeline that installs the
+        application's JavaScript runtime.
+      MESSAGE
+    end
+
+    def application
+      @application ||= RubyApplication.new(root, configuration)
+    end
+
+    def ruby_version_file
+      path = root.join(".ruby-version")
+      return unless path.file?
+
+      normalize_ruby_version(path.read.strip)
+    end
+
+    def mise_ruby_version
+      path = %w[mise.toml .mise.toml].map { |name| root.join(name) }.find(&:file?)
+      return unless path
+
+      tools_section = false
+      path.each_line do |line|
+        value = line.strip.sub(/\s+#.*\z/, "")
+        if value.start_with?("[")
+          tools_section = value == "[tools]"
+          next
+        end
+        next unless tools_section
+
+        version = value[/\Aruby\s*=\s*["']([^"']+)["']\z/, 1]
+        return normalize_ruby_version(version) if version
+      end
+
+      nil
+    end
+
+    def tool_versions_ruby_version
+      path = root.join(".tool-versions")
+      return unless path.file?
+
+      version = path.each_line.filter_map { |line| line[/\Aruby\s+(\S+)/, 1] }.first
+      normalize_ruby_version(version) if version
+    end
+
+    def gemfile_ruby_version
+      path = root.join("Gemfile")
+      return unless path.file?
+
+      version = path.read[/^\s*ruby\s+["']([^"']+)["']/, 1]
+      normalize_ruby_version(version) if version
+    end
+
+    def normalize_ruby_version(version)
+      version.to_s.delete_prefix("ruby-")
+    end
+
+    def locked_ruby_version
+      return unless locked?
+
+      root.join("Gemfile.lock").read[/^RUBY VERSION\n\s+ruby ([^\s]+)/, 1]&.sub(/p\d+\z/, "")
+    end
+  end
+end

data/lib/boringbuilder/project_plan.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class ProjectPlan
+    attr_reader :project
+
+    def initialize(project)
+      @project = project
+    end
+
+    def to_h
+      identity.merge(build, artifact, delivery)
+    end
+
+    private
+
+    def identity
+      {
+        app: project.app_name,
+        root: project.root.to_s,
+        strategy: strategy,
+        framework: project.framework,
+        ruby_version: ruby_version
+      }
+    end
+
+    def build
+      {
+        platform: configuration.platform,
+        runtime: configuration.runtime,
+        format: configuration.format,
+        command: command,
+        port: port,
+        cache: BoringCache.new(project, nil).mode
+      }
+    end
+
+    def artifact
+      {
+        output: project.output_path.to_s,
+        artifact: project.artifact.to_a,
+        artifact_paths: project.artifact_paths,
+        exporters: Exporters::Resolver.new(project, nil).plan
+      }
+    end
+
+    def delivery
+      {
+        publish: configuration.publish,
+        load: configuration.load
+      }
+    end
+
+    def configuration
+      project.configuration
+    end
+
+    def strategy
+      return "custom" if project.custom_pipeline?
+
+      project.framework.to_s
+    end
+
+    def ruby_version
+      project.ruby? ? project.ruby_version : nil
+    end
+
+    def command
+      project.custom_pipeline? ? nil : project.runtime_command
+    end
+
+    def port
+      return if project.custom_pipeline? || !project.web?
+
+      project.runtime_port
+    end
+  end
+end

data/lib/boringbuilder/rails_build.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class RailsBuild < RubyBuild
+  end
+end

data/lib/boringbuilder/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path("tasks/boringbuilder.rake", __dir__)
+    end
+  end
+end

data/lib/boringbuilder/result.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BoringBuilder
+  Result = Data.define(:format, :path, :reference, :runtime, :platform, :artifact_id, :artifact_name) do
+    def initialize(format:, path:, reference:, runtime:, platform:, artifact_id: nil, artifact_name: nil)
+      super
+    end
+
+    def exported?
+      !path.nil?
+    end
+
+    def published?
+      !reference.nil?
+    end
+
+    def artifact_published?
+      !artifact_id.nil?
+    end
+
+    def to_h
+      {
+        format: format,
+        path: path,
+        reference: reference,
+        runtime: runtime,
+        platform: platform,
+        artifact_id: artifact_id,
+        artifact_name: artifact_name
+      }
+    end
+  end
+end