bard 2.0.0.beta → 2.0.0

data/lib/bard/{ci → plugins/deploy/ci}/runner.rb

@@ -1,17 +1,48 @@
-require "bard/ci/state"
-require "bard/ci/retryable"
+require "bard/plugins/deploy/ci/state"
+require "bard/retryable"
 
 module Bard
   class CI
     class Runner < Struct.new(:project_name, :branch, :sha)
-      include Retryable
+      include Bard::Retryable
+
+      @runners = {}
+
+      class << self
+        attr_reader :runners
+
+        def inherited(subclass)
+          super
+          name = extract_runner_name(subclass)
+          runners[name] = subclass if name
+        end
+
+        def [](name)
+          runners[name.to_sym]
+        end
+
+        # Returns the last registered runner (most recently loaded wins)
+        def default
+          runners.values.last
+        end
+
+        private
+
+        def extract_runner_name(klass)
+          klass.name&.split("::")&.last
+            &.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            &.gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            &.downcase
+            &.to_sym
+        end
+      end
 
       def run
         start
         @start_time = Time.new.to_i
         @last_time_elapsed = get_last_time_elapsed
         save_state
-        wait_until_started if respond_to?(:wait_until_started)
+        wait_until_started
 
         poll_until_complete { |elapsed, last_time| yield elapsed, last_time }
 
@@ -62,6 +93,9 @@ module Bard
         raise NotImplementedError, "#{self.class}#success? not implemented"
       end
 
+      def wait_until_started
+      end
+
       def get_last_time_elapsed
         nil
       end

data/lib/bard/plugins/deploy/ci.rb

@@ -0,0 +1,38 @@
+require "forwardable"
+require "bard/plugins/deploy/ci/runner"
+
+module Bard
+  class CI
+    def initialize(project_name, branch, runner_name: nil)
+      @project_name = project_name
+      @branch = branch
+      @runner_name = runner_name
+    end
+
+    extend Forwardable
+    delegate [:run, :resume, :exists?, :console, :status] => :runner
+
+    private
+
+    def runner
+      @runner ||= choose_runner_class.new(@project_name, @branch, sha)
+    end
+
+    def sha
+      @sha ||= `git rev-parse #{@branch}`.chomp
+    end
+
+    def choose_runner_class
+      if @runner_name
+        runner_class = Runner[@runner_name]
+        raise "Unknown CI runner: #{@runner_name}" unless runner_class
+        runner_class
+      else
+        runner_class = Runner.default
+        raise "No CI runner available" unless runner_class
+        runner_class
+      end
+    end
+  end
+end
+

data/lib/bard/plugins/deploy/ssh_strategy.rb

@@ -0,0 +1,27 @@
+require "bard/plugins/deploy/strategy"
+require "bard/copy"
+require "bard/plugins/ssh"
+
+module Bard
+  class DeployStrategy
+    class SSH < DeployStrategy
+      def deploy(clone: nil, branch: nil, force: false)
+        target.require_capability!(:ssh)
+
+        if clone
+          target.run! "git clone git@github.com:botandrosedesign/#{clone} #{target.path}", home: true
+          Bard::Copy.file "config/master.key", from: target.config[:local], to: target
+        elsif force
+          target.run! "git fetch origin #{branch}"
+          target.run! "git checkout -f origin/#{branch}"
+        else
+          branch ||= target.instance_variable_get(:@branch) || "master"
+          target.run! "git pull --ff-only origin #{branch}"
+        end
+
+        target.run! "bin/setup"
+        target.run! "bard setup" if clone
+      end
+    end
+  end
+end

data/lib/bard/{deploy_strategy.rb → plugins/deploy/strategy.rb}

@@ -39,7 +39,7 @@ module Bard
       @target = target
     end
 
-    def deploy
+    def deploy(clone: nil, branch: nil, force: false)
       raise NotImplementedError, "Subclasses must implement #deploy"
     end
 

data/lib/bard/plugins/deploy.rb

@@ -0,0 +1,240 @@
+require "bard/plugins/ping"
+require "bard/plugins/git"
+require "bard/command"
+require "bard/plugins/deploy/strategy"
+require "bard/plugins/deploy/ssh_strategy"
+require "bard/plugins/deploy/ci"
+require "bard/plugins/deploy/ci/jenkins"
+require "bard/plugins/deploy/ci/local"
+require "bard/plugins/deploy/ci/github_actions"
+require "tmpdir"
+
+class Bard::CLI
+  option :"skip-ci", type: :boolean
+  option :"local-ci", type: :boolean
+  option :ci, type: :string
+  option :clone, type: :boolean
+  option :target, type: :string, default: "production"
+  desc "deploy [BRANCH]", "deploys branch to target (default: current branch to production)"
+  def deploy(branch = nil)
+    branch ||= Bard::Git.current_branch
+
+    if branch == "master"
+      if !Bard::Git.up_to_date_with_remote?(branch)
+        run! "git push origin #{branch}:#{branch}"
+      end
+      invoke :ci, [branch], options.slice("local-ci", "ci") unless options["skip-ci"] || config.ci == false
+
+    else
+      run! "git fetch origin"
+      if Bard::Git.current_branch != "master" && !Bard::Git.in_linked_worktree?
+        run! "git fetch origin master:master"
+      end
+
+      unless Bard::Git.fast_forward_merge?("origin/master", branch)
+        puts "The master branch has advanced. Attempting rebase..."
+        if branch == Bard::Git.current_branch
+          run! "git rebase origin/master"
+        else
+          tmpdir = Dir.mktmpdir("bard-rebase")
+          begin
+            run! "git worktree add --detach #{tmpdir} #{branch}"
+            success = Dir.chdir(tmpdir) { system("git rebase origin/master") }
+            rebased_sha = Dir.chdir(tmpdir) { `git rev-parse HEAD`.strip } if success
+            run! "git worktree remove #{tmpdir} --force"
+            unless success
+              puts red("!!! ") + "Rebase failed due to conflicts."
+              puts "Please rebase #{branch} manually:"
+              puts "  git checkout #{branch}"
+              puts "  git rebase origin/master"
+              exit 1
+            end
+            run! "git branch -f #{branch} #{rebased_sha}"
+          ensure
+            FileUtils.rm_rf(tmpdir) if Dir.exist?(tmpdir)
+          end
+        end
+      end
+
+      run! "git push -f origin #{branch}:#{branch}"
+
+      invoke :ci, [branch], options.slice("local-ci", "ci") unless options["skip-ci"] || config.ci == false
+
+      run! "git push origin #{branch}:master"
+      if Bard::Git.current_branch == "master"
+        run! "git pull --ff-only origin master"
+      elsif Bard::Git.in_linked_worktree?
+        run! "git fetch origin master"
+      else
+        run! "git fetch origin master:master"
+      end
+    end
+
+    if `git remote` =~ /\bgithub\b/
+      run! "git push github"
+    end
+
+    to = options[:target].to_sym
+
+    target = config[to]
+    strategy = target.deploy_strategy_instance
+    if options[:clone]
+      strategy.deploy(clone: project_name)
+    else
+      strategy.deploy
+    end
+
+    puts green("Deploy Succeeded")
+
+    if branch != "master"
+      puts "Deleting branch: #{branch}"
+      run! "git push --delete origin #{branch}"
+
+      if branch == Bard::Git.current_branch && Bard::Git.in_linked_worktree?
+        worktree_path = Dir.pwd
+        main_checkout = File.dirname(File.expand_path(`git rev-parse --git-common-dir`.chomp))
+        Dir.chdir(main_checkout)
+        run! "git worktree remove #{worktree_path}"
+        run! "git branch -D #{branch}"
+        puts "Worktree removed. Run: cd #{main_checkout}"
+      else
+        if branch == Bard::Git.current_branch
+          run! "git checkout master"
+        end
+        run! "git branch -D #{branch}"
+      end
+    end
+
+    ping to
+  rescue Bard::Command::Error => e
+    puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
+    exit 1
+  end
+
+  desc "stage [branch=HEAD]", "pushes current branch, and stages it"
+  def stage(branch = Bard::Git.current_branch)
+    if config[:production] == config[:staging]
+      raise Thor::Error.new("`bard stage` is disabled until a production target is defined. Until then, please use `bard deploy` to deploy to the staging target.")
+    end
+
+    run! "git push -u origin #{branch}", verbose: true
+
+    target = config[:staging]
+    strategy = target.deploy_strategy_instance
+    strategy.deploy(branch: branch, force: true)
+
+    puts green("Stage Succeeded")
+
+    ping :staging
+  rescue Bard::Command::Error => e
+    puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
+    exit 1
+  end
+
+  option :"local-ci", type: :boolean
+  option :ci, type: :string
+  option :status, type: :boolean
+  option :resume, type: :boolean
+  desc "ci [branch=HEAD]", "runs ci against BRANCH"
+  def ci(branch = Bard::Git.current_branch)
+    runner_name = if options["local-ci"]
+      :local
+    elsif options["ci"]
+      options["ci"].to_sym
+    else
+      config.ci
+    end
+    ci = Bard::CI.new(project_name, branch, runner_name: runner_name)
+    unless ci.exists?
+      puts red("No CI found for #{project_name}!")
+      puts "Re-run with --skip-ci to bypass CI, if you absolutely must, and know what you're doing."
+      exit 1
+    end
+
+    return puts ci.status if options["status"]
+
+    if options["resume"]
+      puts "Continuous integration: resuming build..."
+      success = ci.resume do |elapsed_time, last_time|
+        if last_time
+          percentage = (elapsed_time.to_f / last_time.to_f * 100).to_i
+          output = "  Estimated completion: #{percentage}%"
+        else
+          output = "  No estimated completion time. Elapsed time: #{elapsed_time} sec"
+        end
+        print "\x08" * output.length
+        print output
+        $stdout.flush
+      end
+    else
+      puts "Continuous integration: starting build on #{branch}..."
+
+      success = ci.run do |elapsed_time, last_time|
+        if last_time
+          percentage = (elapsed_time.to_f / last_time.to_f * 100).to_i
+          output = "  Estimated completion: #{percentage}%"
+        else
+          output = "  No estimated completion time. Elapsed time: #{elapsed_time} sec"
+        end
+        print "\x08" * output.length
+        print output
+        $stdout.flush
+      end
+    end
+
+    if success
+      puts
+      puts "Continuous integration: success!"
+    else
+      puts
+      puts ci.console
+      puts red("Automated tests failed!")
+      exit 1
+    end
+  end
+
+  option :from, default: "production"
+  option :to, default: "local"
+  desc "master_key --from=production --to=local", "copy master key from from to to"
+  def master_key
+    from = config[options[:from]]
+    to = config[options[:to]]
+    Bard::Copy.file "config/master.key", from: from, to: to
+  end
+end
+
+require "bard/config"
+
+class Bard::Config
+  def ci(system = nil)
+    if system.nil?
+      @ci_system
+    else
+      @ci_system = system
+    end
+  end
+end
+
+require "bard/target"
+
+class Bard::Target
+  def deploy_strategy
+    @deploy_strategy
+  end
+
+  def deploy_strategy_instance
+    strategy = @deploy_strategy
+    strategy ||= :ssh if has_capability?(:ssh)
+    raise "No deployment strategy configured for target #{key}" unless strategy
+
+    strategy_class = Bard::DeployStrategy[strategy]
+    raise "Unknown deployment strategy: #{strategy}" unless strategy_class
+
+    strategy_class.new(self)
+  end
+
+  def strategy_options(strategy_name)
+    @strategy_options_hash ||= {}
+    @strategy_options_hash[strategy_name] || {}
+  end
+end

data/lib/bard/{git.rb → plugins/git.rb}

@@ -21,12 +21,15 @@ module Bard
 
     def sha_of ref
       sha = `git rev-parse #{ref} 2>/dev/null`.chomp
-      return sha if command_succeeded?
+      return sha if $?.success?
       nil # Branch doesn't exist
     end
 
-    def command_succeeded?
-      $?.success?
+    def in_linked_worktree?
+      git_dir = `git rev-parse --git-dir 2>/dev/null`.chomp
+      common_dir = `git rev-parse --git-common-dir 2>/dev/null`.chomp
+      return false if git_dir.empty? || common_dir.empty?
+      File.expand_path(git_dir) != File.expand_path(common_dir)
     end
   end
 end

data/lib/bard/{github.rb → plugins/github.rb}

@@ -2,11 +2,12 @@ require "net/http"
 require "json"
 require "base64"
 require "rbnacl"
-require "bard/ci/retryable"
+require "bard/retryable"
+require "bard/secrets"
 
 module Bard
   class Github < Struct.new(:project_name)
-    include CI::Retryable
+    include Retryable
 
     def initialize(project_name, api_key: nil)
       super(project_name)
@@ -107,10 +108,7 @@ module Bard
     private
 
     def api_key
-      @api_key ||= begin
-        raw = `git ls-remote -t git@github.com:botandrosedesign/secrets`
-        raw[/github-apikey\|(.+)$/, 1]
-      end
+      @api_key ||= Bard::Secrets.fetch("github-apikey")
     end
 
     def request path, &block

data/lib/bard/{deploy_strategy/github_pages.rb → plugins/github_pages/strategy.rb}

@@ -1,5 +1,5 @@
-require "bard/deploy_strategy"
-require "bard/git"
+require "bard/plugins/deploy/strategy"
+require "bard/plugins/git"
 require "fileutils"
 require "uri"
 
@@ -8,11 +8,10 @@ module Bard
     class GithubPages < DeployStrategy
       def initialize(target, url = nil, **options)
         super(target)
-        @url = url
+        @url = url || target.github_pages
         @options = options
 
-        # Auto-configure ping URL if provided
-        target.ping(url) if url
+        target.url(url) if url
       end
 
       def deploy
@@ -65,7 +64,15 @@ module Bard
       ensure
         # cleanup
         run! <<~SH
-          cat tmp/pids/server.pid | xargs -I {} kill {}
+          PID=$(cat tmp/pids/server.pid 2>/dev/null)
+          if [ -n "$PID" ]; then
+            kill $PID 2>/dev/null
+            for i in 1 2 3 4 5; do
+              kill -0 $PID 2>/dev/null || break
+              sleep 1
+            done
+            kill -9 $PID 2>/dev/null || true
+          fi
           rm -rf public/assets
         SH
       end

data/lib/bard/plugins/github_pages.rb

@@ -0,0 +1,30 @@
+require "bard/plugins/github_pages/strategy"
+require "bard/config"
+require "bard/target"
+
+class Bard::Config
+  def github_pages(url)
+    uri = url.start_with?("http") ? URI.parse(url) : URI.parse("https://#{url}")
+    hostname = uri.hostname.sub(/^www\./, "")
+
+    remove_target :production
+    target :production do
+      github_pages url
+      url(hostname) if hostname
+    end
+
+    backup(false) if respond_to?(:backup)
+  end
+end
+
+class Bard::Target
+  def github_pages(url = nil)
+    if url.nil?
+      @github_pages_url
+    else
+      @deploy_strategy = :github_pages
+      @github_pages_url = url
+      enable_capability(:github_pages)
+    end
+  end
+end

data/lib/bard/plugins/hurt.rb

@@ -0,0 +1,13 @@
+class Bard::CLI
+  desc "hurt <command>", "reruns a command until it fails"
+  def hurt(*args)
+    (1..).each do |count|
+      puts "Running attempt #{count}"
+      system *args
+      unless $?.success?
+        puts "Ran #{count-1} times before failing"
+        break
+      end
+    end
+  end
+end

data/{install_files → lib/bard/plugins/install}/.github/dependabot.yml

@@ -4,6 +4,8 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+    cooldown:
+      default-days: 7
     allow:
       - dependency-type: "all"
     rebase-strategy: "disabled"
@@ -14,4 +16,3 @@ updates:
         update-types:
           - "minor"
           - "patch"
-

data/{install_files → lib/bard/plugins/install}/.github/workflows/cache-ci.yml

@@ -6,7 +6,7 @@ on:
     - cron: '0 0 */3 * *'
 jobs:
   build_ruby_cache:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     timeout-minutes: 30
     steps:
     - uses: actions/checkout@v3

data/{install_files → lib/bard/plugins/install}/.github/workflows/ci.yml

@@ -12,7 +12,7 @@ permissions:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04${{ github.actor != 'dependabot[bot]' && '-16core' || '' }}
+    runs-on: ubuntu-24.04${{ github.actor != 'dependabot[bot]' && '-8core' || '' }}
     timeout-minutes: 30
     env:
       RAILS_ENV: test
@@ -47,7 +47,7 @@ jobs:
 
   autodeploy-dependabot-prs:
     needs: test
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     timeout-minutes: 30
     if: github.actor == 'dependabot[bot]'
     steps:

data/lib/bard/plugins/install.rb

@@ -0,0 +1,9 @@
+class Bard::CLI
+  desc "install", "copies bin/setup and bin/ci scripts into current project."
+  def install
+    install_files_path = File.expand_path("install", __dir__)
+
+    system "cp -R #{install_files_path}/* bin/"
+    system "cp -R #{install_files_path}/.github ./"
+  end
+end

data/lib/bard/plugins/open.rb

@@ -0,0 +1,20 @@
+require "bard/plugins/url"
+
+class Bard::CLI
+  desc "open [target=production]", "opens the url in the web browser."
+  def open(target = :production)
+    exec "xdg-open #{open_url target}"
+  end
+
+  no_commands do
+    def open_url(target)
+      if target.to_sym == :ci
+        "https://github.com/botandrosedesign/#{project_name}/actions/workflows/ci.yml"
+      else
+        t = config[target]
+        t.require_capability!(:url)
+        t.url
+      end
+    end
+  end
+end

data/lib/bard/{ping.rb → plugins/ping/check.rb}

@@ -2,13 +2,13 @@ require "net/http"
 require "uri"
 
 module Bard
-  class Ping < Struct.new(:server)
-    def self.call server
-      new(server).call
+  class Ping < Struct.new(:target)
+    def self.call target
+      new(target).call
     end
 
     def call
-      server.ping.reject { |url| reachable?(url) }
+      target.ping.reject { |url| reachable?(url) }
     end
 
     private

data/lib/bard/plugins/ping/target_methods.rb

@@ -0,0 +1,23 @@
+require "bard/target"
+require "bard/plugins/url/target_methods"
+require "bard/plugins/ping/check"
+
+class Bard::Target
+  def ping(*urls)
+    if urls.empty?
+      @ping_urls || [url].compact
+    elsif urls.first == false
+      @ping_urls = []
+    else
+      @ping_urls = urls.flatten.map { |u| normalize_url(u) }
+    end
+  end
+
+  def ping!
+    require_capability!(:url)
+    failed_urls = Bard::Ping.call(self)
+    if failed_urls.any?
+      raise "Ping failed for: #{failed_urls.join(", ")}"
+    end
+  end
+end

data/lib/bard/plugins/ping.rb

@@ -0,0 +1,10 @@
+require "bard/plugins/ping/target_methods"
+
+class Bard::CLI
+  desc "ping [target=production]", "hits the target over http to verify that its up."
+  def ping(target = :production)
+    down_urls = Bard::Ping.call(config[target])
+    down_urls.each { |url| puts "#{url} is down!" }
+    exit 1 if down_urls.any?
+  end
+end

data/lib/bard/plugins/run.rb

@@ -0,0 +1,19 @@
+require "bard/command"
+
+class Bard::CLI
+  # HACK: we don't use Thor::Base#run, so its okay to stomp on it here
+  original_verbose, $VERBOSE = $VERBOSE, nil
+  Thor::THOR_RESERVED_WORDS -= ["run"]
+  $VERBOSE = original_verbose
+
+  option :target, type: :string, default: "production"
+  option :home, type: :boolean
+  desc "run <command>", "run the given command on the specified target"
+  def run(*args)
+    target = config[options[:target].to_sym]
+    target.run!(*args.join(" "), verbose: true, home: options[:home])
+  rescue Bard::Command::Error => e
+    puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
+    exit 1
+  end
+end