bard 2.0.0.beta → 2.0.1

data/spec/bard/cli/ping_spec.rb

@@ -1,37 +1,22 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/ping"
 require "thor"
 
-class TestPingCLI < Thor
-  include Bard::CLI::Ping
-
-  attr_reader :config
-
-  def initialize
-    super
-    @config = {}
-  end
-end
-
-describe Bard::CLI::Ping do
-  let(:server) { double("server", ping: ["https://example.com"]) }
-  let(:config) { { production: server } }
-  let(:cli) { TestPingCLI.new }
+describe "bard ping" do
+  let(:target) { double("target", ping: ["https://example.com"]) }
+  let(:config) { double("config", targets: { production: target }) }
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:config).and_return(config)
+    allow(config).to receive(:[]).with(:production).and_return(target)
     allow(cli).to receive(:puts)
     allow(cli).to receive(:exit)
   end
 
   describe "#ping" do
-    it "should have a ping command" do
-      expect(cli).to respond_to(:ping)
-    end
-
-    it "should call Bard::Ping with the server" do
-      expect(Bard::Ping).to receive(:call).and_return([])
+    it "should call Bard::Ping with the target" do
+      expect(Bard::Ping).to receive(:call).with(target).and_return([])
 
       cli.ping
     end
@@ -44,4 +29,4 @@ describe Bard::CLI::Ping do
       cli.ping
     end
   end
-end
+end

data/spec/bard/cli/run_spec.rb

@@ -1,23 +1,10 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/run"
-require "thor"
 
-class TestRunCLI < Thor
-  include Bard::CLI::Run
-
-  attr_reader :config
-
-  def initialize
-    super
-    @config = {}
-  end
-end
-
-describe Bard::CLI::Run do
-  let(:server) { double("server") }
-  let(:config) { { production: server } }
-  let(:cli) { TestRunCLI.new }
+describe "bard run" do
+  let(:target) { double("target") }
+  let(:config) { { production: target } }
+  let(:cli) { Bard::CLI.new }
 
   before do
     allow(cli).to receive(:config).and_return(config)
@@ -25,6 +12,7 @@ describe Bard::CLI::Run do
     allow(cli).to receive(:exit)
     allow(cli).to receive(:red).and_return("")
     allow(cli).to receive(:yellow).and_return("")
+    allow(cli).to receive(:options).and_return({ target: "production" })
   end
 
   describe "#run" do
@@ -32,15 +20,33 @@ describe Bard::CLI::Run do
       expect(cli).to respond_to(:run)
     end
 
-    it "should run command on production server" do
-      expect(server).to receive(:run!).with("ls -la", verbose: true)
+    it "should run command on production target" do
+      expect(target).to receive(:run!).with("ls -la", verbose: true, home: nil)
+
+      cli.run("ls", "-la")
+    end
+
+    it "should run command on specified target" do
+      staging_server = double("staging_target")
+      allow(cli).to receive(:config).and_return(config.merge(staging: staging_server))
+      allow(cli).to receive(:options).and_return({ target: "staging" })
+
+      expect(staging_server).to receive(:run!).with("ls -la", verbose: true, home: nil)
+
+      cli.run("ls", "-la")
+    end
+
+    it "should pass home option to target" do
+      allow(cli).to receive(:options).and_return({ target: "production", home: true })
+
+      expect(target).to receive(:run!).with("ls -la", verbose: true, home: true)
 
       cli.run("ls", "-la")
     end
 
     it "should handle command errors" do
       error = Bard::Command::Error.new("Command failed")
-      allow(server).to receive(:run!).and_raise(error)
+      allow(target).to receive(:run!).and_raise(error)
 
       expect(cli).to receive(:puts).with(/Running command failed/)
       expect(cli).to receive(:exit).with(1)
@@ -48,4 +54,4 @@ describe Bard::CLI::Run do
       cli.run("failing-command")
     end
   end
-end
+end

data/spec/bard/cli/setup_spec.rb

@@ -1,27 +1,11 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/setup"
-require "thor"
 
-class TestSetupCLI < Thor
-  include Bard::CLI::Setup
-
-  attr_reader :config
-
-  def initialize
-    super
-    @config = {}
-  end
-
-  def project_name
-    "test_project"
-  end
-end
-
-describe Bard::CLI::Setup do
-  let(:cli) { TestSetupCLI.new }
+describe "bard setup" do
+  let(:cli) { Bard::CLI.new }
 
   before do
+    allow(cli).to receive(:project_name).and_return("test_project")
     allow(Dir).to receive(:pwd).and_return("/home/user/project")
     allow(File).to receive(:exist?).and_return(false)
     allow(cli).to receive(:system)
@@ -32,9 +16,8 @@ describe Bard::CLI::Setup do
       expect(cli).to respond_to(:setup)
     end
 
-    it "should create nginx common config" do
-      expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/snippets\/common\.conf/)
-      expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/sites-available\/test_project/)
+    it "should create nginx reverse proxy config" do
+      expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/sites-available\/test_project.*proxy_pass http:\/\/puma/m)
       expect(cli).to receive(:system).with(/sudo ln -sf/)
       expect(cli).to receive(:system).with("sudo service nginx restart")
 
@@ -43,7 +26,7 @@ describe Bard::CLI::Setup do
   end
 
   describe "#nginx_server_name" do
-    let(:production_server) { double("production", ping: ["https://example.com"]) }
+    let(:production_server) { double("production", url: "https://example.com") }
 
     before do
       allow(cli).to receive(:config).and_return({ production: production_server })
@@ -53,7 +36,7 @@ describe Bard::CLI::Setup do
       before { allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("production") }
 
       it "returns production server names with wildcard" do
-        expect(cli.send(:nginx_server_name)).to eq("*.example.com _")
+        expect(cli.nginx_server_name).to eq("*.example.com _")
       end
     end
 
@@ -61,7 +44,7 @@ describe Bard::CLI::Setup do
       before { allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("staging") }
 
       it "returns staging server name" do
-        expect(cli.send(:nginx_server_name)).to eq("test_project.botandrose.com")
+        expect(cli.nginx_server_name).to eq("test_project.botandrose.com")
       end
     end
 
@@ -69,8 +52,8 @@ describe Bard::CLI::Setup do
       before { allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("development") }
 
       it "returns localhost server name" do
-        expect(cli.send(:nginx_server_name)).to eq("test_project.localhost")
+        expect(cli.nginx_server_name).to eq("test_project.localhost")
       end
     end
   end
-end
+end

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
-