bard 2.0.0.beta → 2.0.1

data/features/step_definitions/submodule_steps.rb

@@ -1,110 +0,0 @@
-Given /^a submodule$/ do
-  Given 'on development_b, a commit with a new submodule'
-  Given 'on development_b, I type "bard push"'
-  Given 'I type "bard pull"'
-  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
-  @submodule_commit = type "git submodule status"
-end
-
-Given /^the submodule working directory is dirty$/ do
-  Dir.chdir "submodule" do
-    type "git checkout master"
-    type "echo 'submodule_update' > submodule_update"
-  end
-end
-
-Given /^a commit to the submodule$/ do
-  Dir.chdir "submodule" do
-    type "echo 'submodule_update' > submodule_update"
-    type "git add ."
-    type "git commit -am 'update in submodule'"
-  end
-end
-
-Given /^a commit with a new submodule$/ do
-  type "git submodule add #{ROOT}/tmp/submodule_a.git submodule"
-  type "git submodule update --init"
-  Dir.chdir "submodule" do
-    type "git checkout master"
-  end
-  type "git add ."
-  type "git commit -m 'added submodule'"
-end
-
-Given /^a commit with a submodule update$/ do
-  type "git checkout integration"
-  Dir.chdir "submodule" do
-    type "git checkout master"
-    type "echo 'submodule_update' > submodule_update"
-    type "git add ."
-    type "git commit -m 'update in submodule'"
-    type "git push origin HEAD"
-  end
-  type "git add ."
-  type "git commit -m 'updated submodule'"
-end
-
-Given /^a commit with a submodule url change$/ do
-  gsub_file ".gitmodules", "submodule_a.git", "submodule_b.git"
-  type "git add ."
-  type "git commit -m 'updated submodule url'"
-end
-
-Given /^I a commit a with a submodule deletion$/ do
-  type "rm .gitmodules"
-  type "rm -rf --cached submodule"
-  type "git add ."
-  type "git commit -am'removed submodule'"
-end
-
-Then /^there should be one new submodule$/ do
-  status = type "git submodule status"
-  status.should match /.[a-z0-9]{40} submodule/
-end
-
-Then /^the submodule branch should match the submodule origin branch$/ do
-  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
-  @submodule_commit = type "git submodule status"
-  @submodule_commit.should match %r( [a-z0-9]{40} submodule)
-  Dir.chdir "submodule" do
-    @submodule = Grit::Repo.new "."
-    branch = @submodule.head.name rescue nil
-    remote_branch = @submodule.remotes.find {|n| n.name == "origin/HEAD" }.commit.id[/\w+$/]
-    branch.should_not be_nil
-    remote_branch.should_not be_nil
-    branch.should == remote_branch
-    type("git rev-parse HEAD").should == type("git rev-parse origin/HEAD")
-    type("git name-rev --name-only HEAD").should == type("git name-rev --name-only origin/HEAD")
-  end
-end
-
-Then /^the submodule should be checked out$/ do
-  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
-  @submodule_commit = type "git submodule status"
-  @submodule_commit.should match %r( [a-z0-9]{40} submodule)
-end
-
-Then /^the submodule should be updated$/ do
-  @submodule_commit[/[a-z0-9]{40}/].should_not == type("git submodule status")[/[a-z0-9]{40}/]
-end
-
-Then /^the submodule url should be changed$/ do
-  Dir.chdir "submodule" do
-    remote = type "git remote show origin"
-    remote.should_not match %r(Fetch URL: #{@submodule_url}$)
-    remote.should_not match %r(Push  URL: #{@submodule_url}$)
-  end
-end
-
-Then /^the submodule should be deleted$/ do
-  Then 'the directory should not be dirty'
-  @submodule_commit = type "git submodule status"
-  @submodule_commit.should_not match /.[a-z0-9]{40} submodule/
-
-end
-
-Then /^the submodule working directory should be clean$/ do
-  Dir.chdir "submodule" do
-    type("git status").should include "working directory clean"
-  end
-end

data/features/support/grit_ext.rb

@@ -1,13 +0,0 @@
-Grit::Repo.class_eval do
-  def remote_branches(remote = "origin")
-    branches = self.remotes
-    branches.reject!  { |r| r.name !~ %r(^#{remote}/) }
-    branches.collect! { |r| r.name.split('/')[1] }
-    branches.reject!  { |b| b == "HEAD" }
-  end
-
-  def find_common_ancestor(head1, head2)
-    `git merge-base #{head1} #{head2}`.chomp
-  end
-end
-

data/features/support/io.rb

@@ -1,32 +0,0 @@
-require "open3"
-def type(command)
-  @stdout, @stderr, @status = Open3.capture3(@env, command)
-  if ENV['DEBUG']
-    puts '-' * 20
-    puts "Executing command: #{command}"
-    puts "  Status: #{@status}"
-    puts "  Stdout:\n #{@stdout}"
-    puts "  Stderr:\n #{@stderr}"
-    puts '-' * 20
-  end
-  @stdout || @stderr
-end
-
-def file_append(file_name, contents)
-  File.open(file_name, 'ab') { |file| file.puts("\n#{contents}") }
-end
-
-def file_inject(file_name, sentinel, string, before_after=:after)
-  gsub_file file_name, /(#{Regexp.escape(sentinel)})/mi do |match|
-    if before_after == :after
-      "#{match}\n#{string}"
-    else
-      "#{string}\n#{match}"
-    end
-  end
-end
-
-def gsub_file(file_name, regexp, *args, &block)
-  content = File.read(file_name).gsub(regexp, *args, &block)
-  File.open(file_name, 'wb') { |file| file.write(content) }
-end

data/features/support/podman.rb

@@ -1,153 +0,0 @@
-require "fileutils"
-require "open3"
-require "securerandom"
-require "shellwords"
-require "testcontainers"
-
-module PodmanWorld
-  class << self
-    attr_accessor :podman_available, :podman_image_built
-  end
-
-  class PrerequisiteError < StandardError; end
-
-  def ensure_podman_available
-    return if @podman_available || PodmanWorld.podman_available
-
-    raise PrerequisiteError, "podman is not installed or not on PATH" unless system("command -v podman >/dev/null 2>&1")
-
-    configure_podman_socket
-    ensure_bard_test_image
-    FileUtils.chmod(0o600, podman_ssh_key_path)
-
-    PodmanWorld.podman_available = true
-    @podman_available = true
-  end
-
-  def configure_podman_socket
-    return if ENV["DOCKER_HOST"]
-
-    podman_socket = "/run/user/#{Process.uid}/podman/podman.sock"
-    unless File.exist?(podman_socket)
-      system("systemctl --user start podman.socket 2>/dev/null || podman system service --time=0 unix://#{podman_socket} &")
-      sleep 2
-    end
-
-    raise PrerequisiteError, "Podman socket not available at #{podman_socket}" unless File.exist?(podman_socket)
-
-    ENV["DOCKER_HOST"] = "unix://#{podman_socket}"
-  end
-
-  def ensure_bard_test_image
-    return if @podman_image_built || PodmanWorld.podman_image_built
-
-    raise PrerequisiteError, "Unable to pull ubuntu:22.04 image" unless system("podman pull ubuntu:22.04 >/dev/null 2>&1")
-
-    docker_dir = File.join(ROOT, "spec/acceptance/docker")
-    dockerfile = File.join(docker_dir, "Dockerfile")
-    unless system("podman build -t bard-test-server -f #{dockerfile} #{docker_dir} 2>&1")
-      raise PrerequisiteError, "Failed to build bard test image"
-    end
-
-    PodmanWorld.podman_image_built = true
-    @podman_image_built = true
-  end
-
-  def start_podman_container
-    ensure_podman_available
-
-    @podman_container = Testcontainers::DockerContainer
-      .new("localhost/bard-test-server:latest")
-      .with_exposed_port(22)
-      .with_name("bard-test-#{SecureRandom.hex(4)}")
-      .start
-
-    @podman_ssh_port = @podman_container.mapped_port(22)
-    wait_for_ssh
-    run_ssh("mkdir -p testproject")
-    write_bard_config
-  end
-
-  def wait_for_ssh
-    30.times do
-      return if run_ssh("echo ready", quiet: true)
-      sleep 0.5
-    end
-
-    raise PrerequisiteError, "SSH in podman container did not become ready"
-  end
-
-  def write_bard_config
-    FileUtils.mkdir_p(File.join(ROOT, "tmp"))
-    @bard_config_path = File.join(ROOT, "tmp", "test_bard_#{SecureRandom.hex(4)}.rb")
-
-    File.write(@bard_config_path, <<~RUBY)
-      server :production do
-        ssh "deploy@localhost:#{@podman_ssh_port}"
-        path "testproject"
-        ssh_key "#{podman_ssh_key_path}"
-        ping false
-      end
-    RUBY
-  end
-
-  def run_ssh(command, quiet: false)
-    escaped = Shellwords.escape(command)
-    ssh_command = [
-      "ssh",
-      "-o", "StrictHostKeyChecking=no",
-      "-o", "ConnectTimeout=1",
-      "-p", @podman_ssh_port.to_s,
-      "-i", podman_ssh_key_path,
-      "deploy@localhost",
-      "--",
-      "bash",
-      "-lc",
-      escaped
-    ].join(" ")
-
-    quiet ? system("#{ssh_command} >/dev/null 2>&1") : system(ssh_command)
-  end
-
-  def run_bard_against_container(command)
-    Dir.chdir(File.join(ROOT, "tmp")) do
-      FileUtils.cp(@bard_config_path, "bard.rb")
-      @stdout, @status = Open3.capture2e(@env || {}, "bard run #{command}")
-      @stderr = ""
-      FileUtils.rm_f("bard.rb")
-    end
-  end
-
-  def podman_ssh_key_path
-    @podman_ssh_key_path ||= File.expand_path(File.join(ROOT, "spec/acceptance/docker/test_key"))
-  end
-
-  def stop_podman_container
-    FileUtils.rm_f(@bard_config_path) if @bard_config_path
-    return unless @podman_container
-
-    @podman_container.stop
-    @podman_container.remove
-  rescue StandardError => e
-    warn "Failed to cleanup podman container: #{e.message}"
-  ensure
-    @podman_container = nil
-    @podman_ssh_port = nil
-  end
-end
-
-World(PodmanWorld)
-
-Before("@podman") do
-  @env ||= {}
-
-  begin
-    start_podman_container
-  rescue PodmanWorld::PrerequisiteError => e
-    pending(e.message)
-  end
-end
-
-After("@podman") do
-  stop_podman_container
-end

data/lib/bard/ci/jenkins.rb

@@ -1,105 +0,0 @@
-require "json"
-require "bard/ci/runner"
-
-module Bard
-  class CI
-    class Jenkins < Runner
-
-      def exists?
-        `curl -s -I #{ci_host}/` =~ /\b200 OK\b/
-      end
-
-      def console
-        raw = `curl -s #{ci_host}/lastBuild/console`
-        raw[%r{<pre.*?>(.+)</pre>}m, 1]
-      end
-
-      attr_accessor :last_response
-
-      protected
-
-      def wait_until_started
-        sleep(2) until started?
-      end
-
-      def start
-        command = "curl -s -I -X POST -L '#{ci_host}/buildWithParameters?GIT_REF=#{sha}'"
-        output = `#{command}`
-        @queueId = output[%r{Location: .+/queue/item/(\d+)/}, 1].to_i
-      end
-
-      def building?
-        retry_with_backoff do
-          self.last_response = `curl -s #{ci_host}/#{job_id}/api/json?tree=building,result`
-          raise "Blank response from CI" if last_response.blank?
-        end
-        last_response.include? '"building":true'
-      end
-
-      def success?
-        last_response.include? '"result":"SUCCESS"'
-      end
-
-      def get_state_data
-        {
-          "project_name" => project_name,
-          "branch" => branch,
-          "queue_id" => @queueId,
-          "job_id" => @job_id,
-          "start_time" => @start_time,
-          "last_time_elapsed" => @last_time_elapsed
-        }
-      end
-
-      def restore_state(data)
-        @queueId = data["queue_id"]
-        @job_id = data["job_id"]
-        @start_time = data["start_time"]
-        @last_time_elapsed = data["last_time_elapsed"]
-      end
-
-      private
-
-      def get_last_time_elapsed
-        retry_with_backoff do
-          response = `curl -s #{ci_host}/lastStableBuild/api/xml`
-          raise "Blank response from CI" if response.blank?
-          response
-        end
-        response.match(/<duration>(\d+)<\/duration>/)
-        $1 ? $1.to_i / 1000 : nil
-      rescue => e
-        puts "  Warning: Could not get last build duration: #{e.message}"
-        nil
-      end
-
-      def auth
-        "botandrose:11cc2ba6ef2e43fbfbedc1f466724f6290"
-      end
-
-      def ci_host
-        "http://#{auth}@ci.botandrose.com/job/#{project_name}"
-      end
-
-      def started?
-        retry_with_backoff do
-          command = "curl -s -g '#{ci_host}/api/json?depth=1&tree=builds[queueId,number]'"
-          output = `#{command}`
-          raise "Blank response from CI" if output.blank?
-          JSON.parse(output)["builds"][0]["queueId"] == @queueId
-        end
-      end
-
-      def job_id
-        @job_id ||= begin
-          retry_with_backoff do
-            output = `curl -s -g '#{ci_host}/api/json?depth=1&tree=builds[queueId,number]'`
-            raise "Blank response from CI" if output.blank?
-            output[/"number":(\d+),"queueId":#{@queueId}\b/, 1].to_i
-          end
-        end
-      end
-    end
-  end
-end
-

data/lib/bard/ci/retryable.rb

@@ -1,27 +0,0 @@
-module Bard
-  class CI
-    module Retryable
-      MAX_RETRIES = 5
-      INITIAL_DELAY = 1
-
-      def retry_with_backoff(max_retries: MAX_RETRIES)
-        retries = 0
-        delay = INITIAL_DELAY
-
-        begin
-          yield
-        rescue => e
-          if retries < max_retries
-            retries += 1
-            puts "  Network error (attempt #{retries}/#{max_retries}): #{e.message}. Retrying in #{delay}s..."
-            sleep(delay)
-            delay *= 2
-            retry
-          else
-            raise "Network error after #{max_retries} attempts: #{e.message}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bard/ci.rb

@@ -1,50 +0,0 @@
-require "forwardable"
-
-module Bard
-  class CI
-    def initialize project_name, branch, local: false
-      @project_name = project_name
-      @branch = branch
-      @local = !!local
-    end
-
-    extend Forwardable
-    delegate [:run, :resume, :exists?, :console, :status] => :runner
-
-    private
-
-    def local?
-      @local
-    end
-
-    def github_actions?
-      File.exist?(".github/workflows/ci.yml")
-    end
-
-    def jenkins?
-      !local? && !github_actions?
-    end
-
-    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 local?
-        require_relative "./ci/local"
-        Local
-      elsif github_actions?
-        require_relative "./ci/github_actions"
-        GithubActions
-      elsif jenkins?
-        require_relative "./ci/jenkins"
-        Jenkins
-      end
-    end
-  end
-end
-

data/lib/bard/cli/ci.rb

@@ -1,66 +0,0 @@
-require "bard/ci"
-require "bard/git"
-
-module Bard::CLI::CI
-  def self.included mod
-    mod.class_eval do
-
-      option :"local-ci", type: :boolean
-      option :status, type: :boolean
-      option :resume, type: :boolean
-      desc "ci [branch=HEAD]", "runs ci against BRANCH"
-      def ci branch=Bard::Git.current_branch
-        ci = Bard::CI.new(project_name, branch, local: options["local-ci"])
-        if ci.exists?
-          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
-
-        else
-          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
-      end
-
-    end
-  end
-end
-

data/lib/bard/cli/command.rb

@@ -1,26 +0,0 @@
-require "delegate"
-
-class Bard::CLI::Command < SimpleDelegator
-  def self.desc command, description
-    @command = command
-    @method = command.split(" ").first.to_sym
-    @description = description
-  end
-
-  def self.option *args, **kwargs
-    @option_args = args
-    @option_kwargs = kwargs
-  end
-
-  def self.setup cli
-    cli.desc @command, @description
-    cli.option *@option_args, **@option_kwargs if @option_args || @option_kwargs
-    # put in local variables so next block can capture it
-    command_class = self
-    method = @method
-    cli.define_method method do |*args|
-      command = command_class.new(self)
-      command.send method, *args
-    end
-  end
-end

data/lib/bard/cli/data.rb

@@ -1,45 +0,0 @@
-require "bard/command"
-
-module Bard::CLI::Data
-  def self.included mod
-    mod.class_eval do
-
-      desc "data --from=production --to=local", "copy database and assets from from to to"
-      option :from, default: "production"
-      option :to, default: "local"
-      def data
-        from = config[options[:from]]
-        to = config[options[:to]]
-
-        if to.key == :production
-          url = to.ping.first
-          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}..."
-        from.copy_file "db/data.sql.gz", 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}..."
-          from.copy_dir path, to: to, verbose: true
-        end
-      rescue Bard::Command::Error => e
-        puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
-        exit 1
-      end
-
-    end
-  end
-end
-