bard 1.8.0 → 1.9.1

data/lib/bard/cli.rb

@@ -1,8 +1,10 @@
 # this file gets loaded in the CLI context, not the Rails boot context
 
 require "thor"
+require "bard/version"
 require "bard/config"
 require "bard/command"
+require "bard/plugin"
 require "term/ansicolor"
 
 module Bard
@@ -19,23 +21,23 @@ 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)
+    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"
+
+    map "--version" => :version
+    desc "version", "Display version"
+    def version
+      puts Bard::VERSION
     end
 
     def self.exit_on_failure? = true

data/lib/bard/command.rb

@@ -17,9 +17,9 @@ module Bard
     end
 
     def run! verbose: false, quiet: false
-      if !run(verbose:, quiet:)
-        raise Error.new(full_command)
-      end
+      result = run(verbose:, quiet:)
+      raise Error.new(full_command) unless result
+      result
     end
 
     def run verbose: false, quiet: false

data/lib/bard/config.rb

@@ -52,7 +52,9 @@ module Bard
     # New v2.0 API - creates Target instances
     def target(key, &block)
       key = key.to_sym
-      @servers[key] ||= Target.new(key, self)
+      unless @servers[key].is_a?(Target)
+        @servers[key] = Target.new(key, self)
+      end
       @servers[key].instance_eval(&block) if block
       @servers[key]
     end
@@ -131,19 +133,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/provision/ssh.rb

@@ -19,7 +19,14 @@ class Bard::Provision::SSH < Bard::Provision
         add_ssh_known_host!(provision_server.ssh_uri)
       end
       print " Reconfiguring port to #{target_port},"
-      provision_server.run! %(echo "Port #{target_port}" | sudo tee /etc/ssh/sshd_config.d/port_#{target_port}.conf; sudo service ssh restart), home: true
+      provision_server.run! %(echo "Port #{target_port}" | sudo tee /etc/ssh/sshd_config.d/port_#{target_port}.conf && sudo service ssh restart), home: true
+      5.times do
+        sleep 1
+        break if ssh_available?(provision_server.ssh_uri, port: target_port)
+      end
+      if !ssh_available?(provision_server.ssh_uri, port: target_port)
+        raise "reconfigured SSH to port #{target_port} but it's not responding — check firewall and sshd_config Include directive"
+      end
     end
 
     if !ssh_known_host?(provision_server.ssh_uri)
@@ -65,7 +72,7 @@ class Bard::Provision::SSH < Bard::Provision
 
   def disable_password_auth!
     provision_server.run!(
-      %q{echo "PasswordAuthentication no" | sudo tee /etc/ssh/sshd_config.d/disable_password_auth.conf; sudo service ssh restart},
+      %q{echo "PasswordAuthentication no" | sudo tee /etc/ssh/sshd_config.d/disable_password_auth.conf && sudo service ssh restart},
       home: true
     )
   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/server.rb

@@ -135,8 +135,9 @@ module Bard
       key
     end
 
-    def run! command, home: false, verbose: false, quiet: false
-      Bard::Command.run! command, on: self, home:, verbose:, quiet:
+    def run! command, home: false, verbose: false, quiet: false, capture: false
+      result = Bard::Command.run!(command, on: self, home:, verbose:, quiet:)
+      result if capture
     end
 
     def run command, home: false, verbose: false, quiet: false

data/lib/bard/target.rb

@@ -217,9 +217,10 @@ module Bard
     end
 
     # Remote command execution
-    def run!(command, home: false, verbose: false, quiet: false)
+    def run!(command, home: false, verbose: false, quiet: false, capture: false)
       require_capability!(:ssh)
-      Command.run!(command, on: self, home: home, verbose: verbose, quiet: quiet)
+      result = Command.run!(command, on: self, home: home, verbose: verbose, quiet: quiet)
+      result if capture
     end
 
     def run(command, home: false, verbose: false, quiet: false)

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.8.0"
+  VERSION = "1.9.1"
 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