bard 2.0.0.beta → 2.0.0

data/spec/bard/cli/ssh_spec.rb

@@ -1,27 +1,14 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/ssh"
-require "thor"
 
-class TestSSHCLI < Thor
-  include Bard::CLI::SSH
-
-  attr_reader :config, :options
-
-  def initialize
-    super
-    @config = {}
-    @options = {}
-  end
-end
-
-describe Bard::CLI::SSH do
-  let(:server) { double("server") }
-  let(:config) { { production: server } }
-  let(:cli) { TestSSHCLI.new }
+describe "bard ssh" do
+  let(:target) { double("target") }
+  let(:config) { { production: target } }
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:options).and_return({ home: false })
   end
 
   describe "#ssh" do
@@ -29,27 +16,25 @@ describe Bard::CLI::SSH do
       expect(cli).to respond_to(:ssh)
     end
 
-    it "should execute shell on production server by default" do
-      allow(cli).to receive(:options).and_return({ home: false })
-      expect(server).to receive(:exec!).with("exec $SHELL -l", home: false)
+    it "should execute shell on production target by default" do
+      expect(target).to receive(:exec!).with("exec $SHELL -l", home: false)
 
       cli.ssh
     end
 
     it "should execute shell with home option when specified" do
       allow(cli).to receive(:options).and_return({ home: true })
-      expect(server).to receive(:exec!).with("exec $SHELL -l", home: true)
+      expect(target).to receive(:exec!).with("exec $SHELL -l", home: true)
 
       cli.ssh
     end
 
-    it "should connect to specified server" do
+    it "should connect to specified target" do
       staging_server = double("staging")
       allow(config).to receive(:[]).with(:staging).and_return(staging_server)
-      allow(cli).to receive(:options).and_return({ home: false })
       expect(staging_server).to receive(:exec!).with("exec $SHELL -l", home: false)
 
       cli.ssh(:staging)
     end
   end
-end
+end

data/spec/bard/cli/stage_spec.rb

@@ -1,24 +1,13 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/stage"
-require "thor"
 
-class TestStageCLI < Thor
-  include Bard::CLI::Stage
-
-  attr_reader :config
-
-  def initialize
-    super
-    @config = nil
-  end
-end
-
-describe Bard::CLI::Stage do
-  let(:staging_server) { double("staging") }
-  let(:servers) { { production: double("production"), staging: staging_server } }
-  let(:config) { double("config", servers: servers) }
-  let(:cli) { TestStageCLI.new }
+describe "bard stage" do
+  let(:staging_strategy) { double("staging_strategy", deploy: true) }
+  let(:staging_server) { double("staging", deploy_strategy: :ssh, deploy_strategy_instance: staging_strategy) }
+  let(:production_server) { double("production") }
+  let(:targets) { { production: production_server, staging: staging_server } }
+  let(:config) { double("config", targets: targets) }
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:config).and_return(config)
@@ -31,6 +20,7 @@ describe Bard::CLI::Stage do
     allow(cli).to receive(:yellow).and_return("")
     allow(Bard::Git).to receive(:current_branch).and_return("main")
     allow(config).to receive(:[]).with(:staging).and_return(staging_server)
+    allow(config).to receive(:[]).with(:production).and_return(production_server)
   end
 
   describe "#stage" do
@@ -41,7 +31,7 @@ describe Bard::CLI::Stage do
     context "when production server is defined" do
       it "pushes branch and stages it" do
         expect(cli).to receive(:run!).with("git push -u origin main", verbose: true)
-        expect(staging_server).to receive(:run!).with("git fetch && git checkout -f origin/main && bin/setup")
+        expect(staging_strategy).to receive(:deploy)
         expect(cli).to receive(:ping).with(:staging)
 
         cli.stage
@@ -49,14 +39,29 @@ describe Bard::CLI::Stage do
 
       it "accepts custom branch" do
         expect(cli).to receive(:run!).with("git push -u origin develop", verbose: true)
-        expect(staging_server).to receive(:run!).with("git fetch && git checkout -f origin/develop && bin/setup")
+        expect(staging_strategy).to receive(:deploy)
 
         cli.stage("develop")
       end
     end
 
-    context "when production server is not defined" do
-      let(:servers) { { staging: staging_server } }
+    context "when staging target has a deploy strategy" do
+      let(:strategy_instance) { double("strategy") }
+      let(:staging_server) { double("staging", deploy_strategy: :fake, deploy_strategy_instance: strategy_instance) }
+
+      it "uses the deploy strategy" do
+        expect(cli).to receive(:run!).with("git push -u origin main", verbose: true)
+        expect(strategy_instance).to receive(:deploy)
+        expect(cli).to receive(:ping).with(:staging)
+
+        cli.stage
+      end
+    end
+
+    context "when production target is equivalent to staging" do
+      before do
+        allow(config).to receive(:[]).with(:production).and_return(staging_server)
+      end
 
       it "raises an error" do
         expect { cli.stage }.to raise_error(Thor::Error, /bard stage.*is disabled/)
@@ -74,4 +79,4 @@ describe Bard::CLI::Stage do
       end
     end
   end
-end
+end

data/spec/bard/cli/vim_spec.rb

@@ -1,14 +1,8 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/vim"
-require "thor"
 
-class TestVimCLI < Thor
-  include Bard::CLI::Vim
-end
-
-describe Bard::CLI::Vim do
-  let(:cli) { TestVimCLI.new }
+describe "bard vim" do
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:exec)
@@ -31,4 +25,4 @@ describe Bard::CLI::Vim do
       cli.vim("develop")
     end
   end
-end
+end

data/spec/bard/command_spec.rb

@@ -2,18 +2,11 @@ require "spec_helper"
 require "bard/command"
 
 describe Bard::Command do
-  let(:remote) { double("remote", to_sym: :remote, ssh: true, env: nil, path: "/path/to", ssh_key: nil, ssh_uri: "user@example.com", gateway: nil) }
-
   describe ".run" do
     it "should run a command locally" do
       expect(Open3).to receive(:capture3).with("ls -l").and_return(["output", "", 0])
       Bard::Command.run "ls -l"
     end
-
-    it "should run a command on a remote server" do
-      expect(Open3).to receive(:capture3).with("ssh -tt  user@example.com 'cd /path/to && ls -l'").and_return(["output", "", 0])
-      Bard::Command.run "ls -l", on: remote
-    end
   end
 
   describe ".run!" do
@@ -30,7 +23,7 @@ describe Bard::Command do
 
   describe ".exec!" do
     it "should exec a command locally" do
-      expect_any_instance_of(Bard::Command).to receive(:exec).with("ls -l")
+      expect(Kernel).to receive(:exec).with("ls -l")
       Bard::Command.exec! "ls -l"
     end
   end

data/spec/bard/config_spec.rb

@@ -1,6 +1,51 @@
 require "bard/config"
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/data"
+require "bard/plugins/github_pages"
 
 describe Bard::Config do
+  describe ".detect_project_name" do
+    let(:tmpdir) { Dir.mktmpdir("bard-detect-test") }
+    after { FileUtils.rm_rf(tmpdir) }
+
+    def init_repo(path)
+      FileUtils.mkdir_p(path)
+      Dir.chdir(path) do
+        system("git init -q")
+        system("git commit --allow-empty -q -m init")
+      end
+    end
+
+    it "returns the repo dir basename when run from the main checkout" do
+      repo = File.join(tmpdir, "myproject")
+      init_repo(repo)
+
+      Dir.chdir(repo) do
+        expect(described_class.detect_project_name).to eq("myproject")
+      end
+    end
+
+    it "returns the main repo basename when run from a sibling worktree" do
+      repo = File.join(tmpdir, "myproject")
+      init_repo(repo)
+      Dir.chdir(repo) { system("git worktree add -q ../wt-feature -b feature") }
+
+      Dir.chdir(File.join(tmpdir, "wt-feature")) do
+        expect(described_class.detect_project_name).to eq("myproject")
+      end
+    end
+
+    it "returns the main repo basename when run from a nested worktree" do
+      repo = File.join(tmpdir, "myproject")
+      init_repo(repo)
+      Dir.chdir(repo) { system("git worktree add -q tmp/worktrees/wt-feature -b feature") }
+
+      Dir.chdir(File.join(repo, "tmp/worktrees/wt-feature")) do
+        expect(described_class.detect_project_name).to eq("myproject")
+      end
+    end
+  end
+
   context "empty" do
     subject { described_class.new("tracker") }
 
@@ -10,15 +55,22 @@ describe Bard::Config do
       end
     end
 
-    describe "#servers" do
-      it "is prefilled with many servers" do
-        expect(subject.servers.keys).to eq %i[local gubs ci staging]
+    describe "#targets" do
+      it "is prefilled with default targets" do
+        expect(subject.targets.keys).to eq %i[local gubs ci staging production]
+      end
+
+      it "creates Target instances for defaults" do
+        subject.targets.each_value do |target|
+          expect(target).to be_a(Bard::Target)
+        end
       end
     end
 
     describe "#[]" do
-      it "promotes staging to production when production doesn't exist" do
+      it "defines a default production target equivalent to staging" do
         expect(subject[:production]).to eq subject[:staging]
+        expect(subject[:production]).not_to equal subject[:staging]
       end
     end
 
@@ -27,26 +79,16 @@ describe Bard::Config do
         expect(subject.data).to eq []
       end
     end
-
-    describe "#backup" do
-      it "returns a BackupConfig with bard enabled by default" do
-        backup = subject.backup
-        expect(backup).to be_a(Bard::BackupConfig)
-        expect(backup.bard?).to eq true
-        expect(backup.destinations).to be_empty
-      end
-    end
   end
 
   context "with production definition" do
     subject { described_class.new("tracker", source: <<~SOURCE) }
-      server :production do
+      target :production do
         ssh "www@ssh.botandrose.com:22022"
-        ping "tracker.botandrose.com"
+        url "tracker.botandrose.com"
       end
 
       data "public/system", "public/ckeditor"
-      backup false
     SOURCE
 
     describe "#project_name" do
@@ -55,18 +97,18 @@ describe Bard::Config do
       end
     end
 
-    describe "#servers" do
-      it "contains the defined server" do
-        expect(subject.servers.keys).to eq %i[local gubs ci staging production]
+    describe "#targets" do
+      it "contains the defined target" do
+        expect(subject.targets.keys).to eq %i[local gubs ci staging production]
       end
     end
 
-    describe "#server" do
+    describe "#target" do
       it "can overwrite existing definition" do
-        subject.server :staging do
+        subject.target :staging do
           ssh "www@tracker-staging.botandrose.com:22022"
         end
-        expect(subject[:staging].ssh).to eq "www@tracker-staging.botandrose.com:22022"
+        expect(subject[:staging].server.to_s).to eq "www@tracker-staging.botandrose.com:22022"
       end
     end
 
@@ -75,96 +117,34 @@ describe Bard::Config do
         expect(subject.data).to eq ["public/system", "public/ckeditor"]
       end
     end
-
-    describe "#backup" do
-      it "returns the backup setting" do
-        expect(subject.backup).to be_disabled
-      end
-    end
   end
 
-  context "with new backup block syntax" do
-    describe "#backup with bard directive" do
-      subject { described_class.new("test", source: "backup { bard }") }
-
-      it "returns a BackupConfig with bard enabled" do
-        backup = subject.backup
-        expect(backup).to be_a(Bard::BackupConfig)
-        expect(backup.bard?).to eq true
-        expect(backup.destinations).to be_empty
-        expect(backup.self_managed?).to eq false
-      end
-    end
-
-    describe "#backup with s3 directive" do
-      subject { described_class.new("test", source: "backup { s3 :primary, path: 'bucket/path' }") }
-
-      it "returns a BackupConfig with s3 destination" do
-        backup = subject.backup
-        expect(backup).to be_a(Bard::BackupConfig)
-        expect(backup.bard?).to eq false
-        expect(backup.destinations.length).to eq 1
-        expect(backup.self_managed?).to eq true
-
-        dest = backup.destinations.first
-        expect(dest[:name]).to eq :primary
-        expect(dest[:type]).to eq :s3
-        expect(dest[:path]).to eq 'bucket/path'
-      end
-    end
-
-    describe "#backup with both bard and s3 directives" do
-      subject { described_class.new("test", source: "backup { bard; s3 :custom, path: 'bucket/path' }") }
-
-      it "returns a BackupConfig with bard and s3 destination" do
-        backup = subject.backup
-        expect(backup).to be_a(Bard::BackupConfig)
-        expect(backup.bard?).to eq true
-        expect(backup.destinations.length).to eq 1
-        expect(backup.self_managed?).to eq true
-      end
-    end
-
-    describe "#backup with multiple s3 destinations" do
-      subject do
-        described_class.new("test", source: <<~SOURCE)
-          backup do
-            s3 :primary, path: 'bucket1/path'
-            s3 :secondary, path: 'bucket2/path'
-          end
-        SOURCE
+  context "with remove_target" do
+    subject { described_class.new("tracker", source: <<~SOURCE) }
+      remove_target :staging
+      target :staging do
+        ssh "deploy@new-host.com"
       end
+    SOURCE
 
-      it "returns a BackupConfig with multiple destinations" do
-        backup = subject.backup
-        expect(backup).to be_a(Bard::BackupConfig)
-        expect(backup.bard?).to eq false
-        expect(backup.destinations.length).to eq 2
-        expect(backup.self_managed?).to eq true
-
-        expect(backup.destinations[0][:name]).to eq :primary
-        expect(backup.destinations[1][:name]).to eq :secondary
-      end
+    it "replaces the default with a fresh target" do
+      staging = subject[:staging]
+      expect(staging).to be_a(Bard::Target)
+      expect(staging.ssh.to_s).to eq "deploy@new-host.com"
+      expect(staging.url).to eq "https://new-host.com"
     end
   end
 
   context "with github_pages directive" do
     subject { described_class.new("test", source: "github_pages 'example.com'") }
 
-    describe "#backup" do
-      it "sets backup to false" do
-        expect(subject.backup).to be_disabled
-      end
-    end
-
-    describe "#server" do
-      it "creates a production server with github_pages enabled" do
+    describe "#target" do
+      it "creates a production target with github_pages enabled" do
         production = subject[:production]
         expect(production).not_to be_nil
         expect(production.github_pages).to eq "example.com"
-        expect(production.ssh).to eq false
+        expect(production.ssh).to be_nil
       end
     end
   end
 end
-

data/spec/bard/copy_spec.rb

@@ -2,32 +2,68 @@ require "spec_helper"
 require "bard/copy"
 
 describe Bard::Copy do
-  let(:production) { double("production", key: :production, scp_uri: "user@example.com:/path/to/file", rsync_uri: "user@example.com:/path/to/", gateway: nil, ssh_key: nil, path: "/path/to") }
-  let(:local) { double("local", key: :local) }
+  let(:local) { double("local", key: :local, has_capability?: false) }
+  let(:production) { double("production", key: :production, has_capability?: true) }
 
-  context ".file" do
-    it "should copy a file from a remote server to the local machine" do
-      expect(Bard::Command).to receive(:run!).with("scp   user@example.com:/path/to/file path/to/file", verbose: false)
-      Bard::Copy.file "path/to/file", from: production, to: local
+  around do |example|
+    original_handlers = Bard::Copy.instance_variable_get(:@handlers).dup
+    example.run
+    Bard::Copy.instance_variable_set(:@handlers, original_handlers)
+  end
+
+  describe "auto-registration" do
+    it "registers handlers via inherited hook" do
+      handler = Class.new(Bard::Copy) do
+        def self.can_handle?(from, to) = true
+        def file = "copied"
+      end
+
+      copy = handler.new("path", local, production, false)
+      expect(copy.file).to eq("copied")
     end
+  end
+
+  describe ".file" do
+    it "dispatches to the handler that can handle the pair" do
+      Class.new(Bard::Copy) do
+        def self.can_handle?(from, to) = true
+        def file = "file_copied"
+      end
 
-    it "should copy a file from the local machine to a remote server" do
-      expect(Bard::Command).to receive(:run!).with("scp   path/to/file user@example.com:/path/to/file", verbose: false)
-      Bard::Copy.file "path/to/file", from: local, to: production
+      expect(Bard::Copy.file("db/data.sql.gz", from: local, to: production)).to eq("file_copied")
     end
   end
 
-  context ".dir" do
-    it "should copy a directory from a remote server to the local machine" do
-      allow(production).to receive_message_chain("ssh_uri.port").and_return(22)
-      expect(Bard::Command).to receive(:run!).with("rsync -e'ssh  -p22' --delete --info=progress2 -az user@example.com:/path/to/ ./path/", verbose: false)
-      Bard::Copy.dir "path/to", from: production, to: local
+  describe ".dir" do
+    it "dispatches to the handler that can handle the pair" do
+      Class.new(Bard::Copy) do
+        def self.can_handle?(from, to) = true
+        def dir = "dir_copied"
+      end
+
+      expect(Bard::Copy.dir("storage/", from: local, to: production)).to eq("dir_copied")
     end
+  end
+
+  describe ".handler_for!" do
+    it "raises when no handler matches" do
+      expect {
+        Bard::Copy.file("file", from: local, to: local)
+      }.to raise_error(/No copy handler for local -> local/)
+    end
+  end
+
+  describe "#initialize" do
+    it "stores path, from, to, verbose" do
+      handler = Class.new(Bard::Copy) do
+        def self.can_handle?(from, to) = true
+      end
 
-    it "should copy a directory from the local machine to a remote server" do
-      allow(production).to receive_message_chain("ssh_uri.port").and_return(22)
-      expect(Bard::Command).to receive(:run!).with("rsync -e'ssh  -p22' --delete --info=progress2 -az ./path/to user@example.com:/path/to/", verbose: false)
-      Bard::Copy.dir "path/to", from: local, to: production
+      copy = handler.new("db/data.sql.gz", local, production, true)
+      expect(copy.path).to eq("db/data.sql.gz")
+      expect(copy.from).to eq(local)
+      expect(copy.to).to eq(production)
+      expect(copy.verbose).to eq(true)
     end
   end
 end

data/spec/bard/deploy_strategy/ssh_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
-require "bard/deploy_strategy"
-require "bard/deploy_strategy/ssh"
+require "bard/plugins/deploy/strategy"
+require "bard/plugins/deploy/ssh_strategy"
 
 describe Bard::DeployStrategy::SSH do
   let(:config) { double("config", project_name: "testapp") }
@@ -17,12 +17,12 @@ describe Bard::DeployStrategy::SSH do
       strategy_without_ssh = described_class.new(target_without_ssh)
 
       expect { strategy_without_ssh.deploy }
-        .to raise_error(/SSH not configured/)
+        .to raise_error(/ssh capability not configured/)
     end
 
     it "runs git pull on remote server" do
       expect(target).to receive(:run!)
-        .with(/git pull origin master/)
+        .with("git pull --ff-only origin master")
 
       allow(target).to receive(:run!).with(/bin\/setup/)
 
@@ -42,12 +42,69 @@ describe Bard::DeployStrategy::SSH do
       target.instance_variable_set(:@branch, "main")
 
       expect(target).to receive(:run!)
-        .with(/git pull origin main/)
+        .with("git pull --ff-only origin main")
 
       allow(target).to receive(:run!).with(/bin\/setup/)
 
       strategy.deploy
     end
+
+    context "with force: true" do
+      it "force-checks-out the given branch on the remote server" do
+        expect(target).to receive(:run!).with("git fetch origin feature-x").ordered
+        expect(target).to receive(:run!).with("git checkout -f origin/feature-x").ordered
+
+        allow(target).to receive(:run!).with(/bin\/setup/)
+
+        strategy.deploy(branch: "feature-x", force: true)
+      end
+    end
+
+    context "with clone" do
+      let(:local_target) { double("local") }
+
+      before do
+        allow(config).to receive(:[]).with(:local).and_return(local_target)
+        allow(Bard::Copy).to receive(:file)
+      end
+
+      it "clones the repository" do
+        expect(target).to receive(:run!)
+          .with("git clone git@github.com:botandrosedesign/testapp /app", home: true)
+        allow(target).to receive(:run!).with("bin/setup")
+        allow(target).to receive(:run!).with("bard setup")
+
+        strategy.deploy(clone: "testapp")
+      end
+
+      it "copies master key from local" do
+        allow(target).to receive(:run!).with(/git clone/, home: true)
+        expect(Bard::Copy).to receive(:file)
+          .with("config/master.key", from: local_target, to: target)
+        allow(target).to receive(:run!).with("bin/setup")
+        allow(target).to receive(:run!).with("bard setup")
+
+        strategy.deploy(clone: "testapp")
+      end
+
+      it "runs bin/setup and bard setup" do
+        allow(target).to receive(:run!).with(/git clone/, home: true)
+        expect(target).to receive(:run!).with("bin/setup")
+        expect(target).to receive(:run!).with("bard setup")
+
+        strategy.deploy(clone: "testapp")
+      end
+
+      it "does not run git pull" do
+        allow(target).to receive(:run!).with(/git clone/, home: true)
+        allow(target).to receive(:run!).with("bin/setup")
+        allow(target).to receive(:run!).with("bard setup")
+
+        expect(target).not_to receive(:run!).with(/git pull/)
+
+        strategy.deploy(clone: "testapp")
+      end
+    end
   end
 
   describe "auto-registration" do
@@ -57,11 +114,12 @@ describe Bard::DeployStrategy::SSH do
   end
 
   describe "integration with target" do
-    it "is enabled by ssh DSL method" do
+    it "is the default strategy when SSH is configured" do
+      require "bard/plugins/deploy"
       new_target = Bard::Target.new(:staging, config)
       new_target.ssh("deploy@staging.example.com:22")
 
-      expect(new_target.deploy_strategy).to eq(:ssh)
+      expect(new_target.deploy_strategy_instance).to be_a(described_class)
     end
   end
 end

data/spec/bard/deploy_strategy_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "bard/deploy_strategy"
+require "bard/plugins/deploy/strategy"
 
 describe Bard::DeployStrategy do
   describe "auto-registration" do