bard 1.9.6 → 2.0.0

data/spec/bard/dynamic_dsl_spec.rb

@@ -1,118 +1,31 @@
 require "spec_helper"
 require "bard/target"
-require "bard/deploy_strategy"
+require "bard/plugins/deploy"
 
-describe "Dynamic DSL Methods" do
+describe "Deploy strategy target methods" do
   let(:config) { double("config", project_name: "testapp") }
   let(:target) { Bard::Target.new(:production, config) }
 
-  before do
-    # Register test strategies
-    class Bard::DeployStrategy::Jets < Bard::DeployStrategy
-      def deploy
-        # test implementation
-      end
-    end
-
-    class Bard::DeployStrategy::Docker < Bard::DeployStrategy
-      def deploy
-        # test implementation
-      end
-    end
-  end
-
-  describe "method_missing for strategies" do
-    it "enables strategy when method name matches registered strategy" do
-      target.jets("https://api.example.com")
-      expect(target.deploy_strategy).to eq(:jets)
-    end
-
-    it "stores strategy options" do
-      target.jets("https://api.example.com", run_tests: true, env: "production")
-      options = target.strategy_options(:jets)
-      expect(options[:run_tests]).to be true
-      expect(options[:env]).to eq("production")
-    end
-
-    it "auto-configures ping URL from first argument if it's a URL" do
-      target.jets("https://api.example.com")
-      expect(target.ping_urls).to include("https://api.example.com")
-    end
-
-    it "works with multiple strategies" do
-      target1 = Bard::Target.new(:production, config)
-      target2 = Bard::Target.new(:staging, config)
-
-      target1.jets("https://api.example.com")
-      target2.docker("https://app.example.com")
-
-      expect(target1.deploy_strategy).to eq(:jets)
-      expect(target2.deploy_strategy).to eq(:docker)
-    end
-
-    it "raises NoMethodError for unknown methods" do
-      expect { target.unknown_method("arg") }
-        .to raise_error(NoMethodError)
-    end
-  end
-
-  describe "strategy DSL integration" do
-    it "allows chaining with other configuration methods" do
-      target.jets("https://api.example.com", run_tests: true)
-      target.ssh("deploy@example.com:22", path: "app")
-
-      expect(target.deploy_strategy).to eq(:jets)
-      expect(target.has_capability?(:ssh)).to be true
-    end
-
-    it "allows strategy configuration without ping URL" do
-      target.docker(skip_build: true)
-      options = target.strategy_options(:docker)
-      expect(options[:skip_build]).to be true
-    end
-  end
-
-  describe "#strategy_options" do
-    it "returns options for the specified strategy" do
-      target.jets("https://api.example.com", run_tests: true, env: "prod")
-      options = target.strategy_options(:jets)
-      expect(options[:run_tests]).to be true
-      expect(options[:env]).to eq("prod")
-    end
-
-    it "returns empty hash if strategy not configured" do
-      options = target.strategy_options(:unknown)
-      expect(options).to eq({})
-    end
-
-    it "filters out URL from options" do
-      target.jets("https://api.example.com", run_tests: true)
-      options = target.strategy_options(:jets)
-      expect(options[:run_tests]).to be true
-      expect(options).not_to have_key(:url)
-    end
-  end
-
   describe "#deploy_strategy" do
-    it "returns the configured strategy symbol" do
-      target.jets("https://api.example.com")
-      expect(target.deploy_strategy).to eq(:jets)
-    end
-
     it "returns nil if no strategy configured" do
       expect(target.deploy_strategy).to be_nil
     end
+
+    it "returns :ssh after ssh is configured via deploy_strategy_instance" do
+      target.ssh("deploy@example.com:22")
+      expect(target.deploy_strategy_instance).to be_a(Bard::DeployStrategy::SSH)
+    end
   end
 
   describe "#deploy_strategy_instance" do
-    it "creates an instance of the strategy class" do
-      target.jets("https://api.example.com")
+    it "defaults to SSH strategy when SSH capability is present" do
+      target.ssh("deploy@example.com:22")
       instance = target.deploy_strategy_instance
-      expect(instance).to be_a(Bard::DeployStrategy::Jets)
+      expect(instance).to be_a(Bard::DeployStrategy::SSH)
       expect(instance.target).to eq(target)
     end
 
-    it "raises error if no strategy configured" do
+    it "raises error if no strategy configured and no SSH capability" do
       expect { target.deploy_strategy_instance }
         .to raise_error(/No deployment strategy configured/)
     end
@@ -123,4 +36,11 @@ describe "Dynamic DSL Methods" do
         .to raise_error(/Unknown deployment strategy: unknown/)
     end
   end
+
+  describe "#strategy_options" do
+    it "returns empty hash if strategy not configured" do
+      options = target.strategy_options(:unknown)
+      expect(options).to eq({})
+    end
+  end
 end

data/spec/bard/git_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "bard/git"
+require "bard/plugins/git"
 
 describe Bard::Git do
   describe ".current_branch" do
@@ -46,14 +46,18 @@ describe Bard::Git do
 
   describe ".sha_of" do
     it "should return the sha of a ref" do
-      allow(Bard::Git).to receive(:`).with("git rev-parse ref 2>/dev/null").and_return("sha\n")
-      allow(Bard::Git).to receive(:command_succeeded?).and_return(true)
+      allow(Bard::Git).to receive(:`).with("git rev-parse ref 2>/dev/null") {
+        `true` # sets $? to success
+        "sha\n"
+      }
       expect(Bard::Git.sha_of("ref")).to eq("sha")
     end
 
     it "should return nil if the ref does not exist" do
-      allow(Bard::Git).to receive(:`).with("git rev-parse ref 2>/dev/null").and_return("ref: fatal: ambiguous argument 'ref': unknown revision or path not in the working tree.\n")
-      allow(Bard::Git).to receive(:command_succeeded?).and_return(false)
+      allow(Bard::Git).to receive(:`).with("git rev-parse ref 2>/dev/null") {
+        `false` # sets $? to failure
+        "ref: fatal: ambiguous argument 'ref': unknown revision or path not in the working tree.\n"
+      }
       expect(Bard::Git.sha_of("ref")).to be_nil
     end
   end

data/spec/bard/github_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "bard/github"
+require "bard/plugins/github"
 
 describe Bard::Github do
   let(:github) { Bard::Github.new("test-project") }

data/spec/bard/ping_spec.rb

@@ -1,9 +1,9 @@
 require "spec_helper"
-require "bard/ping"
+require "bard/plugins/ping/check"
 
 describe Bard::Ping do
-  let(:server) { double("server", ping: ["http://example.com"]) }
-  let(:ping) { described_class.new(server) }
+  let(:target) { double("target", ping: ["http://example.com"]) }
+  let(:ping) { described_class.new(target) }
 
   def success_response
     Net::HTTPSuccess.new(1.0, "200", "OK")
@@ -13,14 +13,14 @@ describe Bard::Ping do
     Net::HTTPNotFound.new(1.0, "404", "Not Found")
   end
 
-  context "when the server is reachable" do
+  context "when the target is reachable" do
     it "returns an empty array" do
       allow(ping).to receive(:http_get).and_return(success_response)
       expect(ping.call).to be_empty
     end
   end
 
-  context "when the server is not reachable" do
+  context "when the target is not reachable" do
     it "returns the url" do
       allow(ping).to receive(:http_get).and_return(not_found_response)
       expect(ping.call).to eq(["http://example.com"])

data/spec/bard/ssh_copy_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "bard/plugins/ssh/copy"
+
+describe Bard::SSH::Copy do
+  let(:ssh_server) { double("ssh_server", gateway: nil, ssh_key: nil, port: "22", ssh_uri: double(port: 22, user: "user", host: "example.com")) }
+  let(:production) { double("production", key: :production, server: ssh_server, scp_uri: "user@example.com:/path/to/file", rsync_uri: "user@example.com:/path/to/", path: "/path/to", has_capability?: true) }
+  let(:local) { double("local", key: :local, has_capability?: false) }
+
+  describe ".can_handle?" do
+    it "handles pairs where at least one target has ssh capability" do
+      expect(Bard::SSH::Copy.can_handle?(local, production)).to be true
+      expect(Bard::SSH::Copy.can_handle?(production, local)).to be true
+      expect(Bard::SSH::Copy.can_handle?(production, production)).to be true
+    end
+
+    it "does not handle pairs where neither target has ssh capability" do
+      expect(Bard::SSH::Copy.can_handle?(local, local)).to be false
+    end
+  end
+
+  context ".file via Bard::Copy dispatch" do
+    it "should copy a file from a remote server to the local machine" do
+      expect(Bard::Command).to receive(:run!).with("scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR user@example.com:/path/to/file path/to/file", verbose: false)
+      Bard::Copy.file "path/to/file", from: production, to: local
+    end
+
+    it "should copy a file from the local machine to a remote server" do
+      expect(Bard::Command).to receive(:run!).with("scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR path/to/file user@example.com:/path/to/file", verbose: false)
+      Bard::Copy.file "path/to/file", from: local, to: production
+    end
+  end
+
+  context ".dir via Bard::Copy dispatch" do
+    it "should copy a directory from a remote server to the local machine" do
+      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
+    end
+
+    it "should copy a directory from the local machine to a remote server" do
+      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
+    end
+  end
+end

data/spec/bard/ssh_server_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "bard/ssh_server"
+require "bard/plugins/ssh/server"
 
 describe Bard::SSHServer do
   describe "#initialize" do
@@ -73,101 +73,4 @@ describe Bard::SSHServer do
       expect(server.connection_string).to eq("deploy@example.com")
     end
   end
-
-  describe "#run" do
-    let(:server) do
-      described_class.new("deploy@example.com:22", path: "/app")
-    end
-
-    it "executes command via SSH" do
-      expect(Open3).to receive(:capture3)
-        .with(/ssh.*deploy@example.com.*cd.+\/app.+ls/)
-        .and_return(["output", "", 0])
-
-      server.run("ls")
-    end
-
-    it "includes environment variables if configured" do
-      server_with_env = described_class.new("deploy@example.com:22",
-        path: "/app",
-        env: "RAILS_ENV=production"
-      )
-
-      expect(Open3).to receive(:capture3)
-        .with(/RAILS_ENV.*production/)
-        .and_return(["output", "", 0])
-
-      server_with_env.run("ls")
-    end
-  end
-
-  describe "#run!" do
-    let(:server) do
-      described_class.new("deploy@example.com:22", path: "/app")
-    end
-
-    it "executes command via SSH" do
-      expect(Open3).to receive(:capture3)
-        .with(/ssh.*deploy@example.com.*cd.+\/app.+ls/)
-        .and_return(["output", "", 0])
-
-      server.run!("ls")
-    end
-
-    it "raises error if command fails" do
-      expect(Open3).to receive(:capture3)
-        .and_return(["", "error", 1])
-
-      expect { server.run!("false") }.to raise_error(Bard::Command::Error)
-    end
-  end
-
-  describe "#exec!" do
-    let(:server) do
-      described_class.new("deploy@example.com:22", path: "/app")
-    end
-
-    it "replaces current process with SSH command" do
-      expect(server).to receive(:exec)
-        .with(/ssh.*deploy@example.com.*cd.+\/app.+ls/)
-
-      server.exec!("ls")
-    end
-  end
-
-  describe "path handling" do
-    it "uses path in commands if configured" do
-      server = described_class.new("deploy@example.com:22", path: "/var/www/app")
-
-      expect(Open3).to receive(:capture3)
-        .with(/cd.+\/var\/www\/app.+ls/)
-        .and_return(["output", "", 0])
-
-      server.run("ls")
-    end
-
-    it "works without path" do
-      server = described_class.new("deploy@example.com:22")
-
-      expect(Open3).to receive(:capture3)
-        .with(/ssh.*ls/)
-        .and_return(["output", "", 0])
-
-      server.run("ls")
-    end
-  end
-
-  describe "gateway/bastion support" do
-    it "uses ProxyJump for gateway" do
-      server = described_class.new("deploy@private.example.com:22",
-        gateway: "bastion@public.example.com:22"
-      )
-
-      expect(Open3).to receive(:capture3)
-        .with(/-o ProxyJump=bastion@public.example.com:22/)
-        .and_return(["output", "", 0])
-
-      server.run("ls")
-    end
-  end
 end

data/spec/bard/target_spec.rb

@@ -1,5 +1,9 @@
 require "spec_helper"
+require "shellwords"
 require "bard/target"
+require "bard/plugins/url/target_methods"
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/ping/target_methods"
 
 describe Bard::Target do
   let(:config) { double("config", project_name: "testapp") }
@@ -16,12 +20,9 @@ describe Bard::Target do
 
     it "initializes with no capabilities" do
       expect(target.has_capability?(:ssh)).to be false
-      expect(target.has_capability?(:ping)).to be false
+      expect(target.has_capability?(:url)).to be false
     end
 
-    it "initializes with no deploy strategy" do
-      expect(target.deploy_strategy).to be_nil
-    end
   end
 
   describe "#ssh" do
@@ -75,50 +76,67 @@ describe Bard::Target do
         expect(target.env).to eq("RAILS_ENV=production")
       end
 
-      it "auto-configures ping URL from hostname" do
-        expect(target.ping_urls).to include("https://example.com")
+      it "auto-configures url from hostname" do
+        expect(target.url).to eq("https://example.com")
       end
     end
 
-    context "with false value" do
-      before { target.ssh(false) }
-
+    context "without ssh configured" do
       it "does not enable SSH capability" do
         expect(target.has_capability?(:ssh)).to be false
       end
 
-      it "sets server to nil" do
-        expect(target.server).to be_nil
+      it "returns nil from ssh getter" do
+        expect(target.ssh).to be_nil
       end
     end
   end
 
-  describe "#ping" do
-    it "enables ping capability with single URL" do
-      target.ping("https://example.com")
-      expect(target.has_capability?(:ping)).to be true
-      expect(target.ping_urls).to include("https://example.com")
+  describe "#url" do
+    it "enables url capability" do
+      target.url("https://example.com")
+      expect(target.has_capability?(:url)).to be true
+      expect(target.url).to eq("https://example.com")
+    end
+
+    it "normalizes URLs without scheme" do
+      target.url("example.com")
+      expect(target.url).to eq("https://example.com")
     end
 
+    it "disables url with false" do
+      target.url("https://example.com")
+      target.url(false)
+      expect(target.has_capability?(:url)).to be false
+      expect(target.url).to be_nil
+    end
+  end
+
+  describe "#ping" do
     it "accepts multiple URLs" do
-      target.ping("https://example.com", "/health", "/status")
-      expect(target.ping_urls).to include("https://example.com")
-      expect(target.ping_urls).to include("/health")
-      expect(target.ping_urls).to include("/status")
+      target.ping("https://example.com", "https://example.com/health")
+      expect(target.ping).to eq(["https://example.com", "https://example.com/health"])
+    end
+
+    it "defaults to url when not explicitly set" do
+      target.url("https://example.com")
+      expect(target.ping).to eq(["https://example.com"])
+    end
+
+    it "returns empty array when no url or ping configured" do
+      expect(target.ping).to eq([])
     end
 
     it "disables ping with false" do
       target.ping("https://example.com")
       target.ping(false)
-      expect(target.has_capability?(:ping)).to be false
-      expect(target.ping_urls).to be_empty
+      expect(target.ping).to be_empty
     end
   end
 
   describe "#path" do
-    it "stores and retrieves path" do
-      target.path("/var/www/app")
-      expect(target.path).to eq("/var/www/app")
+    it "defaults to project name" do
+      expect(target.path).to eq("testapp")
     end
 
     it "can be set via ssh options" do
@@ -127,108 +145,43 @@ describe Bard::Target do
     end
   end
 
-  describe "remote command execution" do
-    before do
-      target.ssh("deploy@example.com:22", path: "/app")
+  describe "command execution" do
+    describe "local (base)" do
+      it "runs commands locally" do
+        expect(Bard::Command).to receive(:run!)
+          .with("ls", verbose: false, quiet: false)
+        target.run!("ls")
+      end
     end
 
-    describe "#run!" do
-      it "requires SSH capability" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { target_without_ssh.run!("ls") }
-          .to raise_error(/SSH not configured/)
+    describe "remote (SSH)" do
+      before do
+        target.ssh("deploy@example.com:22", path: "/app")
       end
 
-      it "executes command on remote server" do
+      it "runs commands on remote server" do
+        expected_cmd = "ssh -tt -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR deploy@example.com #{Shellwords.shellescape("cd /app && ls")}"
         expect(Bard::Command).to receive(:run!)
-          .with("ls", on: target, home: false, verbose: false, quiet: false)
+          .with(expected_cmd, verbose: false, quiet: false)
         target.run!("ls")
       end
-    end
-
-    describe "#run" do
-      it "requires SSH capability" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { target_without_ssh.run("ls") }
-          .to raise_error(/SSH not configured/)
-      end
 
-      it "executes command on remote server without raising" do
+      it "runs commands without raising on remote server" do
+        expected_cmd = "ssh -tt -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR deploy@example.com #{Shellwords.shellescape("cd /app && ls")}"
         expect(Bard::Command).to receive(:run)
-          .with("ls", on: target, home: false, verbose: false, quiet: false)
+          .with(expected_cmd, verbose: false, quiet: false)
         target.run("ls")
       end
-    end
-
-    describe "#exec!" do
-      it "requires SSH capability" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { target_without_ssh.exec!("ls") }
-          .to raise_error(/SSH not configured/)
-      end
 
       it "replaces process with remote command" do
+        expected_cmd = "ssh -tt -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR deploy@example.com #{Shellwords.shellescape("cd /app && ls")}"
         expect(Bard::Command).to receive(:exec!)
-          .with("ls", on: target, home: false)
+          .with(expected_cmd)
         target.exec!("ls")
       end
     end
   end
 
-  describe "file transfer" do
-    let(:source_target) do
-      t = described_class.new(:source, config)
-      t.ssh("source@example.com:22", path: "/source")
-      t
-    end
-
-    let(:dest_target) do
-      t = described_class.new(:dest, config)
-      t.ssh("dest@example.com:22", path: "/dest")
-      t
-    end
-
-    describe "#copy_file" do
-      it "requires SSH capability on source" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { target_without_ssh.copy_file("test.txt", to: dest_target) }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "requires SSH capability on destination" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { source_target.copy_file("test.txt", to: target_without_ssh) }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "copies file via SCP" do
-        expect(Bard::Copy).to receive(:file)
-          .with("test.txt", from: source_target, to: dest_target, verbose: false)
-        source_target.copy_file("test.txt", to: dest_target)
-      end
-    end
-
-    describe "#copy_dir" do
-      it "requires SSH capability on source" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { target_without_ssh.copy_dir("test/", to: dest_target) }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "requires SSH capability on destination" do
-        target_without_ssh = described_class.new(:local, config)
-        expect { source_target.copy_dir("test/", to: target_without_ssh) }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "syncs directory via rsync" do
-        expect(Bard::Copy).to receive(:dir)
-          .with("test/", from: source_target, to: dest_target, verbose: false)
-        source_target.copy_dir("test/", to: dest_target)
-      end
-    end
-  end
-
   describe "#to_s" do
     it "returns the target key as string" do
       expect(target.to_s).to eq("production")