bard 2.2.0 → 3.0.0

data/features/deploy_git_workflow.feature

@@ -1,89 +0,0 @@
-@server
-Feature: bard deploy git workflow
-  Git workflow behaviors during deploy.
-
-  Background:
-    Given a test server is running
-
-  Scenario: deploy on master pushes unpushed commits
-    Given I create a file "local-only.txt" with content "local commit"
-    And I commit the changes with message "Add local only file"
-    When I run: bard deploy --skip-ci
-    Then the output should contain "Deploy Succeeded"
-    When I run: bard run "cat local-only.txt"
-    Then the output should contain "local commit"
-
-  Scenario: feature branch fast-forward merge
-    Given I create and switch to branch "feature-branch"
-    And I create a file "feature.txt" with content "feature content"
-    And I commit the changes with message "Add feature"
-    When I run: bard deploy --skip-ci
-    Then the output should contain "Deploy Succeeded"
-    And I should be on branch "master"
-    And branch "feature-branch" should not exist locally
-    And branch "feature-branch" should not exist on origin
-    When I run: bard run "cat feature.txt"
-    Then the output should contain "feature content"
-
-  Scenario: feature branch requires rebase
-    Given I create and switch to branch "feature-branch"
-    And I create a file "feature.txt" with content "feature content"
-    And I commit the changes with message "Add feature"
-    And master has an additional commit from another source
-    When I run: bard deploy --skip-ci
-    Then the output should contain "The master branch has advanced"
-    And the output should contain "Attempting rebase"
-    And the output should contain "Deploy Succeeded"
-    And I should be on branch "master"
-    When I run: bard run "cat feature.txt"
-    Then the output should contain "feature content"
-    When I run: bard run "cat remote-change.txt"
-    Then the output should contain "remote change"
-
-  Scenario: feature branch rebase conflict
-    Given I create and switch to branch "feature-branch"
-    And I create a file "conflict.txt" with content "feature content"
-    And I commit the changes with message "Add conflicting file"
-    And master has a conflicting commit to "conflict.txt"
-    When I run expecting failure: bard deploy --skip-ci
-    Then the output should contain "The master branch has advanced"
-    And the output should contain "Attempting rebase"
-    And the output should contain "Running command failed"
-
-  Scenario: branch cleanup after deploy
-    Given I create and switch to branch "cleanup-test"
-    And I create a file "cleanup.txt" with content "cleanup test"
-    And I commit the changes with message "Add cleanup test file"
-    And I push branch "cleanup-test" to origin
-    When I run: bard deploy --skip-ci
-    Then the output should contain "Deleting branch: cleanup-test"
-    And the output should contain "Deploy Succeeded"
-    And I should be on branch "master"
-    And branch "cleanup-test" should not exist locally
-    And branch "cleanup-test" should not exist on origin
-
-  Scenario: deploy a branch without checking it out
-    Given I create and switch to branch "feature-branch"
-    And I create a file "feature.txt" with content "feature content"
-    And I commit the changes with message "Add feature"
-    And I switch to branch "master"
-    When I run: bard deploy feature-branch --skip-ci
-    Then the output should contain "Deploy Succeeded"
-    And I should be on branch "master"
-    And branch "feature-branch" should not exist locally
-    When I run: bard run "cat feature.txt"
-    Then the output should contain "feature content"
-
-  Scenario: deploy a branch that requires rebase without checking it out
-    Given I create and switch to branch "feature-branch"
-    And I create a file "feature.txt" with content "feature content"
-    And I commit the changes with message "Add feature"
-    And I switch to branch "master"
-    And master has an additional commit from another source
-    When I run: bard deploy feature-branch --skip-ci
-    Then the output should contain "The master branch has advanced"
-    And the output should contain "Attempting rebase"
-    And the output should contain "Deploy Succeeded"
-    And I should be on branch "master"
-    When I run: bard run "cat feature.txt"
-    Then the output should contain "feature content"

data/features/run.feature

@@ -1,14 +0,0 @@
-@server
-Feature: bard run
-  Execute commands on a remote server.
-
-  Background:
-    Given a test server is running
-
-  Scenario: executes a command on the remote server
-    When I run: bard run "echo hello"
-    Then the output should contain "hello"
-
-  Scenario: operates in the configured path
-    When I run: bard run "pwd"
-    Then the output should contain "testproject"

data/features/step_definitions/bard_steps.rb

@@ -1,136 +0,0 @@
-Given /^a test server is running$/ do
-  raise "Test server failed to start" unless @container && @ssh_port
-end
-
-When /^I run: bard (.+)$/ do |command|
-  run_bard(command)
-  unless @status.success?
-    raise "Command failed with status: #{@status}\nOutput: #{@stdout}"
-  end
-end
-
-When /^I run expecting failure: bard (.+)$/ do |command|
-  run_bard(command)
-  unless !@status.success?
-    raise "Command succeeded but was expected to fail\nOutput: #{@stdout}"
-  end
-end
-
-Then /^the output should contain "([^\"]+)"$/ do |expected|
-  expect(@stdout).to include(expected)
-end
-
-Given /^I create a file "([^\"]+)" with content "([^\"]+)"$/ do |filename, content|
-  Dir.chdir(@test_dir) do
-    File.write(filename, content)
-  end
-end
-
-Given /^I commit the changes with message "([^\"]+)"$/ do |message|
-  Dir.chdir(@test_dir) do
-    system("git add -A", out: File::NULL, err: File::NULL)
-    system("git commit -m '#{message}'", out: File::NULL, err: File::NULL)
-  end
-end
-
-Then /^a file "([^\"]+)" should exist locally$/ do |filename|
-  path = File.join(@test_dir, filename)
-  expect(File.exist?(path)).to be(true), "Expected file #{filename} to exist at #{path}"
-end
-
-# Branch management
-Given /^I create and switch to branch "([^"]+)"$/ do |branch_name|
-  Dir.chdir(@test_dir) do
-    system("git checkout -b #{branch_name}", out: File::NULL, err: File::NULL)
-  end
-end
-
-Then /^I should be on branch "([^"]+)"$/ do |expected_branch|
-  Dir.chdir(@test_dir) do
-    current = `git rev-parse --abbrev-ref HEAD`.chomp
-    expect(current).to eq(expected_branch)
-  end
-end
-
-Given /^I push branch "([^"]+)" to origin$/ do |branch_name|
-  Dir.chdir(@test_dir) do
-    system("git push -u origin #{branch_name}", out: File::NULL, err: File::NULL)
-  end
-end
-
-Then /^branch "([^"]+)" should not exist locally$/ do |branch_name|
-  Dir.chdir(@test_dir) do
-    result = system("git rev-parse --verify #{branch_name}", out: File::NULL, err: File::NULL)
-    expect(result).to be(false), "Expected branch #{branch_name} to not exist locally"
-  end
-end
-
-Then /^branch "([^"]+)" should not exist on origin$/ do |branch_name|
-  Dir.chdir(@test_dir) do
-    system("git fetch --prune origin", out: File::NULL, err: File::NULL)
-    result = system("git rev-parse --verify origin/#{branch_name}", out: File::NULL, err: File::NULL)
-    expect(result).to be(false), "Expected branch #{branch_name} to not exist on origin"
-  end
-end
-
-# Simulating remote changes
-Given /^master has an additional commit from another source$/ do
-  run_ssh "cd ~/testproject && git pull origin master"
-  run_ssh "cd ~/testproject && echo 'remote change' > remote-change.txt"
-  run_ssh "cd ~/testproject && git add remote-change.txt"
-  run_ssh "cd ~/testproject && git commit -m 'Remote commit on master'"
-  run_ssh "cd ~/testproject && git push origin master"
-
-  Dir.chdir(@test_dir) do
-    system("git fetch origin", out: File::NULL, err: File::NULL)
-  end
-end
-
-Given /^master has a conflicting commit to "([^"]+)"$/ do |filename|
-  run_ssh "cd ~/testproject && git pull origin master"
-  run_ssh "cd ~/testproject && echo 'conflicting content from remote' > #{filename}"
-  run_ssh "cd ~/testproject && git add #{filename}"
-  run_ssh "cd ~/testproject && git commit -m 'Remote conflicting commit'"
-  run_ssh "cd ~/testproject && git push origin master"
-
-  Dir.chdir(@test_dir) do
-    system("git fetch origin", out: File::NULL, err: File::NULL)
-  end
-end
-
-# CI setup
-Given /^a local CI script that passes$/ do
-  Dir.chdir(@test_dir) do
-    File.write("bin/rake", <<~'SCRIPT')
-#!/bin/bash
-case "$1" in
-  ci) echo "All tests passed!"; exit 0 ;;
-esac
-    SCRIPT
-    FileUtils.chmod(0o755, "bin/rake")
-  end
-end
-
-Given /^a local CI script that fails with "([^"]+)"$/ do |error_message|
-  Dir.chdir(@test_dir) do
-    File.write("bin/rake", <<~SCRIPT)
-#!/bin/bash
-case "$1" in
-  ci) echo "#{error_message}"; exit 1 ;;
-esac
-    SCRIPT
-    FileUtils.chmod(0o755, "bin/rake")
-  end
-end
-
-Given /^I switch to branch "([^"]+)"$/ do |branch_name|
-  Dir.chdir(@test_dir) do
-    system("git checkout #{branch_name}", out: File::NULL, err: File::NULL)
-  end
-end
-
-# Output negation
-Then /^the output should not contain "([^"]+)"$/ do |unexpected|
-  expect(@stdout).not_to include(unexpected)
-end
-

data/features/support/bard-coverage

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-root = File.expand_path("../../..", __FILE__)
-
-require "simplecov"
-SimpleCov.root(root)
-SimpleCov.start do
-  command_name "Cucumber (subprocess #{$$})"
-  track_files "lib/**/*.rb"
-  add_filter "spec/"
-  add_filter "features/"
-  coverage_dir "#{root}/coverage"
-end
-
-$LOAD_PATH.unshift("#{root}/lib")
-require "bard/cli"
-Bard::CLI.start ARGV

data/features/support/env.rb

@@ -1,22 +0,0 @@
-require "simplecov"
-SimpleCov.start do
-  command_name "Cucumber"
-  track_files "lib/**/*.rb"
-  add_filter "spec/"
-  add_filter "features/"
-end
-
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require "bard"
-require 'rspec/expectations'
-require 'fileutils'
-
-ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}:#{ENV['PATH']}"
-ENV["GIT_DIR"] = nil
-ENV["GIT_WORK_TREE"] = nil
-ENV["GIT_INDEX_FILE"] = nil
-
-ROOT = File.expand_path(File.dirname(__FILE__) + '/../..')
-
-# Ensure tmp directory exists
-FileUtils.mkdir_p(File.join(ROOT, "tmp"))

data/features/support/test_server.rb

@@ -1,216 +0,0 @@
-require "fileutils"
-require "open3"
-require "tmpdir"
-require "docker-api"
-
-module TestServerWorld
-  class << self
-    attr_accessor :server_available, :image_built
-  end
-
-  class PrerequisiteError < StandardError; end
-
-  def ensure_server_available
-    return if TestServerWorld.server_available
-
-    unless system("command -v podman >/dev/null 2>&1")
-      raise PrerequisiteError, "podman is not installed"
-    end
-
-    configure_container_socket
-    build_test_image
-    FileUtils.chmod(0o600, ssh_key_path)
-
-    TestServerWorld.server_available = true
-  end
-
-  def configure_container_socket
-    if ENV["DOCKER_HOST"]
-      Docker.url = ENV["DOCKER_HOST"]
-      return
-    end
-
-    socket_path = "/run/user/#{Process.uid}/podman/podman.sock"
-    unless File.exist?(socket_path)
-      system("systemctl --user start podman.socket 2>/dev/null")
-      sleep 2
-    end
-
-    unless File.exist?(socket_path)
-      raise PrerequisiteError, "Podman socket not available"
-    end
-
-    ENV["DOCKER_HOST"] = "unix://#{socket_path}"
-    Docker.url = ENV["DOCKER_HOST"]
-  end
-
-  def build_test_image
-    return if TestServerWorld.image_built
-
-    # Check if image already exists (e.g., pre-built in CI)
-    if image_exists?("bard-test-server")
-      TestServerWorld.image_built = true
-      return
-    end
-
-    system("podman pull ubuntu:24.04 >/dev/null 2>&1")
-
-    docker_dir = File.join(ROOT, "spec/acceptance/docker")
-    unless system("podman build -t bard-test-server -f #{docker_dir}/Dockerfile #{docker_dir} 2>&1")
-      raise PrerequisiteError, "Failed to build test image"
-    end
-
-    TestServerWorld.image_built = true
-  end
-
-  def image_exists?(name)
-    Docker::Image.get(name)
-    true
-  rescue Docker::Error::NotFoundError
-    false
-  end
-
-  def start_test_server
-    ensure_server_available
-
-    @container = Docker::Container.create(
-      "Image" => "localhost/bard-test-server:latest",
-      "ExposedPorts" => { "22/tcp" => {} },
-      "HostConfig" => {
-        "PortBindings" => { "22/tcp" => [{ "HostPort" => "" }] },
-        "PublishAllPorts" => true
-      }
-    )
-    @container.start
-    @container.refresh!
-
-    @ssh_port = @container.info["NetworkSettings"]["Ports"]["22/tcp"].first["HostPort"].to_i
-
-    wait_for_ssh
-    setup_test_directory
-  end
-
-  def wait_for_ssh
-    30.times do
-      return if system(
-        "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
-        "-o", "ConnectTimeout=1", "-p", @ssh_port.to_s, "-i", ssh_key_path,
-        "deploy@localhost", "true",
-        out: File::NULL, err: File::NULL
-      )
-      sleep 0.5
-    end
-    raise PrerequisiteError, "SSH not ready"
-  end
-
-  def setup_test_directory
-    # Set up git repos on the remote container
-    run_ssh "git config --global user.email 'test@example.com'"
-    run_ssh "git config --global user.name 'Test User'"
-    run_ssh "git config --global init.defaultBranch master"
-    run_ssh "mkdir -p ~/repos/testproject.git"
-    run_ssh "cd ~/repos/testproject.git && git init --bare"
-    run_ssh "git clone ~/repos/testproject.git ~/testproject"
-    run_ssh "mkdir -p ~/testproject/bin ~/testproject/db"
-
-    # bin/setup script
-    run_ssh "echo '#!/bin/bash' > ~/testproject/bin/setup"
-    run_ssh "echo 'echo Setup complete' >> ~/testproject/bin/setup"
-    run_ssh "chmod +x ~/testproject/bin/setup"
-
-    # bin/rake script for db:dump and db:load
-    run_ssh <<~'SETUP'
-      cat > ~/testproject/bin/rake << 'SCRIPT'
-#!/bin/bash
-case "$1" in
-  db:dump)
-    echo "production data" | gzip > db/data.sql.gz
-    ;;
-  db:load)
-    gunzip -c db/data.sql.gz > /dev/null
-    echo "Data loaded"
-    ;;
-esac
-SCRIPT
-    SETUP
-    run_ssh "chmod +x ~/testproject/bin/rake"
-    run_ssh "cd ~/testproject && git add . && git commit -m 'Initial commit'"
-    run_ssh "cd ~/testproject && git push origin master"
-
-    # Set up local git repo in isolated temp directory
-    setup_local_git_repo
-  end
-
-  def setup_local_git_repo
-    @test_dir = Dir.mktmpdir("bard_test")
-    @ssh_command = "ssh -i #{ssh_key_path} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
-
-    Dir.chdir(@test_dir) do
-      # Clone directly into the temp directory (pass SSH command via env, not global ENV)
-      ssh_url = "ssh://deploy@localhost:#{@ssh_port}/home/deploy/repos/testproject.git"
-      system({ "GIT_SSH_COMMAND" => @ssh_command }, "git clone #{ssh_url} .", out: File::NULL, err: File::NULL)
-
-      # Configure git settings locally in this repo only
-      system("git config user.email 'test@example.com'", out: File::NULL, err: File::NULL)
-      system("git config user.name 'Test User'", out: File::NULL, err: File::NULL)
-      system("git config core.sshCommand '#{@ssh_command}'", out: File::NULL, err: File::NULL)
-
-      # Ensure db directory exists locally
-      FileUtils.mkdir_p("db")
-
-      # Write bard config in the test directory
-      File.write("bard.rb", <<~RUBY)
-        target :production do
-          ssh "deploy@localhost:#{@ssh_port}",
-            path: "testproject",
-            ssh_key: "#{ssh_key_path}"
-          ping false
-        end
-      RUBY
-    end
-  end
-
-  def run_ssh(command)
-    stdout, status = Open3.capture2e(
-      "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
-      "-p", @ssh_port.to_s, "-i", ssh_key_path,
-      "deploy@localhost", command
-    )
-    unless status.success?
-      raise PrerequisiteError, "SSH command failed: #{command}\nOutput: #{stdout}"
-    end
-    true
-  end
-
-  def run_bard(command)
-    Dir.chdir(@test_dir) do
-      bard_coverage = File.join(ROOT, "features/support/bard-coverage")
-      @stdout, @status = Open3.capture2e("#{bard_coverage} #{command}")
-    end
-  end
-
-  def ssh_key_path
-    File.join(ROOT, "spec/acceptance/docker/test_key")
-  end
-
-  def stop_test_server
-    return unless @container
-    @container.stop rescue nil
-    @container.delete(force: true) rescue nil
-  ensure
-    @container = nil
-    @ssh_port = nil
-    FileUtils.rm_rf(@test_dir) if @test_dir
-    @test_dir = nil
-  end
-end
-
-World(TestServerWorld)
-
-Before("@server") do
-  start_test_server
-end
-
-After("@server") do
-  stop_test_server
-end

data/lib/bard/cli.rb

@@ -1,44 +0,0 @@
-# this file gets loaded in the CLI context, not the Rails boot context
-
-require "thor"
-require "bard/version"
-require "bard/config"
-require "bard/command"
-
-module Bard
-  class CLI < Thor
-    class_option :verbose, type: :boolean, aliases: :v
-
-    map "--version" => :version
-    desc "version", "Display version"
-    def version
-      puts Bard::VERSION
-    end
-
-    def self.exit_on_failure? = true
-
-    no_commands do
-      def red(text)    = "\e[31m#{text}\e[0m"
-      def yellow(text) = "\e[33m#{text}\e[0m"
-      def green(text)  = "\e[32m#{text}\e[0m"
-
-      def run!(...)
-        Bard::Command.run!(...)
-      rescue Bard::Command::Error => e
-        puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
-        exit 1
-      end
-
-      def config
-        @config ||= Bard::Config.current
-      end
-
-      def project_name
-        config.project_name
-      end
-    end
-
-    # load plugins from bard and other gems
-    Gem.find_files("bard/plugins/*.rb").sort.each { |path| require path }
-  end
-end

data/lib/bard/command.rb

@@ -1,31 +0,0 @@
-require "open3"
-
-module Bard
-  module Command
-    class Error < RuntimeError; end
-
-    def self.run!(command, verbose: false, quiet: false)
-      result = run(command, verbose:, quiet:)
-      raise Error.new(command) unless result
-      result
-    end
-
-    def self.run(command, verbose: false, quiet: false)
-      if verbose
-        system command
-      else
-        stdout, stderr, status = Open3.capture3(command)
-        failed = status.to_i.nonzero?
-        if failed && !quiet
-          $stdout.puts stdout
-          $stderr.puts stderr
-        end
-        !failed && stdout
-      end
-    end
-
-    def self.exec!(command)
-      Kernel.exec command
-    end
-  end
-end

data/lib/bard/copy.rb

@@ -1,45 +0,0 @@
-module Bard
-  class Copy
-    @handlers = []
-
-    class << self
-      def inherited(subclass)
-        super
-        @handlers.unshift(subclass)
-      end
-
-      def file(path, from:, to:, verbose: false)
-        handler_for!(from, to).new(path, from, to, verbose).file
-      end
-
-      def dir(path, from:, to:, verbose: false)
-        handler_for!(from, to).new(path, from, to, verbose).dir
-      end
-
-      private
-
-      def handler_for!(from, to)
-        handler = @handlers.find { |h| h.can_handle?(from, to) }
-        raise "No copy handler for #{from.key} -> #{to.key}" unless handler
-        handler
-      end
-    end
-
-    attr_reader :path, :from, :to, :verbose
-
-    def initialize(path, from, to, verbose)
-      @path = path
-      @from = from
-      @to = to
-      @verbose = verbose
-    end
-
-    def file
-      raise NotImplementedError
-    end
-
-    def dir
-      raise NotImplementedError
-    end
-  end
-end

data/lib/bard/plugins/data.rb

@@ -1,56 +0,0 @@
-require "bard/command"
-require "bard/copy"
-require "bard/plugins/ssh"
-require "bard/plugins/url"
-
-class Bard::CLI
-  option :from, default: "production"
-  option :to, default: "local"
-  desc "data --from=production --to=local", "copy database and assets from from to to"
-  def data
-    from = config[options[:from]]
-    to = config[options[:to]]
-
-    from.require_capability!(:ssh) unless from.key == :local
-    to.require_capability!(:ssh) unless to.key == :local
-
-    if to.key == :production
-      url = to.url
-      puts yellow "WARNING: You are about to push data to production, overwriting everything that is there!"
-      answer = ask("If you really want to do this, please type in the full HTTPS url of the production server:")
-      if answer != url
-        puts red("!!! ") + "Failed! We expected #{url}. Is this really where you want to overwrite all the data?"
-        exit 1
-      end
-    end
-
-    puts "Dumping #{from.key} database to file..."
-    from.run! "bin/rake db:dump"
-
-    puts "Transfering file from #{from.key} to #{to.key}..."
-    Bard::Copy.file "db/data.sql.gz", from: from, to: to, verbose: true
-
-    puts "Loading file into #{to.key} database..."
-    to.run! "bin/rake db:load"
-
-    config.data.each do |path|
-      puts "Synchronizing files in #{path}..."
-      Bard::Copy.dir path, from: from, to: to, verbose: true
-    end
-  rescue Bard::Command::Error => e
-    puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
-    exit 1
-  end
-end
-
-require "bard/config"
-
-class Bard::Config
-  def data(*paths)
-    if paths.empty?
-      @data_paths ||= []
-    else
-      @data_paths = paths
-    end
-  end
-end