bard 2.2.0 → 3.0.0

data/spec/bard/cli/stage_spec.rb

@@ -1,127 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-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)
-    allow(cli).to receive(:puts)
-    allow(cli).to receive(:exit)
-    allow(cli).to receive(:run!)
-    allow(cli).to receive(:ping)
-    allow(cli).to receive(:green).and_return("")
-    allow(cli).to receive(:red).and_return("")
-    allow(cli).to receive(:yellow) { |s| s }
-    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)
-    allow(cli).to receive(:project_name).and_return("acme")
-    allow(cli).to receive(:staging_provisioned?).and_return(true)
-  end
-
-  describe "#stage" do
-    it "should have a stage command" do
-      expect(cli).to respond_to(:stage)
-    end
-
-    context "when the staging site has been reaped" do
-      before do
-        allow(cli).to receive(:staging_provisioned?).and_return(false)
-        allow(cli).to receive(:invoke)
-        allow($stdin).to receive(:tty?).and_return(false)
-      end
-
-      it "provisions from scratch by cloning and checking out the branch" do
-        expect(staging_strategy).to receive(:deploy).with(clone: "acme", branch: "main")
-        cli.stage
-      end
-
-      it "restores data from production by default (Enter/no decline)" do
-        allow(staging_strategy).to receive(:deploy)
-        allow($stdin).to receive(:tty?).and_return(true)
-        allow(cli).to receive(:no?).and_return(false)
-        expect(cli).to receive(:invoke).with(:data, [], from: "production", to: "staging")
-        cli.stage
-      end
-
-      it "skips the restore when the user declines" do
-        allow(staging_strategy).to receive(:deploy)
-        allow($stdin).to receive(:tty?).and_return(true)
-        allow(cli).to receive(:no?).and_return(true)
-        expect(cli).not_to receive(:invoke)
-        cli.stage
-      end
-
-      it "prints restore instructions when non-interactive" do
-        allow(staging_strategy).to receive(:deploy)
-        expect(cli).to receive(:puts).with(/bard data --from production --to staging/)
-        cli.stage
-      end
-    end
-
-    context "when the staging site already exists" do
-      it "does not prompt to restore data" do
-        allow($stdin).to receive(:tty?).and_return(true)
-        expect(cli).not_to receive(:invoke)
-        cli.stage
-      end
-    end
-
-    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_strategy).to receive(:deploy)
-        expect(cli).to receive(:ping).with(:staging)
-
-        cli.stage
-      end
-
-      it "accepts custom branch" do
-        expect(cli).to receive(:run!).with("git push -u origin develop", verbose: true)
-        expect(staging_strategy).to receive(:deploy)
-
-        cli.stage("develop")
-      end
-    end
-
-    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/)
-      end
-    end
-
-    context "when command fails" do
-      it "handles errors gracefully" do
-        allow(cli).to receive(:run!).and_raise(Bard::Command::Error.new("Git push failed"))
-
-        expect(cli).to receive(:puts).with(/Running command failed/)
-        expect(cli).to receive(:exit).with(1)
-
-        cli.stage
-      end
-    end
-  end
-end

data/spec/bard/cli/vim_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard vim" do
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:exec)
-  end
-
-  describe "#vim" do
-    it "should have a vim command" do
-      expect(cli).to respond_to(:vim)
-    end
-
-    it "should exec vim with git diff files by default" do
-      expect(cli).to receive(:exec).with("vim -p `(git diff master --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`")
-
-      cli.vim
-    end
-
-    it "should exec vim with specified branch" do
-      expect(cli).to receive(:exec).with("vim -p `(git diff develop --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`")
-
-      cli.vim("develop")
-    end
-  end
-end

data/spec/bard/command_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-require "bard/command"
-
-describe Bard::Command do
-  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
-  end
-
-  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 raise an error if the command fails" do
-      expect(Open3).to receive(:capture3).with("ls -l").and_return(["output", "error", 1])
-      expect { Bard::Command.run! "ls -l" }.to raise_error(Bard::Command::Error)
-    end
-  end
-
-  describe ".exec!" do
-    it "should exec a command locally" do
-      expect(Kernel).to receive(:exec).with("ls -l")
-      Bard::Command.exec! "ls -l"
-    end
-  end
-end

data/spec/bard/copy_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-require "bard/copy"
-
-describe Bard::Copy do
-  let(:local) { double("local", key: :local, has_capability?: false) }
-  let(:production) { double("production", key: :production, has_capability?: true) }
-
-  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
-
-      expect(Bard::Copy.file("db/data.sql.gz", from: local, to: production)).to eq("file_copied")
-    end
-  end
-
-  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
-
-      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/github_pages_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-require "bard/plugins/github_pages/strategy"
-require "bard/plugins/github_pages"
-
-describe Bard::DeployStrategy::GithubPages do
-  let(:config) { double("config", project_name: "testapp") }
-
-  def build_shell_for(target)
-    strategy = described_class.new(target)
-    strategy.instance_variable_set(:@sha, "abc123")
-    strategy.instance_variable_set(:@build_dir, "tmp/github-build-abc123")
-    strategy.instance_variable_set(:@port, 4321)
-    strategy.instance_variable_set(:@domain, strategy.send(:extract_domain))
-
-    captured = []
-    allow(strategy).to receive(:run!) { |cmd| captured << cmd }
-    allow(strategy).to receive(:system)
-    strategy.send(:build_site)
-    captured.join("\n")
-  end
-
-  context "with no custom domain (project page under /<repo>/)" do
-    let(:target) do
-      Bard::Target.new(:production, config).tap { |t| t.github_pages(nil) }
-    end
-
-    it "mirrors with --convert-links so the tree is relocatable under the subpath" do
-      expect(build_shell_for(target)).to match(/wget .*\s-k\s/)
-    end
-
-    it "strips the localhost prefix wget bakes into un-crawled links" do
-      expect(build_shell_for(target))
-        .to include(%(sed -i "s#http://localhost:$PORT/#/#g"))
-    end
-
-    it "does not write a CNAME" do
-      expect(build_shell_for(target)).not_to match(/> CNAME/)
-    end
-  end
-
-  context "with a custom domain (served at the domain root)" do
-    let(:target) do
-      Bard::Target.new(:production, config).tap { |t| t.github_pages("example.com") }
-    end
-
-    it "does not add --convert-links" do
-      expect(build_shell_for(target)).not_to match(/wget .*\s-k\s/)
-    end
-
-    it "does not run the localhost strip" do
-      expect(build_shell_for(target)).not_to include("localhost:$PORT/#")
-    end
-
-    it "writes the CNAME" do
-      expect(build_shell_for(target)).to match(/echo example\.com > CNAME/)
-    end
-  end
-end

data/spec/bard/deploy_strategy/ssh_spec.rb

@@ -1,135 +0,0 @@
-require "spec_helper"
-require "bard/plugins/deploy/strategy"
-require "bard/plugins/deploy/ssh_strategy"
-
-describe Bard::DeployStrategy::SSH do
-  let(:config) { double("config", project_name: "testapp") }
-  let(:target) do
-    t = Bard::Target.new(:production, config)
-    t.ssh("deploy@example.com:22", path: "/app")
-    t
-  end
-  let(:strategy) { described_class.new(target) }
-
-  describe "#deploy" do
-    it "requires SSH capability" do
-      target_without_ssh = Bard::Target.new(:local, config)
-      strategy_without_ssh = described_class.new(target_without_ssh)
-
-      expect { strategy_without_ssh.deploy }
-        .to raise_error(/ssh capability not configured/)
-    end
-
-    it "runs git pull on remote server" do
-      expect(target).to receive(:run!)
-        .with("git pull --ff-only origin master")
-
-      allow(target).to receive(:run!).with(/bin\/setup/)
-
-      strategy.deploy
-    end
-
-    it "runs bin/setup on remote server" do
-      allow(target).to receive(:run!).with(/git pull/)
-
-      expect(target).to receive(:run!)
-        .with(/bin\/setup/)
-
-      strategy.deploy
-    end
-
-    it "pulls the given branch when one is specified" do
-      expect(target).to receive(:run!)
-        .with("git pull --ff-only origin main")
-
-      allow(target).to receive(:run!).with(/bin\/setup/)
-
-      strategy.deploy(branch: "main")
-    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, defaulting to master" do
-        expect(target).to receive(:run!)
-          .with("git clone --branch master 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
-
-      it "clones the requested branch directly when provisioning from scratch" do
-        allow(target).to receive(:run!).with("bin/setup")
-        allow(target).to receive(:run!).with("bard setup")
-
-        expect(target).to receive(:run!)
-          .with("git clone --branch feature-x git@github.com:botandrosedesign/testapp /app", home: true)
-        expect(target).not_to receive(:run!).with(/git fetch/)
-        expect(target).not_to receive(:run!).with(/git checkout/)
-
-        strategy.deploy(clone: "testapp", branch: "feature-x")
-      end
-    end
-  end
-
-  describe "auto-registration" do
-    it "registers as :ssh strategy" do
-      expect(Bard::DeployStrategy[:ssh]).to eq(described_class)
-    end
-  end
-
-  describe "integration with target" 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_instance).to be_a(described_class)
-    end
-  end
-end

data/spec/bard/deploy_strategy_spec.rb

@@ -1,107 +0,0 @@
-require "spec_helper"
-require "bard/plugins/deploy/strategy"
-
-describe Bard::DeployStrategy do
-  describe "auto-registration" do
-    it "registers strategies via inherited hook" do
-      # Define a test strategy
-      class Bard::DeployStrategy::TestStrategy < Bard::DeployStrategy
-      end
-
-      expect(Bard::DeployStrategy[:test_strategy]).to eq(Bard::DeployStrategy::TestStrategy)
-    end
-
-    it "extracts strategy name from class name" do
-      class Bard::DeployStrategy::MyCustomStrategy < Bard::DeployStrategy
-      end
-
-      expect(Bard::DeployStrategy[:my_custom_strategy]).to eq(Bard::DeployStrategy::MyCustomStrategy)
-    end
-
-
-    it "allows retrieval of registered strategies" do
-      class Bard::DeployStrategy::RetrievalTest < Bard::DeployStrategy
-      end
-
-      strategy_class = Bard::DeployStrategy[:retrieval_test]
-      expect(strategy_class).to eq(Bard::DeployStrategy::RetrievalTest)
-      expect(strategy_class.superclass).to eq(Bard::DeployStrategy)
-    end
-  end
-
-  describe ".strategies" do
-    it "returns a hash of all registered strategies" do
-      class Bard::DeployStrategy::Strategy1 < Bard::DeployStrategy
-      end
-      class Bard::DeployStrategy::Strategy2 < Bard::DeployStrategy
-      end
-
-      strategies = Bard::DeployStrategy.strategies
-      expect(strategies).to be_a(Hash)
-      expect(strategies[:strategy1]).to eq(Bard::DeployStrategy::Strategy1)
-      expect(strategies[:strategy2]).to eq(Bard::DeployStrategy::Strategy2)
-    end
-  end
-
-  describe ".[]" do
-    it "retrieves a strategy by symbol" do
-      class Bard::DeployStrategy::LookupTest < Bard::DeployStrategy
-      end
-
-      expect(Bard::DeployStrategy[:lookup_test]).to eq(Bard::DeployStrategy::LookupTest)
-    end
-
-    it "returns nil for unknown strategies" do
-      expect(Bard::DeployStrategy[:unknown_strategy]).to be_nil
-    end
-  end
-
-  describe "#initialize" do
-    let(:target) { double("target") }
-
-    it "stores the target" do
-      strategy = described_class.new(target)
-      expect(strategy.target).to eq(target)
-    end
-  end
-
-  describe "#deploy" do
-    let(:target) { double("target") }
-    let(:strategy) { described_class.new(target) }
-
-    it "raises NotImplementedError" do
-      expect { strategy.deploy }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe "helper methods" do
-    let(:target) { double("target") }
-    let(:strategy) { described_class.new(target) }
-
-    describe "#run!" do
-      it "delegates to Bard::Command.run!" do
-        expect(Bard::Command).to receive(:run!).with("ls -l")
-        strategy.run!("ls -l")
-      end
-    end
-
-    describe "#run" do
-      it "delegates to Bard::Command.run" do
-        expect(Bard::Command).to receive(:run).with("ls -l")
-        strategy.run("ls -l")
-      end
-    end
-
-    describe "#system!" do
-      it "delegates to Kernel.system with error checking" do
-        expect(Kernel).to receive(:system).with("ls -l").and_return(true)
-        strategy.system!("ls -l")
-      end
-
-      it "raises error if command fails" do
-        expect(Kernel).to receive(:system).with("false").and_return(false)
-        expect { strategy.system!("false") }.to raise_error(/Command failed/)
-      end
-    end
-  end
-end

data/spec/bard/dynamic_dsl_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-require "bard/target"
-require "bard/plugins/deploy"
-
-describe "Deploy strategy target methods" do
-  let(:config) { double("config", project_name: "testapp") }
-  let(:target) { Bard::Target.new(:production, config) }
-
-  describe "#deploy_strategy" do
-    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 "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::SSH)
-      expect(instance.target).to eq(target)
-    end
-
-    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
-
-    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
-
-  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