bard 2.2.0 → 3.0.0

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

@@ -1,60 +0,0 @@
-require "bard/command"
-
-module Bard
-  class DeployStrategy
-    @strategies = {}
-
-    class << self
-      attr_reader :strategies
-
-      def inherited(subclass)
-        super
-        # Extract strategy name from class name
-        # e.g., Bard::DeployStrategy::SSH -> :ssh
-        name = extract_strategy_name(subclass)
-        strategies[name] = subclass
-      end
-
-      def [](name)
-        strategies[name.to_sym]
-      end
-
-      private
-
-      def extract_strategy_name(klass)
-        # Get the class name without module prefix
-        class_name = klass.name.split('::').last
-        # Convert from CamelCase to snake_case
-        class_name
-          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-          .downcase
-          .to_sym
-      end
-    end
-
-    attr_reader :target
-
-    def initialize(target)
-      @target = target
-    end
-
-    def deploy(clone: nil, branch: "master", force: false)
-      raise NotImplementedError, "Subclasses must implement #deploy"
-    end
-
-    # Helper methods for strategies
-    def run!(command)
-      Command.run!(command)
-    end
-
-    def run(command)
-      Command.run(command)
-    end
-
-    def system!(command)
-      result = Kernel.system(command)
-      raise "Command failed: #{command}" unless result
-    end
-  end
-end

data/lib/bard/plugins/deploy.rb

@@ -1,260 +0,0 @@
-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
-
-    if staging_provisioned?(target)
-      strategy.deploy(branch: branch, force: true)
-      puts green("Stage Succeeded")
-
-    else # clone from scratch
-      puts yellow("Staging site for #{project_name} not found — provisioning it from scratch…")
-      strategy.deploy(clone: project_name, branch: branch)
-      puts green("Stage Succeeded")
-
-      puts "#{project_name} was rebuilt from scratch; its database and files are empty."
-      if $stdin.tty? && !no?("Restore #{project_name}'s data from production now? (bard data --from production --to staging) [Y/n]")
-        invoke :data, [], from: "production", to: "staging"
-      else
-        puts "Run #{yellow("bard data --from production --to staging")} to restore its data."
-      end
-    end
-
-    ping :staging
-  rescue Bard::Command::Error => e
-    puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
-    exit 1
-  end
-
-  no_commands do
-    def staging_provisioned?(target)
-      !!target.run("test -e #{target.path}/.git", home: true)
-    end
-  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/plugins/git.rb

@@ -1,45 +0,0 @@
-module Bard
-  module Git
-    module_function
-
-    def current_branch
-      ref = `git symbolic-ref HEAD 2>&1`.chomp
-      return false if ref =~ /^fatal:/
-      ref.sub(/refs\/heads\//, '') # refs/heads/master ... we want "master"
-    end
-
-    def fast_forward_merge?(root, branch)
-      root_head = sha_of(root)
-      branch_head = sha_of(branch)
-      common_ancestor = `git merge-base #{root_head} #{branch_head}`.chomp
-      common_ancestor == root_head
-    end
-
-    def up_to_date_with_remote? branch
-      sha_of(branch) == sha_of("origin/#{branch}")
-    end
-
-    def sha_of ref
-      sha = `git rev-parse #{ref} 2>/dev/null`.chomp
-      return sha if $?.success?
-      nil # Branch doesn't exist
-    end
-
-    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
-
-    def github_pages_url
-      remote = `git remote get-url origin`.chomp
-      match = remote.match(%r{github\.com[:/]+([^/]+?)/(.+?)(?:\.git)?/?\z})
-      raise "Could not derive a github.io URL: origin remote #{remote.inspect} is not a github.com repository" unless match
-      owner, repo = match[1], match[2]
-      host = "#{owner.downcase}.github.io"
-      repo.casecmp?(host) ? "https://#{host}/" : "https://#{host}/#{repo}/"
-    end
-  end
-end
-

data/lib/bard/plugins/github.rb

@@ -1,152 +0,0 @@
-require "net/http"
-require "json"
-require "base64"
-require "rbnacl"
-require "bard/retryable"
-require "bard/secrets"
-
-module Bard
-  class Github < Struct.new(:project_name)
-    include Retryable
-
-    def initialize(project_name, api_key: nil)
-      super(project_name)
-      @api_key = api_key
-    end
-
-    def get path, params={}
-      request(path) do |uri|
-        uri.query = URI.encode_www_form(params)
-        Net::HTTP::Get.new(uri)
-      end
-    end
-
-    def post path, params={}
-      request(path) do |uri|
-        Net::HTTP::Post.new(uri).tap do |r|
-          r.body = JSON.dump(params)
-        end
-      end
-    end
-
-    def put path, params={}
-      request(path) do |uri|
-        Net::HTTP::Put.new(uri).tap do |r|
-          r.body = JSON.dump(params)
-        end
-      end
-    end
-
-    def patch path, params={}
-      request(path) do |uri|
-        Net::HTTP::Patch.new(uri).tap do |r|
-          r.body = JSON.dump(params)
-        end
-      end
-    end
-
-    def delete path, params={}
-      request(path) do |uri|
-        Net::HTTP::Delete.new(uri).tap do |r|
-          r.body = JSON.dump(params)
-        end
-      end
-    end
-
-    def read_file path, branch: "master"
-      metadata = get("contents/#{path}", ref: branch)
-      Base64.decode64(metadata["content"])
-    end
-
-    def add_deploy_key title:, key:
-      post("keys", title:, key:)
-    end
-
-    def add_master_key master_key
-      response = get("actions/secrets/public-key")
-      public_key, public_key_id = response.values_at("key", "key_id")
-
-      def encrypt_secret(encoded_public_key, secret)
-        decoded_key = Base64.decode64(encoded_public_key)
-        public_key = RbNaCl::PublicKey.new(decoded_key)
-        box = RbNaCl::Boxes::Sealed.from_public_key(public_key)
-        encrypted_secret = box.encrypt(secret)
-        Base64.strict_encode64(encrypted_secret)
-      end
-
-      encrypted_master_key = encrypt_secret(public_key, master_key)
-
-      put("actions/secrets/RAILS_MASTER_KEY", {
-        encrypted_value: encrypted_master_key,
-        key_id: public_key_id,
-      })
-    end
-
-    def add_master_branch_protection
-      put("branches/master/protection", {
-        required_status_checks: {
-          strict: false,
-          contexts: [],
-        },
-        enforce_admins: nil,
-        required_pull_request_reviews: nil,
-        restrictions: nil,
-      })
-    end
-
-    def create_repo
-      post("https://api.github.com/orgs/botandrosedesign/repos", {
-        name: project_name,
-        private: true,
-      })
-    end
-
-    def delete_repo
-      delete(nil)
-    end
-
-    private
-
-    def api_key
-      @api_key ||= Bard::Secrets.fetch("github-apikey")
-    end
-
-    def request path, &block
-      uri = if path =~ /^http/
-        URI(path)
-      else
-        base = "https://api.github.com/repos/botandrosedesign/#{project_name}"
-        if path
-          URI(File.join(base, path))
-        else
-          URI(base)
-        end
-      end
-
-      retry_with_backoff do
-        req = nil
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-          req = block.call(uri)
-          req["Accept"] = "application/vnd.github+json"
-          req["Authorization"] = "Bearer #{api_key}"
-          req["X-GitHub-Api-Version"] = "2022-11-28"
-          http.request(req)
-        end
-
-        case response
-        when Net::HTTPRedirection then
-          Net::HTTP.get(URI(response["Location"]))
-        when Net::HTTPSuccess then
-          if response["Content-Type"].to_s.include?("/json")
-            JSON.load(response.body)
-          else
-            response.body
-          end
-        else
-          raise [req.method, req.uri, req.to_hash, response, response.body].inspect
-        end
-      end
-    end
-  end
-end
-

data/lib/bard/plugins/github_pages/strategy.rb

@@ -1,170 +0,0 @@
-require "bard/plugins/deploy/strategy"
-require "bard/plugins/git"
-require "fileutils"
-require "socket"
-require "uri"
-
-module Bard
-  class DeployStrategy
-    class GithubPages < DeployStrategy
-      def initialize(target, url = nil, **options)
-        super(target)
-        @url = url || target.github_pages
-        @options = options
-
-        target.url(url) if url
-      end
-
-      def deploy
-        @sha = Git.sha_of(Git.current_branch)
-        @build_dir = "tmp/github-build-#{@sha}"
-        @branch = "gh-pages"
-        @domain = extract_domain
-        @port = pick_free_port
-
-        puts "Starting deployment to GitHub Pages..."
-
-        build_site
-        tree_sha = create_tree_from_build
-        new_commit = create_commit(tree_sha)
-        commit_and_push(new_commit)
-      end
-
-      private
-
-      def extract_domain
-        return nil unless @url
-        domain = @url
-        domain = URI.parse(domain).hostname if domain =~ /^http/
-        domain
-      end
-
-      def pick_free_port
-        server = TCPServer.new("127.0.0.1", 0)
-        port = server.addr[1]
-        server.close
-        port
-      end
-
-      def build_site
-        # No custom domain => the site serves under /<repo>/, so make the mirror relocatable:
-        # -k rewrites absolute links to relative, and the sed strips the localhost prefix wget
-        # bakes into any links it couldn't crawl.
-        convert_links = @domain ? "" : "-k"
-        relocate_step = @domain ? "" : %(find . -type f \\( -name '*.html' -o -name '*.css' \\) -exec sed -i "s#http://localhost:$PORT/#/#g" {} +)
-        cname_step = @domain ? "echo #{@domain} > CNAME" : ""
-        system "rm -rf #{@build_dir.sub(@sha, "*")}"
-        run! <<~SH
-          set -e
-          PORT=#{@port}
-
-          OUTPUT=$(bundle exec rake assets:clean assets:precompile 2>&1) || echo "$OUTPUT"
-
-          BUILD=#{@build_dir}
-          rm -rf $BUILD
-          mkdir -p $BUILD
-          cp -R public/assets $BUILD/
-
-          # Start rails in the foreground, backgrounded — NOT as a daemon —
-          # so a port-bind failure surfaces instead of being swallowed by fork.
-          rm -f tmp/pids/server.pid
-          RAILS_ENV=production bundle exec rails s -p $PORT -P tmp/pids/server.pid >tmp/pids/server.log 2>&1 &
-          RAILS_PID=$!
-
-          echo waiting...
-          for i in $(seq 1 30); do
-            if ! kill -0 $RAILS_PID 2>/dev/null; then
-              echo "Rails server failed to start on port $PORT:"
-              cat tmp/pids/server.log
-              exit 1
-            fi
-            curl -sf http://localhost:$PORT >/dev/null 2>&1 && break
-            sleep 1
-          done
-
-          cd $BUILD
-          echo copying...
-          wget -nv -r -l inf #{convert_links} --no-remove-listing -FEnH --reject-regex "(\\.*)\\?(.*)" http://localhost:$PORT/ 2>&1
-
-          #{relocate_step}
-          #{cname_step}
-        SH
-      ensure
-        # cleanup
-        run! <<~SH
-          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
-
-      def create_tree_from_build
-        # Create temporary index
-        git_index_file = ".git/tmp-index"
-        git = "GIT_INDEX_FILE=#{git_index_file} git"
-        run! "#{git} read-tree --empty"
-
-        # Add build files to temporary index
-        Dir.chdir(@build_dir) do
-          Dir.glob('**/*', File::FNM_DOTMATCH).each do |file|
-            next if file == '.' || file == '..'
-            if File.file?(file)
-              run! "#{git} update-index --add --cacheinfo 100644 $(#{git} hash-object -w #{file}) #{file}"
-            end
-          end
-        end
-
-        # Create tree object from index
-        tree_sha = `#{git} write-tree`.chomp
-
-        # Clean up temporary index
-        FileUtils.rm_f(git_index_file)
-
-        tree_sha
-      end
-
-      def create_commit(tree_sha)
-        # Get parent commit if branch exists
-        parent = get_parent_commit
-
-        # Create commit object
-        message = "'Deploying to #{@branch} from @ #{@sha} 🚀'"
-        args = ['commit-tree', tree_sha]
-        args += ['-p', parent] if parent
-        args += ['-m', message]
-
-        commit_sha = `git #{args.join(' ')}`.chomp
-
-        commit_sha
-      end
-
-      def get_parent_commit
-        Git.sha_of("#{@branch}^{commit}")
-      end
-
-      def commit_and_push(commit_sha)
-        if branch_exists?
-          run! "git update-ref refs/heads/#{@branch} #{commit_sha}"
-        else
-          run! "git branch #{@branch} #{commit_sha}"
-        end
-        run! "git push -f origin #{@branch}:refs/heads/#{@branch}"
-      end
-
-      def branch_exists?
-        system("git show-ref --verify --quiet refs/heads/#{@branch}")
-      end
-
-      def cleanup
-        # Cleanup method for tests
-      end
-    end
-  end
-end