bard 1.4.8 → 1.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3203ba9146ef6ed6b43512e6e61d02c0f34769703a20bc7809316fedee18dbd2
-  data.tar.gz: b8a8d8aa3ebd8163cb6679fecde47e6a9e961456ec3fc661f904775b36bb4283
+  metadata.gz: d7758630b558e557b178b1d598cec7ef6c5bd3d56769673372f4133ffc488451
+  data.tar.gz: 86df74f01dab9bdb30690340571d10b2bd51bbff3d70f1aeca4385d399542d76
 SHA512:
-  metadata.gz: 36f776bfba32128c5584fd91bea060fb57423e648de3590c68a4be0dca835a553be992b3629704640d1530f94d6b25420302efe030de13f0fb8da1c1ea3394a5
-  data.tar.gz: 591b17f6e3ac45fef9b579056777a6d33756cfb1ced970e75251856d782daddbe3e24786b744931b69275828b64e9ecb95d3f940a3edfe65d769f8a230581b2a
+  metadata.gz: bd955ce3572ec9c071f775ea15c78ce004ef0db2125105e0d72678057b65475d534cc21e408ca0900ef57735c13f30a7d1755714bc4dd0019469f73f66ed04c2
+  data.tar.gz: e6b64d2cef83b325161b5f7b5f990b400a245f7b5103f7539d3a500150f7c2ab863557350954213fec8f382aa7908142f19fb98df0304a921f486be77470187d

data/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ "3.2", "3.3", "3.4" ]
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rake

data/Gemfile

@@ -3,3 +3,7 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in bard.gemspec
 gemspec
 
+group :test do
+  gem "simplecov", require: false
+  gem "webmock", require: false
+end

data/bard.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rvm"
   spec.add_dependency "term-ansicolor", ">= 1.0.3"
   spec.add_dependency "rbnacl"
+  spec.add_dependency "base64"
 
-  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "debug"
 end

data/lib/bard/git.rb

@@ -21,9 +21,13 @@ module Bard
 
     def sha_of ref
       sha = `git rev-parse #{ref} 2>/dev/null`.chomp
-      return sha if $?.success?
+      return sha if command_succeeded?
       nil # Branch doesn't exist
     end
+
+    def command_succeeded?
+      $?.success?
+    end
   end
 end
 

data/lib/bard/provision/repo.rb

@@ -20,6 +20,11 @@ class Bard::Provision::Repo < Bard::Provision
       end
       print " Cloning repo,"
       provision_server.run! "git clone git@github.com:botandrosedesign/#{project_name}", home: true
+    else
+      if !on_latest_master?
+        print " Updating to latest master,"
+        update_to_latest_master!
+      end
     end
 
     puts " ✓"
@@ -47,5 +52,21 @@ class Bard::Provision::Repo < Bard::Provision
   def project_name
     server.project_name
   end
+
+  def on_latest_master?
+    provision_server.run [
+      "cd ~/#{project_name}",
+      "git fetch origin",
+      "[ $(git rev-parse HEAD) = $(git rev-parse origin/master) ]"
+    ].join(" && "), home: true, quiet: true
+  end
+
+  def update_to_latest_master!
+    provision_server.run! [
+      "cd ~/#{project_name}",
+      "git checkout master",
+      "git reset --hard origin/master"
+    ].join(" && "), home: true
+  end
 end
 

data/lib/bard/provision/ssh.rb

@@ -5,6 +5,11 @@ class Bard::Provision::SSH < Bard::Provision
   def call
     print "SSH:"
 
+    if password_auth_enabled?
+      print " Disabling password authentication,"
+      disable_password_auth!
+    end
+
     if !ssh_available?(provision_server.ssh_uri, port: target_port)
       if !ssh_available?(provision_server.ssh_uri)
         raise "can't find SSH on port #{target_port} or #{provision_server.ssh_uri.port || 22}"
@@ -48,4 +53,20 @@ class Bard::Provision::SSH < Bard::Provision
     port ||= ssh_uri.port || 22
     system "ssh-keyscan -p#{port} -H #{ssh_uri.host} >> ~/.ssh/known_hosts 2>/dev/null"
   end
+
+  def password_auth_enabled?
+    result = provision_server.run!(
+      %q{grep -E '^\s*PasswordAuthentication\s+yes' /etc/ssh/sshd_config /etc/ssh/sshd_config.d/*.conf 2>/dev/null || true},
+      home: true,
+      capture: true
+    )
+    !!(result && !result.strip.empty?)
+  end
+
+  def disable_password_auth!
+    provision_server.run!(
+      %q{echo "PasswordAuthentication no" | sudo tee /etc/ssh/sshd_config.d/disable_password_auth.conf; sudo service ssh restart},
+      home: true
+    )
+  end
 end

data/lib/bard/server.rb

@@ -73,8 +73,8 @@ module Bard
 
     def rsync_uri file_path=nil
       str = ssh_uri.dup.tap do |uri|
-        uri.scheme = nil
-        uri.port = nil
+        uri.send :set_scheme, nil
+        uri.send :set_port, nil
       end.to_s[2..]
       str += ":#{path}"
       str += "/#{file_path}" if file_path

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.4.8"
+  VERSION = "1.4.9"
 end
 

data/spec/bard/cli/ci_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/ci"
+require "thor"
+
+class TestCICLI < Thor
+  include Bard::CLI::CI
+
+  attr_reader :options
+
+  def initialize
+    super
+    @options = {}
+  end
+
+  def project_name
+    "test_project"
+  end
+end
+
+describe Bard::CLI::CI do
+  let(:cli) { TestCICLI.new }
+  let(:ci_runner) { double("ci_runner") }
+
+  before do
+    allow(cli).to receive(:puts)
+    allow(cli).to receive(:print)
+    allow(cli).to receive(:exit)
+    allow(cli).to receive(:red).and_return("")
+    allow($stdout).to receive(:flush)
+    allow(Bard::Git).to receive(:current_branch).and_return("feature-branch")
+    allow(Bard::CI).to receive(:new).and_return(ci_runner)
+  end
+
+  describe "#ci" do
+    it "should have a ci command" do
+      expect(cli).to respond_to(:ci)
+    end
+
+    context "when CI exists and status option is set" do
+      it "prints CI status and returns early" do
+        allow(cli).to receive(:options).and_return({ "status" => true })
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:status).and_return("Build #123: SUCCESS")
+
+        expect(cli).to receive(:puts).with("Build #123: SUCCESS")
+        expect(ci_runner).not_to receive(:run)
+
+        cli.ci
+      end
+    end
+
+    context "when CI exists and running normally" do
+      before do
+        allow(cli).to receive(:options).and_return({})
+        allow(ci_runner).to receive(:exists?).and_return(true)
+      end
+
+      it "starts CI build and handles success" do
+        allow(ci_runner).to receive(:run).and_yield(30, 60).and_return(true)
+
+        expect(cli).to receive(:puts).with("Continuous integration: starting build on feature-branch...")
+        expect(cli).to receive(:puts).with("Continuous integration: success!")
+        expect(cli).to receive(:puts).with("Deploying...")
+
+        cli.ci
+      end
+
+      it "handles CI failure" do
+        allow(ci_runner).to receive(:run).and_yield(30, 60).and_return(false)
+        allow(ci_runner).to receive(:console).and_return("Test failed: spec/model_spec.rb")
+
+        expect(cli).to receive(:puts).with("Continuous integration: starting build on feature-branch...")
+        expect(cli).to receive(:puts).with("Test failed: spec/model_spec.rb")
+        expect(cli).to receive(:puts) # The puts with newline
+        expect(cli).to receive(:puts) # The "Automated tests failed!" message
+        expect(cli).to receive(:exit).with(1)
+
+        cli.ci
+      end
+
+      it "displays progress with estimated completion time" do
+        allow(ci_runner).to receive(:run).and_yield(30, 60).and_return(true)
+
+        expect(cli).to receive(:print).with("\x08" * "  Estimated completion: 50%".length)
+        expect(cli).to receive(:print).with("  Estimated completion: 50%")
+
+        cli.ci
+      end
+
+      it "displays progress without estimated completion time" do
+        allow(ci_runner).to receive(:run).and_yield(45, nil).and_return(true)
+
+        expect(cli).to receive(:print).with("\x08" * "  No estimated completion time. Elapsed time: 45 sec".length)
+        expect(cli).to receive(:print).with("  No estimated completion time. Elapsed time: 45 sec")
+
+        cli.ci
+      end
+    end
+
+    context "when CI doesn't exist" do
+      it "shows error message and exits" do
+        allow(cli).to receive(:options).and_return({})
+        allow(ci_runner).to receive(:exists?).and_return(false)
+
+        expect(cli).to receive(:puts) # "No CI found for test_project!"
+        expect(cli).to receive(:puts) # "Re-run with --skip-ci to bypass CI..."
+        expect(cli).to receive(:exit).with(1)
+
+        cli.ci
+      end
+    end
+
+    context "with custom branch" do
+      it "uses the specified branch" do
+        allow(cli).to receive(:options).and_return({})
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:run).and_return(true)
+
+        expect(Bard::CI).to receive(:new).with("test_project", "develop", local: nil)
+        expect(cli).to receive(:puts).with("Continuous integration: starting build on develop...")
+
+        cli.ci("develop")
+      end
+    end
+
+    context "with local-ci option" do
+      it "passes local option to CI runner" do
+        allow(cli).to receive(:options).and_return({ "local-ci" => true })
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:run).and_return(true)
+
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", local: true)
+
+        cli.ci
+      end
+    end
+  end
+end

data/spec/bard/cli/command_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/command"
+
+class TestCommand < Bard::CLI::Command
+  desc "test_command", "test command description"
+  option :verbose, type: :boolean
+
+  def test_command
+    "executed"
+  end
+end
+
+describe Bard::CLI::Command do
+  let(:cli_mock) { double("cli") }
+  let(:command) { TestCommand.new(cli_mock) }
+
+  describe ".desc" do
+    it "sets command and description" do
+      expect(TestCommand.instance_variable_get(:@command)).to eq("test_command")
+      expect(TestCommand.instance_variable_get(:@description)).to eq("test command description")
+    end
+  end
+
+  describe ".option" do
+    it "sets option arguments" do
+      expect(TestCommand.instance_variable_get(:@option_args)).to eq([:verbose])
+      expect(TestCommand.instance_variable_get(:@option_kwargs)).to eq({type: :boolean})
+    end
+  end
+
+  describe ".setup" do
+    let(:cli_double) { double("cli") }
+
+    it "sets up the command on the CLI class" do
+      expect(cli_double).to receive(:desc).with("test_command", "test command description")
+      expect(cli_double).to receive(:option).with(:verbose, type: :boolean)
+      expect(cli_double).to receive(:define_method)
+
+      TestCommand.setup(cli_double)
+    end
+  end
+
+  describe "delegation" do
+    it "should delegate to the wrapped object" do
+      allow(cli_mock).to receive(:some_method).and_return("delegated")
+      expect(command.some_method).to eq("delegated")
+    end
+  end
+end

data/spec/bard/cli/data_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/data"
+
+require "thor"
+
+require "term/ansicolor"
+
+class TestCLI < Thor
+  include Bard::CLI::Data
+  include Term::ANSIColor
+
+  attr_reader :config
+
+  def initialize
+    @config = {}
+  end
+
+  def options
+    {}
+  end
+end
+
+describe Bard::CLI::Data do
+  let(:cli) { TestCLI.new }
+
+  it "should have a data command" do
+    expect(cli).to respond_to(:data)
+  end
+
+  context "data" do
+    let(:from) { double("from", key: :production, run!: nil, copy_file: nil, copy_dir: nil) }
+    let(:to) { double("to", key: :local, run!: nil) }
+
+    let(:config) do
+      double("config", data: [], :[] => nil).tap do |config|
+        allow(config).to receive(:[]).with("production").and_return(from)
+        allow(config).to receive(:[]).with("local").and_return(to)
+      end
+    end
+
+    before do
+      allow(cli).to receive(:config).and_return(config)
+      allow(cli).to receive(:options).and_return({from: "production", to: "local"})
+    end
+
+    it "should run the data command" do
+      expect(from).to receive(:run!).with("bin/rake db:dump")
+      expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+      expect(to).to receive(:run!).with("bin/rake db:load")
+      cli.data
+    end
+
+    context "pushing to production" do
+      let(:to) { double("to", key: :production, ping: ["https://example.com"]) }
+
+      before do
+        allow(cli).to receive(:options).and_return({from: "local", to: "production"})
+        allow(config).to receive(:[]).with("production").and_return(to)
+        allow(config).to receive(:[]).with("local").and_return(from)
+      end
+
+      it "should prevent pushing to production if the user does not confirm" do
+        expect(cli).to receive(:ask).and_return("no")
+        expect { cli.data }.to raise_error(SystemExit)
+      end
+
+      it "should allow pushing to production if the user confirms" do
+        expect(cli).to receive(:ask).and_return("https://example.com")
+        expect(from).to receive(:run!).with("bin/rake db:dump")
+        expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+        expect(to).to receive(:run!).with("bin/rake db:load")
+        cli.data
+      end
+    end
+  end
+end

data/spec/bard/cli/deploy_spec.rb

@@ -0,0 +1,202 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/deploy"
+require "thor"
+
+class TestDeployCLI < Thor
+  include Bard::CLI::Deploy
+
+  attr_reader :config, :options
+
+  def initialize
+    super
+    @config = {}
+    @options = {}
+  end
+
+  def project_name
+    "test_project"
+  end
+end
+
+describe Bard::CLI::Deploy do
+  let(:production_server) { double("production", run!: true, github_pages: false, path: "/var/www/test_project") }
+  let(:config) { { production: production_server } }
+  let(:cli) { TestDeployCLI.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(:invoke)
+    allow(cli).to receive(:ping)
+    allow(cli).to receive(:green).and_return("")
+    allow(cli).to receive(:red).and_return("")
+    allow(cli).to receive(:yellow).and_return("")
+    allow(Bard::Git).to receive(:current_branch).and_return("feature-branch")
+    allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(true)
+    allow(Bard::Git).to receive(:fast_forward_merge?).and_return(true)
+    allow(cli).to receive(:`).and_return("")
+  end
+
+  describe "#deploy" do
+    it "should have a deploy command" do
+      expect(cli).to respond_to(:deploy)
+    end
+
+    context "when on master branch" do
+      before do
+        allow(Bard::Git).to receive(:current_branch).and_return("master")
+        allow(cli).to receive(:options).and_return({})
+      end
+
+      context "when up to date with remote" do
+        it "skips push and runs CI then deploys" do
+          allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(true)
+
+          expect(cli).not_to receive(:run!).with(/git push/)
+          expect(cli).to receive(:invoke).with(:ci, ["master"], {})
+          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+          expect(cli).to receive(:puts) # "Deploy Succeeded"
+          expect(cli).to receive(:ping).with(:production)
+
+          cli.deploy
+        end
+      end
+
+      context "when not up to date with remote" do
+        it "pushes master then runs CI and deploys" do
+          allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(false)
+
+          expect(cli).to receive(:run!).with("git push origin master:master")
+          expect(cli).to receive(:invoke).with(:ci, ["master"], {})
+          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+
+          cli.deploy
+        end
+      end
+
+      context "with skip-ci option" do
+        it "skips CI step" do
+          allow(cli).to receive(:options).and_return({ "skip-ci" => true })
+
+          expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
+          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+
+          cli.deploy
+        end
+      end
+    end
+
+    context "when on feature branch" do
+      before do
+        allow(cli).to receive(:options).and_return({})
+      end
+
+      context "with fast-forward merge possible" do
+        it "fetches master, pushes branch, runs CI, merges to master, and deploys" do
+          expect(cli).to receive(:run!).with("git fetch origin master:master")
+          expect(cli).to receive(:run!).with("git push -f origin feature-branch:feature-branch")
+          expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], {})
+          expect(cli).to receive(:run!).with("git push origin feature-branch:master")
+          expect(cli).to receive(:run!).with("git fetch origin master:master")
+          expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
+
+          cli.deploy
+        end
+
+        it "deletes the feature branch after successful deploy" do
+          expect(cli).to receive(:puts).with("Deleting branch: feature-branch")
+          expect(cli).to receive(:run!).with("git push --delete origin feature-branch")
+          expect(cli).to receive(:run!).with("git checkout master")
+          expect(cli).to receive(:run!).with("git branch -D feature-branch")
+
+          cli.deploy
+        end
+      end
+
+      context "when rebase is needed" do
+        it "attempts rebase before proceeding" do
+          allow(Bard::Git).to receive(:fast_forward_merge?).and_return(false)
+
+          expect(cli).to receive(:puts).with("The master branch has advanced. Attempting rebase...")
+          expect(cli).to receive(:run!).with("git rebase origin/master")
+          expect(cli).to receive(:run!).with("git push -f origin feature-branch:feature-branch")
+
+          cli.deploy
+        end
+      end
+    end
+
+    context "with github remote" do
+      it "pushes to github remote" do
+        allow(cli).to receive(:`).with("git remote").and_return("origin\ngithub\n")
+
+        expect(cli).to receive(:run!).with("git push github")
+
+        cli.deploy
+      end
+    end
+
+    context "with clone option" do
+      it "clones repository and sets up application" do
+        allow(cli).to receive(:options).and_return({ clone: true })
+
+        expect(production_server).to receive(:run!).with("git clone git@github.com:botandrosedesign/test_project /var/www/test_project", home: true)
+        expect(cli).to receive(:invoke).with(:master_key, [], from: "local", to: :production)
+        expect(production_server).to receive(:run!).with("bin/setup && bard setup")
+
+        cli.deploy
+      end
+    end
+
+    context "with github pages" do
+      it "deploys to github pages" do
+        allow(production_server).to receive(:github_pages).and_return(true)
+        github_pages = double("github_pages")
+        allow(Bard::GithubPages).to receive(:new).and_return(github_pages)
+
+        expect(github_pages).to receive(:deploy).with(production_server)
+
+        cli.deploy
+      end
+    end
+
+    context "with custom deployment target" do
+      let(:staging_server) { double("staging", run!: true, github_pages: false) }
+
+      before do
+        allow(config).to receive(:[]).with(:staging).and_return(staging_server)
+      end
+
+      it "deploys to specified target" do
+        expect(staging_server).to receive(:run!).with("git pull origin master && bin/setup")
+        expect(cli).to receive(:ping).with(:staging)
+
+        cli.deploy(:staging)
+      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.deploy
+      end
+    end
+
+    context "with local-ci option" do
+      it "passes local-ci option to CI invocation" do
+        allow(cli).to receive(:options).and_return({ "local-ci" => true })
+
+        expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], { "local-ci" => true })
+
+        cli.deploy
+      end
+    end
+  end
+end

data/spec/bard/cli/hurt_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/hurt"
+require "thor"
+
+class TestHurtCLI < Thor
+  include Bard::CLI::Hurt
+end
+
+describe Bard::CLI::Hurt do
+  let(:cli) { TestHurtCLI.new }
+
+  before do
+    allow(cli).to receive(:puts)
+    allow(cli).to receive(:system)
+  end
+
+  describe "#hurt" do
+    it "should have a hurt command" do
+      expect(cli).to respond_to(:hurt)
+    end
+  end
+end

data/spec/bard/cli/install_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/install"
+require "thor"
+
+class TestInstallCLI < Thor
+  include Bard::CLI::Install
+end
+
+describe Bard::CLI::Install do
+  let(:cli) { TestInstallCLI.new }
+
+  describe "#install" do
+    it "should have an install command" do
+      expect(cli).to respond_to(:install)
+    end
+
+    it "should copy install files to bin directory" do
+      expect(cli).to receive(:system).with(/cp -R .*install_files\/\* bin\//)
+      expect(cli).to receive(:system).with(/cp -R .*install_files\/\.github \.\//)
+
+      cli.install
+    end
+  end
+end