bard 1.8.0 → 1.9.0

data/lib/bard/cli.rb

@@ -3,6 +3,7 @@
 require "thor"
 require "bard/config"
 require "bard/command"
+require "bard/plugin"
 require "term/ansicolor"
 
 module Bard
@@ -19,24 +20,18 @@ module Bard
       master_key: "MasterKey",
       setup: "Setup",
       run: "Run",
-      open: "Open",
       ssh: "SSH",
-      install: "Install",
-      ping: "Ping",
-      hurt: "Hurt",
-      vim: "Vim",
     }.each do |command, klass|
       require "bard/cli/#{command}"
       include const_get(klass)
     end
 
-    {
-      provision: "Provision",
-      new: "New",
-    }.each do |command, klass|
-      require "bard/cli/#{command}"
-      const_get(klass).setup(self)
-    end
+    Plugin.load_all!
+    Plugin.all.each { |plugin| plugin.apply_to_cli(self) }
+
+    # Load core CI runners AFTER plugins so GithubActions is the default (last registered wins)
+    require "bard/ci/local"
+    require "bard/ci/github_actions"
 
     def self.exit_on_failure? = true
 

data/lib/bard/config.rb

@@ -131,19 +131,7 @@ module Bard
       return nil if @ci_system == false
 
       require "bard/ci"
-
-      # Use the existing CI class which handles auto-detection
-      case @ci_system
-      when :local
-        CI.new(project_name, branch, local: true)
-      when :github_actions, :jenkins, nil
-        # CI class auto-detects between github_actions and jenkins
-        CI.new(project_name, branch)
-      when false
-        nil
-      else
-        CI.new(project_name, branch)
-      end
+      CI.new(project_name, branch, runner_name: @ci_system)
     end
 
     private

data/lib/bard/github.rb

@@ -3,6 +3,7 @@ require "json"
 require "base64"
 require "rbnacl"
 require "bard/ci/retryable"
+require "bard/secrets"
 
 module Bard
   class Github < Struct.new(:project_name)
@@ -107,10 +108,7 @@ module Bard
     private
 
     def api_key
-      @api_key ||= begin
-        raw = `git ls-remote -t git@github.com:botandrosedesign/secrets`
-        raw[/github-apikey\|(.+)$/, 1]
-      end
+      @api_key ||= Bard::Secrets.fetch("github-apikey")
     end
 
     def request path, &block

data/lib/bard/plugin.rb

@@ -0,0 +1,99 @@
+module Bard
+  class Plugin
+    @registry = {}
+
+    class << self
+      attr_reader :registry
+
+      def register(name, &block)
+        plugin = new(name)
+        plugin.instance_eval(&block) if block
+        @registry[name.to_sym] = plugin
+      end
+
+      def [](name)
+        @registry[name.to_sym]
+      end
+
+      def all
+        @registry.values
+      end
+
+      def load_all!
+        Dir[File.join(__dir__, "plugins", "*.rb")].sort.each { |f| require f }
+        all.each(&:apply!)
+      end
+
+      def reset!
+        @registry = {}
+      end
+    end
+
+    attr_reader :name, :cli_modules
+
+    def initialize(name)
+      @name = name.to_sym
+      @cli_modules = []
+      @cli_requires = []
+      @target_methods = {}
+      @config_methods = {}
+      @requires = []
+    end
+
+    # DSL methods for defining plugins
+
+    def require_file(path)
+      @requires << path
+    end
+
+    def cli(mod, require: nil)
+      @cli_requires << require if require
+      @cli_modules << mod
+    end
+
+    def target_method(name, &block)
+      @target_methods[name] = block
+    end
+
+    def config_method(name, &block)
+      @config_methods[name] = block
+    end
+
+    # Apply plugin to the system (non-CLI parts)
+    def apply!
+      @requires.each { |path| require path }
+      apply_target_methods!
+      apply_config_methods!
+    end
+
+    def apply_to_cli(cli_class)
+      @cli_requires.each { |path| require path }
+      @cli_modules.each do |mod|
+        mod = resolve_constant(mod) if mod.is_a?(String)
+        mod.setup(cli_class)
+      end
+    end
+
+    private
+
+    def apply_target_methods!
+      return if @target_methods.empty?
+      require "bard/target"
+      @target_methods.each do |method_name, block|
+        Target.define_method(method_name, &block)
+      end
+    end
+
+    def apply_config_methods!
+      return if @config_methods.empty?
+      require "bard/config"
+      @config_methods.each do |method_name, block|
+        Config.define_method(method_name, &block)
+      end
+    end
+
+    def resolve_constant(name)
+      name.split("::").reduce(Object) { |mod, const| mod.const_get(const) }
+    end
+  end
+end

data/lib/bard/plugins/backup.rb

@@ -0,0 +1,19 @@
+require "bard/plugin"
+
+Bard::Plugin.register :backup do
+  config_method :backup do |value = nil, &block|
+    if block
+      @backup = Bard::BackupConfig.new(&block)
+    elsif value == false
+      @backup = Bard::BackupConfig.new { disabled }
+    elsif value.nil? # Getter
+      @backup ||= Bard::BackupConfig.new { bard }
+    else
+      raise ArgumentError, "backup accepts false or a block"
+    end
+  end
+
+  config_method :backup_enabled? do
+    backup == true
+  end
+end

data/lib/bard/plugins/github_pages.rb

@@ -0,0 +1,34 @@
+require "bard/plugin"
+
+# Load the deploy strategy (auto-registers via inherited hook)
+require "bard/deploy_strategy/github_pages"
+
+Bard::Plugin.register :github_pages do
+  # Config DSL: github_pages "url" sets up a production target
+  config_method :github_pages do |url|
+    urls = []
+    uri = url.start_with?("http") ? URI.parse(url) : URI.parse("https://#{url}")
+    hostname = uri.hostname.sub(/^www\./, "")
+    urls = [hostname]
+    urls << "www.#{hostname}" if hostname.count(".") < 2
+
+    target :production do
+      github_pages url
+      ssh false
+      ping(*urls) if urls.any?
+    end
+
+    backup false
+  end
+
+  # Target DSL: github_pages sets deploy strategy
+  target_method :github_pages do |url = nil|
+    if url.nil?
+      @github_pages_url
+    else
+      @deploy_strategy = :github_pages
+      @github_pages_url = url
+      enable_capability(:github_pages)
+    end
+  end
+end

data/lib/bard/plugins/hurt.rb

@@ -0,0 +1,5 @@
+require "bard/plugin"
+
+Bard::Plugin.register :hurt do
+  cli "Bard::CLI::Hurt", require: "bard/cli/hurt"
+end

data/lib/bard/plugins/install.rb

@@ -0,0 +1,5 @@
+require "bard/plugin"
+
+Bard::Plugin.register :install do
+  cli "Bard::CLI::Install", require: "bard/cli/install"
+end

data/lib/bard/plugins/jenkins.rb

@@ -0,0 +1,6 @@
+require "bard/plugin"
+
+Bard::Plugin.register :jenkins do
+  # Jenkins CI runner - auto-registers via inherited hook when loaded
+  require_file "bard/ci/jenkins"
+end

data/lib/bard/plugins/new.rb

@@ -0,0 +1,5 @@
+require "bard/plugin"
+
+Bard::Plugin.register :new do
+  cli "Bard::CLI::New", require: "bard/cli/new"
+end

data/lib/bard/plugins/ping.rb

@@ -0,0 +1,6 @@
+require "bard/plugin"
+
+Bard::Plugin.register :ping do
+  cli "Bard::CLI::Ping", require: "bard/cli/ping"
+  cli "Bard::CLI::Open", require: "bard/cli/open"
+end

data/lib/bard/plugins/provision.rb

@@ -0,0 +1,5 @@
+require "bard/plugin"
+
+Bard::Plugin.register :provision do
+  cli "Bard::CLI::Provision", require: "bard/cli/provision"
+end

data/lib/bard/plugins/vim.rb

@@ -0,0 +1,5 @@
+require "bard/plugin"
+
+Bard::Plugin.register :vim do
+  cli "Bard::CLI::Vim", require: "bard/cli/vim"
+end

data/lib/bard/secrets.rb

@@ -0,0 +1,10 @@
+module Bard
+  module Secrets
+    REPO = "git@github.com:botandrosedesign/secrets"
+
+    def self.fetch(key)
+      raw = `git ls-remote -t #{REPO}`
+      raw[/#{Regexp.escape(key)}\|(.+)$/, 1]
+    end
+  end
+end

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.8.0"
+  VERSION = "1.9.0"
 end
 

data/spec/bard/ci/github_actions_spec.rb

@@ -1,35 +1,138 @@
+require "spec_helper"
 require "bard/ci/github_actions"
 
-describe Bard::CI::GithubActions do
-  subject { described_class.new("metrc", "master", "0966308e204b256fdcc11457eb53306d84884c60") }
+BASE_URL = "https://api.github.com/repos/botandrosedesign/metrc"
+
+RSpec.shared_context "github actions stubs" do
+  let(:run_id) { 123 }
+  let(:job_id) { 456 }
+  let(:started_at) { "2024-01-15T10:00:00Z" }
+  let(:completed_at) { "2024-01-15T10:01:30Z" }
+  let(:sha) { "abc123" }
+
+  let(:run_json) do
+    {
+      "id" => run_id,
+      "status" => "completed",
+      "conclusion" => "success",
+      "head_branch" => "master",
+      "head_sha" => sha,
+      "run_started_at" => started_at,
+      "updated_at" => completed_at,
+    }
+  end
 
-  xit "works" do
-    subject.run
+  let(:job_json) do
+    {
+      "id" => job_id,
+      "started_at" => started_at,
+      "completed_at" => completed_at,
+    }
+  end
+
+  before do
+    allow(Bard::Secrets).to receive(:fetch).with("github-apikey").and_return("test-key")
   end
 end
 
 describe Bard::CI::GithubActions::API do
+  include_context "github actions stubs"
+
   subject { described_class.new("metrc") }
 
   describe "#last_successful_run" do
-    xit "has #time_elapsed" do
+    before do
+      stub_request(:get, "#{BASE_URL}/actions/runs")
+        .with(query: hash_including("status" => "success"))
+        .to_return(
+          headers: { "Content-Type" => "application/json" },
+          body: JSON.dump("workflow_runs" => [run_json]),
+        )
+
+      stub_request(:get, "#{BASE_URL}/actions/runs/#{run_id}/jobs")
+        .with(query: hash_including("filter" => "latest"))
+        .to_return(
+          headers: { "Content-Type" => "application/json" },
+          body: JSON.dump("jobs" => [job_json]),
+        )
+    end
+
+    it "has #time_elapsed" do
       run = subject.last_successful_run
-      run.time_elapsed
+      expect(run.time_elapsed).to eq 90
     end
 
-    xit "has #console" do
-      subject.last_successful_run.console
+    it "has #console" do
+      stub_request(:get, "#{BASE_URL}/actions/jobs/#{job_id}/logs")
+        .to_return(
+          headers: { "Content-Type" => "text/plain" },
+          body: "build log output here",
+        )
+
+      expect(subject.last_successful_run.console).to eq "build log output here"
     end
   end
 
   describe "#create_run!" do
-    xit "returns a run" do
-      subject.create_run! "master"
+    it "returns a run" do
+      stub_request(:post, "#{BASE_URL}/actions/workflows/ci.yml/dispatches")
+        .to_return(status: 204, body: "")
+
+      allow(subject).to receive(:`).with("git rev-parse master").and_return("#{sha}\n")
+
+      stub_request(:get, "#{BASE_URL}/actions/runs")
+        .with(query: hash_including("head_sha" => sha))
+        .to_return(
+          headers: { "Content-Type" => "application/json" },
+          body: JSON.dump("workflow_runs" => [run_json]),
+        )
+
+      run = subject.create_run!("master")
+      expect(run).to be_a Bard::CI::GithubActions::Run
+      expect(run.id).to eq run_id
     end
   end
 end
 
-describe Bard::Github do
-  subject { described_class.new("metrc") }
-end
+describe Bard::CI::GithubActions do
+  include_context "github actions stubs"
+
+  subject { described_class.new("metrc", "master", sha) }
+
+  it "returns true on successful run" do
+    stub_request(:post, "#{BASE_URL}/actions/workflows/ci.yml/dispatches")
+      .to_return(status: 204, body: "")
+
+    allow_any_instance_of(Bard::CI::GithubActions::API)
+      .to receive(:`).with("git rev-parse master").and_return("#{sha}\n")
 
+    stub_request(:get, "#{BASE_URL}/actions/runs")
+      .with(query: hash_including("head_sha" => sha))
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump("workflow_runs" => [run_json]),
+      )
+
+    stub_request(:get, "#{BASE_URL}/actions/runs")
+      .with(query: hash_including("status" => "success"))
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump("workflow_runs" => [run_json]),
+      )
+
+    stub_request(:get, "#{BASE_URL}/actions/runs/#{run_id}/jobs")
+      .with(query: hash_including("filter" => "latest"))
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump("jobs" => [job_json]),
+      )
+
+    stub_request(:get, "#{BASE_URL}/actions/runs/#{run_id}")
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump(run_json),
+      )
+
+    expect(subject.run { }).to eq true
+  end
+end

data/spec/bard/ci/jenkins_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "bard/ci/jenkins"
+
+RSpec.describe Bard::CI::Jenkins do
+  let(:jenkins) { described_class.new("test-project", "master", "abc123") }
+
+  before do
+    allow(Bard::Secrets).to receive(:fetch).with("jenkins-user").and_return("micah")
+    allow(Bard::Secrets).to receive(:fetch).with("jenkins-token").and_return("fake-token")
+  end
+
+  describe "#get_last_time_elapsed" do
+    it "returns the duration in seconds from the last stable build" do
+      xml = "<build><duration>120000</duration></build>"
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/lastStableBuild/api/xml").and_return(xml)
+
+      result = jenkins.send(:get_last_time_elapsed)
+      expect(result).to eq 120
+    end
+  end
+
+  describe "#run" do
+    let(:ci_url) { "http://micah:fake-token@ci.botandrose.com/job/test-project" }
+
+    before do
+      allow(jenkins).to receive(:sleep)
+      state = instance_double(Bard::CI::State, save: nil, delete: nil)
+      allow(jenkins).to receive(:state).and_return(state)
+    end
+
+    it "waits until the build has started before polling" do
+      allow(jenkins).to receive(:`).with("curl -s -I -X POST -L '#{ci_url}/buildWithParameters?GIT_REF=master'").and_return("Location: http://ci.botandrose.com/queue/item/99/\r\n")
+      allow(jenkins).to receive(:`).with("curl -s #{ci_url}/lastStableBuild/api/xml").and_return("<build><duration>60000</duration></build>")
+      allow(jenkins).to receive(:`).with("curl -s -g '#{ci_url}/api/json?depth=1&tree=builds[queueId,number]'").and_return(
+        '{"builds":[{"queueId":1,"number":1}]}',
+        '{"builds":[{"queueId":99,"number":5}]}',
+        '{"builds":[{"queueId":99,"number":5}]}'
+      )
+      allow(jenkins).to receive(:`).with("curl -s #{ci_url}/5/api/json?tree=building,result").and_return('{"building":false,"result":"SUCCESS"}')
+
+      result = jenkins.run { |elapsed, last_time| }
+      expect(result).to eq true
+    end
+  end
+
+  describe "#started?" do
+    before do
+      jenkins.instance_variable_set(:@queueId, 99)
+    end
+
+    it "retries when builds list is empty (job just created)" do
+      allow(jenkins).to receive(:`).with(/api\/json\?depth=1/).and_return(
+        '{"builds":[]}',
+        '{"builds":[{"queueId":99,"number":1}]}'
+      )
+      allow(jenkins).to receive(:sleep)
+
+      expect(jenkins.send(:started?)).to eq true
+    end
+  end
+
+  describe "#exists?" do
+    it "returns truthy when the job exists" do
+      allow(jenkins).to receive(:`).with(/curl -s -I/).and_return("HTTP/1.1 200 OK\r\n")
+
+      expect(jenkins.exists?).to be_truthy
+    end
+
+    it "auto-creates the job when it does not exist" do
+      allow(jenkins).to receive(:`).with(/curl -s -I/).and_return("HTTP/1.1 404 Not Found\r\n")
+      allow(jenkins).to receive(:`).with("git remote get-url origin").and_return("git@gitlab.com:botandrose/test-project.git\n")
+      allow(File).to receive(:exist?).with("config/master.key").and_return(false)
+      expect(jenkins).to receive(:`).with(/curl -s -X POST.*createItem\?name=test-project.*Content-Type: application\/xml/)
+
+      jenkins.exists?
+    end
+
+    it "includes a master key build step when config/master.key exists" do
+      allow(jenkins).to receive(:`).with(/curl -s -I/).and_return("HTTP/1.1 404 Not Found\r\n")
+      allow(jenkins).to receive(:`).with("git remote get-url origin").and_return("git@gitlab.com:botandrose/test-project.git\n")
+      allow(File).to receive(:exist?).with("config/master.key").and_return(true)
+      allow(File).to receive(:read).with("config/master.key").and_return("abc123secret")
+
+      config_xml = nil
+      allow(jenkins).to receive(:`).with(/createItem/) do |cmd|
+        config_xml = cmd
+        ""
+      end
+
+      jenkins.exists?
+      expect(config_xml).to include("abc123secret")
+      expect(config_xml).to include("config/master.key")
+    end
+  end
+
+  describe "#building? and #success?" do
+    before do
+      jenkins.instance_variable_set(:@job_id, 42)
+    end
+
+    it "detects a successful build" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"building":false,"result":"SUCCESS"}')
+
+      expect(jenkins.send(:building?)).to eq false
+      expect(jenkins.send(:success?)).to eq true
+    end
+
+    it "detects a failed build" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"building":false,"result":"FAILURE"}')
+
+      expect(jenkins.send(:building?)).to eq false
+      expect(jenkins.send(:success?)).to eq false
+    end
+
+    it "detects a build in progress" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"building":true,"result":null}')
+
+      expect(jenkins.send(:building?)).to eq true
+    end
+
+    it "handles JSON with spaces in keys" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"_class":"hudson.model.FreeStyleBuild","building":false,"result":"SUCCESS"}')
+
+      expect(jenkins.send(:building?)).to eq false
+      expect(jenkins.send(:success?)).to eq true
+    end
+
+    it "success? reflects the last response from building?" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return(
+        '{"building":true,"result":null}',
+        '{"building":false,"result":"SUCCESS"}'
+      )
+
+      jenkins.send(:building?) # first call — still building
+      jenkins.send(:building?) # second call — done
+      expect(jenkins.send(:success?)).to eq true
+    end
+  end
+end

data/spec/bard/ci/runner_spec.rb

@@ -0,0 +1,61 @@
+require "bard/ci/runner"
+
+RSpec.describe Bard::CI::Runner do
+  describe ".runners" do
+    it "is a hash registry" do
+      expect(described_class.runners).to be_a(Hash)
+    end
+  end
+
+  describe ".[]" do
+    before do
+      require "bard/ci/local"
+      require "bard/ci/github_actions"
+    end
+
+    it "looks up runners by name" do
+      expect(described_class[:local]).to eq Bard::CI::Local
+      expect(described_class[:github_actions]).to eq Bard::CI::GithubActions
+    end
+
+    it "returns nil for unknown runners" do
+      expect(described_class[:nonexistent]).to be_nil
+    end
+  end
+
+  describe ".default" do
+    it "returns the last registered runner" do
+      # Whatever was registered last in the current test run
+      expect(described_class.default).to be_a(Class)
+      expect(described_class.default.ancestors).to include(Bard::CI::Runner)
+    end
+  end
+
+  describe "auto-registration via inherited" do
+    it "registers subclasses automatically" do
+      eval <<-RUBY
+        module Bard
+          class CI
+            class SpecTestRunner < Runner
+            end
+          end
+        end
+      RUBY
+
+      expect(described_class[:spec_test_runner]).to eq Bard::CI::SpecTestRunner
+    end
+
+    it "newly registered runner becomes the default" do
+      eval <<-RUBY
+        module Bard
+          class CI
+            class AnotherTestRunner < Runner
+            end
+          end
+        end
+      RUBY
+
+      expect(described_class.default).to eq Bard::CI::AnotherTestRunner
+    end
+  end
+end