bard 2.0.0.beta → 2.0.1

data/spec/bard/ci/runner_spec.rb

@@ -0,0 +1,61 @@
+require "bard/plugins/deploy/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/plugins/deploy/ci/local"
+      require "bard/plugins/deploy/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

data/spec/bard/ci_spec.rb

@@ -1,4 +1,4 @@
-require "bard/ci"
+require "bard/plugins/deploy/ci"
 
 describe Bard::CI do
   subject { described_class.new("tracker", "master") }

data/spec/bard/cli/ci_spec.rb

@@ -1,28 +1,14 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/ci"
-require "thor"
+require "ostruct"
 
-class TestCICLI < Thor
-  include Bard::CLI::CI
-
-  attr_reader :options
-
-  def initialize
-    super
-    @options = {}
-  end
-
-  def project_name
-    "test_project"
-  end
-end
-
-describe Bard::CLI::CI do
-  let(:cli) { TestCICLI.new }
+describe "bard ci" do
+  let(:cli) { Bard::CLI.new }
   let(:ci_runner) { double("ci_runner") }
 
   before do
+    allow(cli).to receive(:config).and_return(OpenStruct.new(ci: nil))
+    allow(cli).to receive(:project_name).and_return("test_project")
     allow(cli).to receive(:puts)
     allow(cli).to receive(:print)
     allow(cli).to receive(:exit)
@@ -101,12 +87,9 @@ describe Bard::CLI::CI do
       it "shows error message and exits" do
         allow(cli).to receive(:options).and_return({})
         allow(ci_runner).to receive(:exists?).and_return(false)
+        allow(cli).to receive(:exit).with(1).and_raise(SystemExit)
 
-        expect(cli).to receive(:puts) # "No CI found for test_project!"
-        expect(cli).to receive(:puts) # "Re-run with --skip-ci to bypass CI..."
-        expect(cli).to receive(:exit).with(1)
-
-        cli.ci
+        expect { cli.ci }.to raise_error(SystemExit)
       end
     end
 
@@ -116,7 +99,7 @@ describe Bard::CLI::CI do
         allow(ci_runner).to receive(:exists?).and_return(true)
         allow(ci_runner).to receive(:run).and_return(true)
 
-        expect(Bard::CI).to receive(:new).with("test_project", "develop", local: nil)
+        expect(Bard::CI).to receive(:new).with("test_project", "develop", runner_name: nil)
         expect(cli).to receive(:puts).with("Continuous integration: starting build on develop...")
 
         cli.ci("develop")
@@ -124,12 +107,36 @@ describe Bard::CLI::CI do
     end
 
     context "with local-ci option" do
-      it "passes local option to CI runner" do
+      it "passes local runner_name to CI" do
         allow(cli).to receive(:options).and_return({ "local-ci" => true })
         allow(ci_runner).to receive(:exists?).and_return(true)
         allow(ci_runner).to receive(:run).and_return(true)
 
-        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", local: true)
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", runner_name: :local)
+
+        cli.ci
+      end
+    end
+
+    context "with ci option" do
+      it "passes specified runner_name to CI" do
+        allow(cli).to receive(:options).and_return({ "ci" => "jenkins" })
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:run).and_return(true)
+
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", runner_name: :jenkins)
+
+        cli.ci
+      end
+    end
+
+    context "with both local-ci and ci options" do
+      it "local-ci takes precedence" do
+        allow(cli).to receive(:options).and_return({ "local-ci" => true, "ci" => "jenkins" })
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:run).and_return(true)
+
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", runner_name: :local)
 
         cli.ci
       end

data/spec/bard/cli/data_spec.rb

@@ -1,35 +1,15 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/data"
 
-require "thor"
-
-require "term/ansicolor"
-
-class TestCLI < Thor
-  include Bard::CLI::Data
-  include Term::ANSIColor
-
-  attr_reader :config
-
-  def initialize
-    @config = {}
-  end
-
-  def options
-    {}
-  end
-end
-
-describe Bard::CLI::Data do
-  let(:cli) { TestCLI.new }
+describe "bard data" do
+  let(:cli) { Bard::CLI.new }
 
   it "should have a data command" do
     expect(cli).to respond_to(:data)
   end
 
   context "data" do
-    let(:from) { double("from", key: :production, run!: nil, copy_file: nil, copy_dir: nil) }
+    let(:from) { double("from", key: :production, run!: nil, require_capability!: nil) }
     let(:to) { double("to", key: :local, run!: nil) }
 
     let(:config) do
@@ -42,17 +22,18 @@ describe Bard::CLI::Data do
     before do
       allow(cli).to receive(:config).and_return(config)
       allow(cli).to receive(:options).and_return({from: "production", to: "local"})
+      allow(cli).to receive(:puts)
     end
 
     it "should run the data command" do
       expect(from).to receive(:run!).with("bin/rake db:dump")
-      expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+      expect(Bard::Copy).to receive(:file).with("db/data.sql.gz", from: from, to: to, verbose: true)
       expect(to).to receive(:run!).with("bin/rake db:load")
       cli.data
     end
 
     context "pushing to production" do
-      let(:to) { double("to", key: :production, ping: ["https://example.com"]) }
+      let(:to) { double("to", key: :production, url: "https://example.com", run!: nil, require_capability!: nil) }
 
       before do
         allow(cli).to receive(:options).and_return({from: "local", to: "production"})
@@ -68,7 +49,7 @@ describe Bard::CLI::Data do
       it "should allow pushing to production if the user confirms" do
         expect(cli).to receive(:ask).and_return("https://example.com")
         expect(from).to receive(:run!).with("bin/rake db:dump")
-        expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+        expect(Bard::Copy).to receive(:file).with("db/data.sql.gz", from: from, to: to, verbose: true)
         expect(to).to receive(:run!).with("bin/rake db:load")
         cli.data
       end

data/spec/bard/cli/deploy_spec.rb

@@ -1,42 +1,29 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/deploy"
-require "thor"
 
-class TestDeployCLI < Thor
-  include Bard::CLI::Deploy
-
-  attr_reader :config, :options
-
-  def initialize
-    super
-    @config = {}
-    @options = {}
-  end
-
-  def project_name
-    "test_project"
-  end
-end
-
-describe Bard::CLI::Deploy do
-  let(:production_server) { double("production", run!: true, github_pages: false, path: "/var/www/test_project") }
+describe "bard deploy" do
+  let(:deploy_strategy) { double("deploy_strategy", deploy: true) }
+  let(:production_server) { double("production", run!: true, path: "/var/www/test_project", deploy_strategy: :ssh, deploy_strategy_instance: deploy_strategy) }
   let(:config) { { production: production_server } }
-  let(:cli) { TestDeployCLI.new }
+  let(:cli) { Bard::CLI.new }
 
   before do
+    allow(config).to receive(:ci).and_return(nil)
     allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:options).and_return({ target: "production" })
     allow(cli).to receive(:puts)
     allow(cli).to receive(:exit)
     allow(cli).to receive(:run!)
     allow(cli).to receive(:invoke)
     allow(cli).to receive(:ping)
+    allow(cli).to receive(:project_name).and_return("test_project")
     allow(cli).to receive(:green).and_return("")
     allow(cli).to receive(:red).and_return("")
     allow(cli).to receive(:yellow).and_return("")
     allow(Bard::Git).to receive(:current_branch).and_return("feature-branch")
     allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(true)
     allow(Bard::Git).to receive(:fast_forward_merge?).and_return(true)
+    allow(Bard::Git).to receive(:in_linked_worktree?).and_return(false)
     allow(cli).to receive(:`).and_return("")
   end
 
@@ -48,7 +35,7 @@ describe Bard::CLI::Deploy do
     context "when on master branch" do
       before do
         allow(Bard::Git).to receive(:current_branch).and_return("master")
-        allow(cli).to receive(:options).and_return({})
+        allow(cli).to receive(:options).and_return({ target: "production" })
       end
 
       context "when up to date with remote" do
@@ -57,8 +44,7 @@ describe Bard::CLI::Deploy do
 
           expect(cli).not_to receive(:run!).with(/git push/)
           expect(cli).to receive(:invoke).with(:ci, ["master"], {})
-          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
-          expect(cli).to receive(:puts) # "Deploy Succeeded"
+          expect(deploy_strategy).to receive(:deploy)
           expect(cli).to receive(:ping).with(:production)
 
           cli.deploy
@@ -71,7 +57,7 @@ describe Bard::CLI::Deploy do
 
           expect(cli).to receive(:run!).with("git push origin master:master")
           expect(cli).to receive(:invoke).with(:ci, ["master"], {})
-          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+          expect(deploy_strategy).to receive(:deploy)
 
           cli.deploy
         end
@@ -79,10 +65,21 @@ describe Bard::CLI::Deploy do
 
       context "with skip-ci option" do
         it "skips CI step" do
-          allow(cli).to receive(:options).and_return({ "skip-ci" => true })
+          allow(cli).to receive(:options).and_return({ "skip-ci" => true, target: "production" })
+
+          expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
+          expect(deploy_strategy).to receive(:deploy)
+
+          cli.deploy
+        end
+      end
+
+      context "with ci disabled in config" do
+        it "skips CI step" do
+          allow(config).to receive(:ci).and_return(false)
 
           expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
-          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+          expect(deploy_strategy).to receive(:deploy)
 
           cli.deploy
         end
@@ -91,17 +88,17 @@ describe Bard::CLI::Deploy do
 
     context "when on feature branch" do
       before do
-        allow(cli).to receive(:options).and_return({})
+        allow(cli).to receive(:options).and_return({ target: "production" })
       end
 
       context "with fast-forward merge possible" do
         it "fetches master, pushes branch, runs CI, merges to master, and deploys" do
-          expect(cli).to receive(:run!).with("git fetch origin master:master")
+          expect(cli).to receive(:run!).with("git fetch origin")
+          expect(cli).to receive(:run!).with("git fetch origin master:master").twice
           expect(cli).to receive(:run!).with("git push -f origin feature-branch:feature-branch")
           expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], {})
           expect(cli).to receive(:run!).with("git push origin feature-branch:master")
-          expect(cli).to receive(:run!).with("git fetch origin master:master")
-          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+          expect(deploy_strategy).to receive(:deploy)
 
           cli.deploy
         end
@@ -116,6 +113,27 @@ describe Bard::CLI::Deploy do
         end
       end
 
+      context "when run from a linked worktree" do
+        before do
+          allow(Bard::Git).to receive(:in_linked_worktree?).and_return(true)
+          allow(cli).to receive(:`).with("git rev-parse --git-common-dir").and_return("/main/checkout/.git\n")
+          allow(Dir).to receive(:pwd).and_return("/main/checkout/tmp/worktrees/feature-branch")
+          allow(Dir).to receive(:chdir).with("/main/checkout")
+        end
+
+        it "skips writes to local master, removes the worktree, and reports where to cd back" do
+          expect(cli).not_to receive(:run!).with("git fetch origin master:master")
+          expect(cli).not_to receive(:run!).with("git checkout master")
+          expect(cli).to receive(:run!).with("git fetch origin master")
+          expect(Dir).to receive(:chdir).with("/main/checkout")
+          expect(cli).to receive(:run!).with("git worktree remove /main/checkout/tmp/worktrees/feature-branch")
+          expect(cli).to receive(:run!).with("git branch -D feature-branch")
+          expect(cli).to receive(:puts).with("Worktree removed. Run: cd /main/checkout")
+
+          cli.deploy
+        end
+      end
+
       context "when rebase is needed" do
         it "attempts rebase before proceeding" do
           allow(Bard::Git).to receive(:fast_forward_merge?).and_return(false)
@@ -129,6 +147,20 @@ describe Bard::CLI::Deploy do
       end
     end
 
+    context "when on feature branch with ci disabled in config" do
+      before do
+        allow(cli).to receive(:options).and_return({ target: "production" })
+        allow(config).to receive(:ci).and_return(false)
+      end
+
+      it "skips CI step" do
+        expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
+        expect(deploy_strategy).to receive(:deploy)
+
+        cli.deploy
+      end
+    end
+
     context "with github remote" do
       it "pushes to github remote" do
         allow(cli).to receive(:`).with("git remote").and_return("origin\ngithub\n")
@@ -140,41 +172,40 @@ describe Bard::CLI::Deploy do
     end
 
     context "with clone option" do
-      it "clones repository and sets up application" do
-        allow(cli).to receive(:options).and_return({ clone: true })
+      it "deploys with clone option to strategy" do
+        allow(cli).to receive(:options).and_return({ clone: true, target: "production" })
 
-        expect(production_server).to receive(:run!).with("git clone git@github.com:botandrosedesign/test_project /var/www/test_project", home: true)
-        expect(cli).to receive(:invoke).with(:master_key, [], from: "local", to: :production)
-        expect(production_server).to receive(:run!).with("bin/setup && bard setup")
+        expect(deploy_strategy).to receive(:deploy).with(clone: "test_project")
 
         cli.deploy
       end
     end
 
     context "with github pages" do
-      it "deploys to github pages" do
-        allow(production_server).to receive(:github_pages).and_return(true)
-        github_pages = double("github_pages")
-        allow(Bard::GithubPages).to receive(:new).and_return(github_pages)
+      let(:deploy_strategy) { double("github_pages_strategy") }
+      let(:production_server) { double("production", run!: true, path: "/var/www/test_project", deploy_strategy: :github_pages, deploy_strategy_instance: deploy_strategy) }
 
-        expect(github_pages).to receive(:deploy).with(production_server)
+      it "deploys using deploy strategy" do
+        expect(deploy_strategy).to receive(:deploy)
 
         cli.deploy
       end
     end
 
     context "with custom deployment target" do
-      let(:staging_server) { double("staging", run!: true, github_pages: false) }
+      let(:staging_strategy) { double("staging_strategy", deploy: true) }
+      let(:staging_server) { double("staging", run!: true, deploy_strategy: :ssh, deploy_strategy_instance: staging_strategy) }
 
       before do
         allow(config).to receive(:[]).with(:staging).and_return(staging_server)
+        allow(cli).to receive(:options).and_return({ target: "staging" })
       end
 
       it "deploys to specified target" do
-        expect(staging_server).to receive(:run!).with("git pull origin master && bin/setup")
+        expect(staging_strategy).to receive(:deploy)
         expect(cli).to receive(:ping).with(:staging)
 
-        cli.deploy(:staging)
+        cli.deploy
       end
     end
 
@@ -191,12 +222,22 @@ describe Bard::CLI::Deploy do
 
     context "with local-ci option" do
       it "passes local-ci option to CI invocation" do
-        allow(cli).to receive(:options).and_return({ "local-ci" => true })
+        allow(cli).to receive(:options).and_return({ "local-ci" => true, target: "production" })
 
         expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], { "local-ci" => true })
 
         cli.deploy
       end
     end
+
+    context "with ci option" do
+      it "passes ci option to CI invocation" do
+        allow(cli).to receive(:options).and_return({ "ci" => "jenkins", target: "production" })
+
+        expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], { "ci" => "jenkins" })
+
+        cli.deploy
+      end
+    end
   end
-end
+end

data/spec/bard/cli/hurt_spec.rb

@@ -1,14 +1,8 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/hurt"
-require "thor"
 
-class TestHurtCLI < Thor
-  include Bard::CLI::Hurt
-end
-
-describe Bard::CLI::Hurt do
-  let(:cli) { TestHurtCLI.new }
+describe "bard hurt" do
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:puts)
@@ -20,4 +14,4 @@ describe Bard::CLI::Hurt do
       expect(cli).to respond_to(:hurt)
     end
   end
-end
+end

data/spec/bard/cli/install_spec.rb

@@ -1,14 +1,8 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/install"
-require "thor"
 
-class TestInstallCLI < Thor
-  include Bard::CLI::Install
-end
-
-describe Bard::CLI::Install do
-  let(:cli) { TestInstallCLI.new }
+describe "bard install" do
+  let(:cli) { Bard::CLI.new }
 
   describe "#install" do
     it "should have an install command" do
@@ -16,10 +10,10 @@ describe Bard::CLI::Install do
     end
 
     it "should copy install files to bin directory" do
-      expect(cli).to receive(:system).with(/cp -R .*install_files\/\* bin\//)
-      expect(cli).to receive(:system).with(/cp -R .*install_files\/\.github \.\//)
+      expect(cli).to receive(:system).with(/cp -R .*plugins\/install\/\* bin\//)
+      expect(cli).to receive(:system).with(/cp -R .*plugins\/install\/\.github \.\//)
 
       cli.install
     end
   end
-end
+end

data/spec/bard/cli/master_key_spec.rb

@@ -1,25 +1,11 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/master_key"
-require "thor"
 
-class TestMasterKeyCLI < Thor
-  include Bard::CLI::MasterKey
-
-  attr_reader :config, :options
-
-  def initialize
-    super
-    @config = {}
-    @options = {}
-  end
-end
-
-describe Bard::CLI::MasterKey do
+describe "bard master_key" do
   let(:from_server) { double("production") }
   let(:to_server) { double("local") }
   let(:config) { { production: from_server, local: to_server } }
-  let(:cli) { TestMasterKeyCLI.new }
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:config).and_return(config)
@@ -34,7 +20,7 @@ describe Bard::CLI::MasterKey do
       allow(config).to receive(:[]).with("production").and_return(from_server)
       allow(config).to receive(:[]).with("local").and_return(to_server)
       allow(cli).to receive(:options).and_return({ from: "production", to: "local" })
-      expect(from_server).to receive(:copy_file).with("config/master.key", to: to_server)
+      expect(Bard::Copy).to receive(:file).with("config/master.key", from: from_server, to: to_server)
 
       cli.master_key
     end
@@ -44,9 +30,9 @@ describe Bard::CLI::MasterKey do
       allow(config).to receive(:[]).with("production").and_return(staging_server)
       allow(config).to receive(:[]).with("local").and_return(to_server)
       allow(cli).to receive(:options).and_return({ from: "production", to: "local" })
-      expect(staging_server).to receive(:copy_file).with("config/master.key", to: to_server)
+      expect(Bard::Copy).to receive(:file).with("config/master.key", from: staging_server, to: to_server)
 
       cli.master_key
     end
   end
-end
+end

data/spec/bard/cli/open_spec.rb

@@ -1,30 +1,14 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/open"
-require "thor"
 
-class TestOpenCLI < Thor
-  include Bard::CLI::Open
-
-  attr_reader :config
-
-  def initialize
-    super
-    @config = {}
-  end
-
-  def project_name
-    "test_project"
-  end
-end
-
-describe Bard::CLI::Open do
-  let(:server) { double("server", ping: ["https://example.com"]) }
-  let(:config) { { production: server } }
-  let(:cli) { TestOpenCLI.new }
+describe "bard open" do
+  let(:target) { double("target", url: "https://example.com", require_capability!: nil) }
+  let(:config) { { production: target } }
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:project_name).and_return("test_project")
     allow(cli).to receive(:exec)
   end
 
@@ -33,14 +17,14 @@ describe Bard::CLI::Open do
       expect(cli).to respond_to(:open)
     end
 
-    it "should open production server URL by default" do
+    it "should open production target URL by default" do
       expect(cli).to receive(:exec).with("xdg-open https://example.com")
 
       cli.open
     end
 
-    it "should open specified server URL" do
-      staging_server = double("staging", ping: ["https://staging.example.com"])
+    it "should open specified target URL" do
+      staging_server = double("staging", url: "https://staging.example.com", require_capability!: nil)
       allow(config).to receive(:[]).with(:staging).and_return(staging_server)
 
       expect(cli).to receive(:exec).with("xdg-open https://staging.example.com")
@@ -48,7 +32,7 @@ describe Bard::CLI::Open do
       cli.open(:staging)
     end
 
-    it "should open CI URL when server is ci" do
+    it "should open CI URL when target is ci" do
       expect(cli).to receive(:exec).with("xdg-open https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
 
       cli.open(:ci)
@@ -56,12 +40,12 @@ describe Bard::CLI::Open do
   end
 
   describe "#open_url" do
-    it "returns CI URL for ci server" do
-      expect(cli.send(:open_url, :ci)).to eq("https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
+    it "returns CI URL for ci target" do
+      expect(cli.open_url(:ci)).to eq("https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
     end
 
-    it "returns server ping URL for other servers" do
-      expect(cli.send(:open_url, :production)).to eq("https://example.com")
+    it "returns target url for other targets" do
+      expect(cli.open_url(:production)).to eq("https://example.com")
     end
   end
-end
+end