bard 1.7.3 → 2.0.0.beta

data/spec/bard/dynamic_dsl_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+require "bard/target"
+require "bard/deploy_strategy"
+
+describe "Dynamic DSL 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
+  end
+
+  describe "#deploy_strategy_instance" do
+    it "creates an instance of the strategy class" do
+      target.jets("https://api.example.com")
+      instance = target.deploy_strategy_instance
+      expect(instance).to be_a(Bard::DeployStrategy::Jets)
+      expect(instance.target).to eq(target)
+    end
+
+    it "raises error if no strategy configured" do
+      expect { target.deploy_strategy_instance }
+        .to raise_error(/No deployment strategy configured/)
+    end
+
+    it "raises error if strategy class not found" do
+      target.instance_variable_set(:@deploy_strategy, :unknown)
+      expect { target.deploy_strategy_instance }
+        .to raise_error(/Unknown deployment strategy: unknown/)
+    end
+  end
+end

data/spec/bard/github_pages_spec.rb

@@ -38,6 +38,69 @@ describe Bard::GithubPages do
     end
   end
 
+  describe "#build_site" do
+    it "uses the locked port" do
+      github_pages.instance_variable_set(:@sha, "abc123")
+      github_pages.instance_variable_set(:@build_dir, "tmp/github-build-abc123")
+      github_pages.instance_variable_set(:@domain, "example.com")
+
+      allow(github_pages).to receive(:with_locked_port).and_yield(3005)
+
+      expect(github_pages).to receive(:run!).with(satisfy { |cmd|
+        cmd.include?("rails s -p 3005") && cmd.include?("http://localhost:3005")
+      }).ordered
+
+      expect(github_pages).to receive(:run!).with(include("kill")).ordered
+
+      github_pages.send(:build_site)
+    end
+  end
+
+  describe "#with_locked_port" do
+    let(:file_mock) { double("file", close: true) }
+
+    before do
+      allow(File).to receive(:open).and_return(file_mock)
+    end
+
+    it "yields the first available port" do
+      allow(file_mock).to receive(:flock).and_return(true)
+      
+      expect(File).to receive(:open).with("/tmp/bard_github_pages_3000.lock", anything, anything)
+      
+      yielded_port = nil
+      github_pages.send(:with_locked_port) { |p| yielded_port = p }
+      expect(yielded_port).to eq(3000)
+    end
+
+    it "retries if the first port is locked" do
+      # 1. Try port 3000
+      expect(File).to receive(:open).with("/tmp/bard_github_pages_3000.lock", anything, anything).ordered
+      expect(file_mock).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(false).ordered
+      expect(file_mock).to receive(:close).ordered
+
+      # 2. Try port 3001
+      expect(File).to receive(:open).with("/tmp/bard_github_pages_3001.lock", anything, anything).ordered
+      expect(file_mock).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(true).ordered
+      
+      # 3. Cleanup after yielding
+      expect(file_mock).to receive(:flock).with(File::LOCK_UN).ordered
+      expect(file_mock).to receive(:close).ordered
+
+      yielded_port = nil
+      github_pages.send(:with_locked_port) { |p| yielded_port = p }
+      expect(yielded_port).to eq(3001)
+    end
+
+    it "raises an error if no ports are available" do
+      allow(file_mock).to receive(:flock).and_return(false)
+      
+      expect {
+        github_pages.send(:with_locked_port) {}
+      }.to raise_error(/Could not find an available port/)
+    end
+  end
+
   describe "#get_parent_commit" do
     it "returns the sha of the gh-pages branch" do
       github_pages.instance_variable_set(:@branch, "gh-pages")
@@ -77,4 +140,4 @@ describe Bard::GithubPages do
       end
     end
   end
-end
+end

data/spec/bard/ssh_server_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+require "bard/ssh_server"
+
+describe Bard::SSHServer do
+  describe "#initialize" do
+    it "parses SSH URI with user, host, and port" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.user).to eq("deploy")
+      expect(server.host).to eq("example.com")
+      expect(server.port).to eq("22")
+    end
+
+    it "handles SSH URI without port (defaults to 22)" do
+      server = described_class.new("deploy@example.com")
+      expect(server.user).to eq("deploy")
+      expect(server.host).to eq("example.com")
+      expect(server.port).to eq("22")
+    end
+
+    it "handles SSH URI without user (uses current user)" do
+      server = described_class.new("example.com:22")
+      expect(server.host).to eq("example.com")
+      expect(server.port).to eq("22")
+      expect(server.user).to eq(ENV['USER'])
+    end
+
+    it "accepts options hash" do
+      server = described_class.new("deploy@example.com:22",
+        path: "/app",
+        gateway: "bastion@example.com:22",
+        ssh_key: "/path/to/key",
+        env: "RAILS_ENV=production"
+      )
+
+      expect(server.path).to eq("/app")
+      expect(server.gateway).to eq("bastion@example.com:22")
+      expect(server.ssh_key).to eq("/path/to/key")
+      expect(server.env).to eq("RAILS_ENV=production")
+    end
+  end
+
+  describe "#ssh_uri" do
+    it "returns the SSH connection string" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.ssh_uri).to eq("deploy@example.com: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")
+    end
+  end
+
+  describe "#hostname" do
+    it "extracts hostname from SSH URI" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.hostname).to eq("example.com")
+    end
+
+    it "handles IP addresses" do
+      server = described_class.new("deploy@192.168.1.1:22")
+      expect(server.hostname).to eq("192.168.1.1")
+    end
+  end
+
+  describe "#connection_string" do
+    it "builds SSH connection string" do
+      server = described_class.new("deploy@example.com:22")
+      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

@@ -0,0 +1,239 @@
+require "spec_helper"
+require "bard/target"
+
+describe Bard::Target do
+  let(:config) { double("config", project_name: "testapp") }
+  let(:target) { described_class.new(:production, config) }
+
+  describe "#initialize" do
+    it "stores the target key" do
+      expect(target.key).to eq(:production)
+    end
+
+    it "stores the config" do
+      expect(target.config).to eq(config)
+    end
+
+    it "initializes with no capabilities" do
+      expect(target.has_capability?(:ssh)).to be false
+      expect(target.has_capability?(:ping)).to be false
+    end
+
+    it "initializes with no deploy strategy" do
+      expect(target.deploy_strategy).to be_nil
+    end
+  end
+
+  describe "#ssh" do
+    context "with simple SSH configuration" do
+      before { target.ssh("deploy@example.com:22") }
+
+      it "enables SSH capability" do
+        expect(target.has_capability?(:ssh)).to be true
+      end
+
+      it "creates SSHServer instance" do
+        expect(target.server).to be_a(Bard::SSHServer)
+      end
+
+      it "parses SSH URI" do
+        expect(target.ssh_uri).to eq("deploy@example.com:22")
+      end
+    end
+
+    context "with hash options" do
+      before do
+        target.ssh("deploy@example.com:22",
+          path: "/var/www/app",
+          gateway: "bastion@example.com:22",
+          ssh_key: "/path/to/key",
+          env: "RAILS_ENV=production"
+        )
+      end
+
+      it "enables SSH capability" do
+        expect(target.has_capability?(:ssh)).to be true
+      end
+
+      it "stores path" do
+        expect(target.path).to eq("/var/www/app")
+      end
+
+      it "stores gateway" do
+        expect(target.gateway).to eq("bastion@example.com:22")
+      end
+
+      it "stores SSH key" do
+        expect(target.ssh_key).to eq("/path/to/key")
+      end
+
+      it "stores environment variables" do
+        expect(target.env).to eq("RAILS_ENV=production")
+      end
+
+      it "auto-configures ping URL from hostname" do
+        expect(target.ping_urls).to include("example.com")
+      end
+    end
+
+    context "with false value" do
+      before { target.ssh(false) }
+
+      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
+      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")
+    end
+
+    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")
+    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
+    end
+  end
+
+  describe "#path" do
+    it "stores and retrieves path" do
+      target.path("/var/www/app")
+      expect(target.path).to eq("/var/www/app")
+    end
+
+    it "can be set via ssh options" do
+      target.ssh("deploy@example.com:22", path: "/app")
+      expect(target.path).to eq("/app")
+    end
+  end
+
+  describe "remote command execution" do
+    before do
+      target.ssh("deploy@example.com:22", path: "/app")
+    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" do
+        expect(Bard::Command).to receive(:run!)
+          .with("ls", on: target.server, home: false, 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
+        expect(Bard::Command).to receive(:run)
+          .with("ls", on: target.server, home: false, 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
+        expect(Bard::Command).to receive(:exec!)
+          .with("ls", on: target.server, home: false)
+        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")
+    end
+  end
+
+  describe "#to_sym" do
+    it "returns the target key as symbol" do
+      expect(target.to_sym).to eq(:production)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bard
 version: !ruby/object:Gem::Version
-  version: 1.7.3
+  version: 2.0.0.beta
 platform: ruby
 authors:
 - Micah Geisel
 bindir: bin
 cert_chain: []
-date: 2025-12-15 00:00:00.000000000 Z
+date: 2025-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -160,8 +160,12 @@ files:
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
+- ARCHITECTURE.md
+- CUSTOM_STRATEGIES.md
 - Gemfile
 - LICENSE
+- MIGRATION_GUIDE.md
+- README.md
 - README.rdoc
 - Rakefile
 - bard.gemspec
@@ -219,6 +223,10 @@ files:
 - lib/bard/command.rb
 - lib/bard/config.rb
 - lib/bard/copy.rb
+- lib/bard/default_config.rb
+- lib/bard/deploy_strategy.rb
+- lib/bard/deploy_strategy/github_pages.rb
+- lib/bard/deploy_strategy/ssh.rb
 - lib/bard/git.rb
 - lib/bard/github.rb
 - lib/bard/github_pages.rb
@@ -240,11 +248,14 @@ files:
 - lib/bard/provision/swapfile.rb
 - lib/bard/provision/user.rb
 - lib/bard/server.rb
+- lib/bard/ssh_server.rb
+- lib/bard/target.rb
 - lib/bard/version.rb
 - spec/acceptance/.gitignore
 - spec/acceptance/docker/Dockerfile
 - spec/acceptance/docker/test_key
 - spec/acceptance/docker/test_key.pub
+- spec/bard/capability_spec.rb
 - spec/bard/ci/github_actions_spec.rb
 - spec/bard/ci_spec.rb
 - spec/bard/cli/ci_spec.rb
@@ -266,6 +277,9 @@ files:
 - spec/bard/command_spec.rb
 - spec/bard/config_spec.rb
 - spec/bard/copy_spec.rb
+- spec/bard/deploy_strategy/ssh_spec.rb
+- spec/bard/deploy_strategy_spec.rb
+- spec/bard/dynamic_dsl_spec.rb
 - spec/bard/git_spec.rb
 - spec/bard/github_pages_spec.rb
 - spec/bard/github_spec.rb
@@ -287,6 +301,8 @@ files:
 - spec/bard/provision/user_spec.rb
 - spec/bard/provision_spec.rb
 - spec/bard/server_spec.rb
+- spec/bard/ssh_server_spec.rb
+- spec/bard/target_spec.rb
 - spec/bard_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixtures/job.json
@@ -332,6 +348,7 @@ test_files:
 - spec/acceptance/docker/Dockerfile
 - spec/acceptance/docker/test_key
 - spec/acceptance/docker/test_key.pub
+- spec/bard/capability_spec.rb
 - spec/bard/ci/github_actions_spec.rb
 - spec/bard/ci_spec.rb
 - spec/bard/cli/ci_spec.rb
@@ -353,6 +370,9 @@ test_files:
 - spec/bard/command_spec.rb
 - spec/bard/config_spec.rb
 - spec/bard/copy_spec.rb
+- spec/bard/deploy_strategy/ssh_spec.rb
+- spec/bard/deploy_strategy_spec.rb
+- spec/bard/dynamic_dsl_spec.rb
 - spec/bard/git_spec.rb
 - spec/bard/github_pages_spec.rb
 - spec/bard/github_spec.rb
@@ -374,6 +394,8 @@ test_files:
 - spec/bard/provision/user_spec.rb
 - spec/bard/provision_spec.rb
 - spec/bard/server_spec.rb
+- spec/bard/ssh_server_spec.rb
+- spec/bard/target_spec.rb
 - spec/bard_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixtures/job.json