bsdkrun 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1b2ffdacfec58cee3714b8ca96ecc133604655d423e264444d8f41ea88393e5
-  data.tar.gz: 848ec7c03c5489a41daf404135c3bbfdcfb126449ecb712ddf920ea7377bc822
+  metadata.gz: 86e468aea9e96825db542d4c5e9ddf2fbbc473ddfb4e4b7edfa8ecac48abd685
+  data.tar.gz: 86f792adb80c6218763193a256b16c4f307e68063a494718277e4e4b94d3c0b1
 SHA512:
-  metadata.gz: a86228909ae198caab0e630bac039179fc115317118f321a1aa193683ee6fb10ccfdc56ae1d05d42cad3ebad712897b5979c0b3b75cd0fe9b64bef0406d1d5ae
-  data.tar.gz: aef36636aef92124b1c78695648c929bfee4f60e134b9ef0a2d5588693827994e8023f62c91f39cd2d1a19c74e7e1a6a3d99a99c2aca9df51ba53bf03022368e
+  metadata.gz: e948aea05cab5bffabb28a50a0fb8df66500ab6b6ead6fe0e8a3ff9f07d981f84f19deac1f775e7c4a7665dd037a711d2c6aba19fb15ee4d1cdb7903f8293c40
+  data.tar.gz: 56d75e614b8f78319079302e61cc257cd30a3229e27384d09e6412c9bcb58459a6519d6df4e17a608a0b0fc18e92569e4510fea063bc849b13e60af3a723cea8

data/lib/bsdkrun/ci.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "tmpdir"
+
+module Bsdkrun
+  # CI workflows defined in code instead of YAML.
+  #
+  # The builder produces exactly the file +bsdkrun ci+ (and tangled's spindle)
+  # consumes — {CIWorkflow#yaml} is that file, {CIWorkflow#save} commits it to
+  # +.tangled/workflows/+, and {CIWorkflow#run} executes it in a microVM
+  # without a file ever touching the repository:
+  #
+  #   Bsdkrun.workflow("test")
+  #     .on_push("main")
+  #     .deps("ruby", "bundler")
+  #     .env("CI_FROM", "sdk")
+  #     .step("install", "bundle install")
+  #     .step("test", "bundle exec rspec")
+  #     .run
+  #
+  # Code is the source of truth and YAML the wire format, in that order —
+  # which is why +save+ writes a generated-file header: a hand-edit there will
+  # be overwritten by the next +save+.
+  class CIWorkflow
+    def initialize(name)
+      @name = name
+      @engine = "nixery"
+      @when = []
+      @deps = {}
+      @env = {}
+      @steps = []
+      @clone_depth = nil
+      @clone_skip = false
+    end
+
+    # Override the engine (+nixery+ by default).
+    def engine(engine)
+      @engine = engine
+      self
+    end
+
+    # Add a push trigger for the given branches.
+    def on_push(*branches)
+      @when << [["push"], branches]
+      self
+    end
+
+    # Add a pull_request trigger targeting the given branches.
+    def on_pull_request(*branches)
+      @when << [["pull_request"], branches]
+      self
+    end
+
+    # Add a trigger with explicit events.
+    def on(events, *branches)
+      @when << [events, branches]
+      self
+    end
+
+    # Add nixpkgs dependencies — the toolchain the steps run against.
+    def deps(*packages)
+      (@deps["nixpkgs"] ||= []).concat(packages)
+      self
+    end
+
+    # Add dependencies from a custom registry (a flake reference).
+    def deps_from(registry, *packages)
+      (@deps[registry] ||= []).concat(packages)
+      self
+    end
+
+    # Set a workflow-level environment variable.
+    def env(key, value)
+      @env[key] = value
+      self
+    end
+
+    # Append a step; steps run serially in one VM, from the workspace root.
+    def step(name, command, env: nil)
+      @steps << { name: name, command: command, env: env || {} }
+      self
+    end
+
+    # Set the clone depth (default 1).
+    def clone_depth(depth)
+      @clone_depth = depth
+      self
+    end
+
+    # Skip the checkout entirely.
+    def skip_clone
+      @clone_skip = true
+      self
+    end
+
+    # The workflow file name {#save} writes: +<name>.yml+.
+    def file_name
+      @name.match?(/\.ya?ml\z/) ? @name : "#{@name}.yml"
+    end
+
+    # Render the workflow file. Scalars are emitted as JSON strings — valid
+    # YAML by construction — and commands as literal blocks when safe, so the
+    # SDK needs no YAML dependency.
+    def yaml
+      out = []
+      q = ->(s) { JSON.generate(s) }
+
+      unless @when.empty?
+        out << "when:"
+        @when.each do |events, branches|
+          out << "  - event: [#{events.map(&q).join(', ')}]"
+          if branches.length == 1
+            out << "    branch: #{q.call(branches[0])}"
+          elsif branches.length > 1
+            out << "    branch: [#{branches.map(&q).join(', ')}]"
+          end
+        end
+        out << ""
+      end
+
+      out << "engine: #{@engine}"
+
+      unless @deps.empty?
+        out << "" << "dependencies:"
+        @deps.keys.sort.each do |reg|
+          out << "  #{q.call(reg)}:"
+          @deps[reg].each { |p| out << "    - #{q.call(p)}" }
+        end
+      end
+
+      unless @env.empty?
+        out << "" << "environment:"
+        @env.keys.sort.each { |k| out << "  #{k}: #{q.call(@env[k])}" }
+      end
+
+      if @clone_skip || @clone_depth
+        out << "" << "clone:"
+        out << "  skip: true" if @clone_skip
+        out << "  depth: #{@clone_depth}" if @clone_depth
+      end
+
+      out << "" << "steps:"
+      @steps.each do |s|
+        out << "  - name: #{q.call(s[:name])}"
+        # Literal blocks read well in a committed file, but cannot carry
+        # trailing spaces or carriage returns byte-for-byte; fall back to a
+        # JSON string rather than silently altering the command.
+        block_safe = !s[:command].empty? &&
+                     !s[:command].include?("\r") &&
+                     s[:command].split("\n", -1).all? { |l| l == l.sub(/ +\z/, "") }
+        if block_safe
+          out << "    command: |"
+          s[:command].sub(/\n+\z/, "").split("\n", -1).each { |l| out << "      #{l}" }
+        else
+          out << "    command: #{q.call(s[:command])}"
+        end
+        next if s[:env].empty?
+
+        out << "    environment:"
+        s[:env].keys.sort.each { |k| out << "      #{k}: #{q.call(s[:env][k])}" }
+      end
+      "#{out.join("\n")}\n"
+    end
+
+    # Write into +<repo>/.tangled/workflows/+ and return the path.
+    def save(repo)
+      dir = File.join(repo, ".tangled", "workflows")
+      FileUtils.mkdir_p(dir)
+      path = File.join(dir, file_name)
+      File.write(
+        path,
+        "# Generated by the bsdkrun SDK — edit the code that save()d it instead.\n#{yaml}"
+      )
+      path
+    end
+
+    # Execute the workflow in a microVM, streaming output. The YAML never
+    # touches the repository — it goes to a temp file and +bsdkrun ci run -f+.
+    # Raises {CommandFailed} when a step fails.
+    def run(dir: nil)
+      Dir.mktmpdir("bsdkrun-ci-") do |tmp|
+        file = File.join(tmp, file_name)
+        File.write(file, yaml)
+        args = ["ci", "run", "-f", file]
+        args += ["-w", dir] if dir
+        ok = Process.spawn_interactive(args)
+        unless ok
+          raise CommandFailed.new(
+            exit_code: 1, stdout: "", stderr: "workflow #{@name} failed",
+            command: "bsdkrun ci run"
+          )
+        end
+      end
+      nil
+    end
+  end
+
+  # Start a CI workflow definition.
+  def self.workflow(name)
+    CIWorkflow.new(name)
+  end
+end

data/lib/bsdkrun/version.rb

@@ -2,5 +2,5 @@
 
 module Bsdkrun
   # The bsdkrun Ruby SDK version.
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/bsdkrun.rb

@@ -6,6 +6,7 @@ require_relative "bsdkrun/binary"
 require_relative "bsdkrun/process"
 require_relative "bsdkrun/args"
 require_relative "bsdkrun/cache"
+require_relative "bsdkrun/ci"
 require_relative "bsdkrun/filesystem"
 require_relative "bsdkrun/types"
 require_relative "bsdkrun/sandbox"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bsdkrun
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Tsiry Sandratraina
@@ -52,6 +52,7 @@ files:
 - lib/bsdkrun/args.rb
 - lib/bsdkrun/binary.rb
 - lib/bsdkrun/cache.rb
+- lib/bsdkrun/ci.rb
 - lib/bsdkrun/client.rb
 - lib/bsdkrun/errors.rb
 - lib/bsdkrun/filesystem.rb