bard 2.0.0.beta → 2.0.1

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

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,11 +1,11 @@
 require "spec_helper"
-require "bard/github"
+require "bard/plugins/github"
 
 describe Bard::Github do
   let(:github) { Bard::Github.new("test-project") }
 
   before do
-    allow(github).to receive(:`).with("git ls-remote -t git@github.com:botandrosedesign/secrets").and_return("github-apikey|12345")
+    allow(Bard::Secrets).to receive(:fetch).with("github-apikey").and_return("12345")
   end
 
   describe "#get" do

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
@@ -40,14 +40,18 @@ describe Bard::SSHServer do
   end
 
   describe "#ssh_uri" do
-    it "returns the SSH connection string" do
+    it "returns a URI object" do
       server = described_class.new("deploy@example.com:22")
-      expect(server.ssh_uri).to eq("deploy@example.com:22")
+      expect(server.ssh_uri).to be_a(URI::Generic)
+      expect(server.ssh_uri.scheme).to eq("ssh")
+      expect(server.ssh_uri.user).to eq("deploy")
+      expect(server.ssh_uri.host).to eq("example.com")
+      expect(server.ssh_uri.port).to eq(22)
     end
 
     it "includes port if non-standard" do
       server = described_class.new("deploy@example.com:2222")
-      expect(server.ssh_uri).to eq("deploy@example.com:2222")
+      expect(server.ssh_uri.port).to eq(2222)
     end
   end
 
@@ -69,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