bard 2.0.0.beta → 2.0.1

data/lib/bard/server.rb

@@ -1,117 +0,0 @@
-require "uri"
-require "bard/command"
-require "bard/copy"
-
-module Bard
-  class Server < Struct.new(:project_name, :key, :ssh, :path, :ping, :gateway, :ssh_key, :env, :github_pages)
-    def self.define project_name, key, &block
-      new(project_name, key).tap do |server|
-        server.instance_eval &block
-      end
-    end
-
-    def self.setting *fields
-      fields.each do |field|
-        define_method field do |*args|
-          if args.length == 1
-            send :"#{field}=", args.first
-          elsif args.length == 0
-            super()
-          else
-            raise ArgumentError
-          end
-        end
-      end
-    end
-
-    setting :ssh, :path, :ping, :gateway, :ssh_key, :env, :github_pages
-
-    def ping(*args)
-      if args.length == 0
-        (super() || [nil]).map(&method(:normalize_ping)).flatten
-      else
-        self.ping = args
-      end
-    end
-
-    private def normalize_ping value
-      return [] if value == false
-      normalized = "https://#{ssh_uri.host}" # default if none specified
-      if value =~ %r{^/}
-        normalized += value
-      elsif value.to_s.length > 0
-        normalized = value
-      end
-      if normalized !~ /^http/
-        normalized = "https://#{normalized}"
-      end
-      normalized
-    end
-
-    def path(*args)
-      if args.length == 1
-        self.path = args.first
-      elsif args.length == 0
-        super() || project_name
-      else
-        raise ArgumentError
-      end
-    end
-
-    def ssh_uri which=:ssh
-      value = send(which)
-      URI("ssh://#{value}")
-    end
-
-    def scp_uri file_path=nil
-      ssh_uri.dup.tap do |uri|
-        uri.scheme = "scp"
-        uri.path = "/#{path}"
-        uri.path += "/#{file_path}" if file_path
-      end
-    end
-
-    def rsync_uri file_path=nil
-      str = ssh_uri.dup.tap do |uri|
-        uri.send :set_scheme, nil
-        uri.send :set_port, nil
-      end.to_s[2..]
-      str += ":#{path}"
-      str += "/#{file_path}" if file_path
-      str
-    end
-
-    def with(attrs)
-      dup.tap do |s|
-        attrs.each do |key, value|
-          s.send key, value
-        end
-      end
-    end
-
-    def to_sym
-      key
-    end
-
-    def run! command, home: false, verbose: false, quiet: false
-      Bard::Command.run! command, on: self, home:, verbose:, quiet:
-    end
-
-    def run command, home: false, verbose: false, quiet: false
-      Bard::Command.run command, on: self, home:, verbose:, quiet:
-    end
-
-    def exec! command, home: false
-      Bard::Command.exec! command, on: self, home:
-    end
-
-    def copy_file path, to:, verbose: false
-      Bard::Copy.file path, from: self, to:, verbose:
-    end
-
-    def copy_dir path, to:, verbose: false
-      Bard::Copy.dir path, from: self, to:, verbose:
-    end
-  end
-end
-

data/spec/bard/cli/command_spec.rb

@@ -1,50 +0,0 @@
-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/new_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/new"
-
-describe Bard::CLI::New do
-  let(:new_cli) { Bard::CLI::New.new(double("cli")) }
-
-  before do
-    allow(new_cli).to receive(:puts)
-    allow(new_cli).to receive(:exit)
-    allow(new_cli).to receive(:run!)
-    allow(new_cli).to receive(:green).and_return("")
-    allow(new_cli).to receive(:red).and_return("")
-    allow(new_cli).to receive(:yellow).and_return("")
-    allow(File).to receive(:read).and_return("master_key_content")
-  end
-
-  describe "#new" do
-    context "with invalid project name" do
-      before do
-        allow(new_cli).to receive(:create_project)
-        allow(new_cli).to receive(:push_to_github)
-        allow(new_cli).to receive(:stage)
-      end
-
-      it "should reject names starting with uppercase" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("InvalidProject")
-      end
-
-      it "should reject names with special characters" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("invalid-project")
-      end
-
-      it "should reject names starting with numbers" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("1invalidproject")
-      end
-    end
-  end
-
-  describe "#ruby_version" do
-    it "returns the ruby version" do
-      expect(new_cli.send(:ruby_version)).to eq("ruby-3.4.2")
-    end
-  end
-
-  describe "#template_path" do
-    it "returns the path to the rails template" do
-      expect(new_cli.send(:template_path)).to match(/new_rails_template\.rb$/)
-    end
-  end
-
-  describe "#install_and_extract_version" do
-    it "correctly installs a gem and extracts its version", skip: !!ENV["CI"] do
-      cmd = new_cli.send :build_bash_env do
-        <<~SH
-          #{new_cli.send(:build_gem_install, "bundler", "~> 2.0")}
-          echo ${GEM_VERSION}
-        SH
-      end
-      result = `#{cmd}`.strip
-      expect(result).to match(/^2\.\d+\.\d+/)
-    end
-  end
-end

data/spec/bard/cli/provision_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/provision"
-
-describe Bard::CLI::Provision do
-  let(:config) { { production: double("production", ssh: "user@example.com") } }
-  let(:provision_cli) { Bard::CLI::Provision.new(double("cli")) }
-
-  before do
-    allow(provision_cli).to receive(:config).and_return(config)
-    allow(provision_cli).to receive(:options).and_return({ steps: ["SSH", "User"] })
-  end
-
-  describe "STEPS constant" do
-    it "defines the provisioning steps" do
-      expect(Bard::CLI::Provision::STEPS).to include("SSH", "User", "Apt", "MySQL", "Deploy")
-      expect(Bard::CLI::Provision::STEPS).to be_a(Array)
-    end
-  end
-
-  describe "#provision" do
-    it "should run provision steps" do
-      expect(Bard::Provision).to receive(:const_get).with("SSH").and_return(double("ssh_step", call: true))
-      expect(Bard::Provision).to receive(:const_get).with("User").and_return(double("user_step", call: true))
-
-      provision_cli.provision
-    end
-
-    it "should use production ssh by default" do
-      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
-
-      provision_cli.provision
-    end
-
-    it "should accept custom ssh_url" do
-      custom_ssh = "root@newserver.com"
-      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
-
-      provision_cli.provision(custom_ssh)
-    end
-  end
-end

data/spec/bard/github_pages_spec.rb

@@ -1,143 +0,0 @@
-require "spec_helper"
-require "bard/github_pages"
-
-describe Bard::GithubPages do
-  let(:server) { double("server", ping: ["https://example.com"]) }
-  let(:github_pages) { Bard::GithubPages.new(double) }
-
-  before do
-    allow(Bard::Git).to receive(:sha_of).and_return("abc123")
-    allow(Bard::Git).to receive(:current_branch).and_return("main")
-    allow(github_pages).to receive(:system)
-    allow(github_pages).to receive(:run!)
-    allow(github_pages).to receive(:puts)
-  end
-
-  describe "#deploy" do
-    it "performs the deployment steps" do
-      expect(github_pages).to receive(:build_site)
-      expect(github_pages).to receive(:create_tree_from_build).and_return("tree123")
-      expect(github_pages).to receive(:create_commit).with("tree123").and_return("commit123")
-      expect(github_pages).to receive(:commit_and_push).with("commit123")
-
-      github_pages.deploy(server)
-    end
-
-    it "sets instance variables" do
-      allow(github_pages).to receive(:build_site)
-      allow(github_pages).to receive(:create_tree_from_build).and_return("tree123")
-      allow(github_pages).to receive(:create_commit).and_return("commit123")
-      allow(github_pages).to receive(:commit_and_push)
-
-      github_pages.deploy(server)
-
-      expect(github_pages.instance_variable_get(:@sha)).to eq("abc123")
-      expect(github_pages.instance_variable_get(:@build_dir)).to eq("tmp/github-build-abc123")
-      expect(github_pages.instance_variable_get(:@branch)).to eq("gh-pages")
-      expect(github_pages.instance_variable_get(:@domain)).to eq("example.com")
-    end
-  end
-
-  describe "#build_site" do
-    it "uses the locked port" do
-      github_pages.instance_variable_set(:@sha, "abc123")
-      github_pages.instance_variable_set(:@build_dir, "tmp/github-build-abc123")
-      github_pages.instance_variable_set(:@domain, "example.com")
-
-      allow(github_pages).to receive(:with_locked_port).and_yield(3005)
-
-      expect(github_pages).to receive(:run!).with(satisfy { |cmd|
-        cmd.include?("rails s -p 3005") && cmd.include?("http://localhost:3005")
-      }).ordered
-
-      expect(github_pages).to receive(:run!).with(include("kill")).ordered
-
-      github_pages.send(:build_site)
-    end
-  end
-
-  describe "#with_locked_port" do
-    let(:file_mock) { double("file", close: true) }
-
-    before do
-      allow(File).to receive(:open).and_return(file_mock)
-    end
-
-    it "yields the first available port" do
-      allow(file_mock).to receive(:flock).and_return(true)
-      
-      expect(File).to receive(:open).with("/tmp/bard_github_pages_3000.lock", anything, anything)
-      
-      yielded_port = nil
-      github_pages.send(:with_locked_port) { |p| yielded_port = p }
-      expect(yielded_port).to eq(3000)
-    end
-
-    it "retries if the first port is locked" do
-      # 1. Try port 3000
-      expect(File).to receive(:open).with("/tmp/bard_github_pages_3000.lock", anything, anything).ordered
-      expect(file_mock).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(false).ordered
-      expect(file_mock).to receive(:close).ordered
-
-      # 2. Try port 3001
-      expect(File).to receive(:open).with("/tmp/bard_github_pages_3001.lock", anything, anything).ordered
-      expect(file_mock).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(true).ordered
-      
-      # 3. Cleanup after yielding
-      expect(file_mock).to receive(:flock).with(File::LOCK_UN).ordered
-      expect(file_mock).to receive(:close).ordered
-
-      yielded_port = nil
-      github_pages.send(:with_locked_port) { |p| yielded_port = p }
-      expect(yielded_port).to eq(3001)
-    end
-
-    it "raises an error if no ports are available" do
-      allow(file_mock).to receive(:flock).and_return(false)
-      
-      expect {
-        github_pages.send(:with_locked_port) {}
-      }.to raise_error(/Could not find an available port/)
-    end
-  end
-
-  describe "#get_parent_commit" do
-    it "returns the sha of the gh-pages branch" do
-      github_pages.instance_variable_set(:@branch, "gh-pages")
-      expect(Bard::Git).to receive(:sha_of).with("gh-pages^{commit}")
-      github_pages.send(:get_parent_commit)
-    end
-  end
-
-  describe "#branch_exists?" do
-    it "checks if branch exists using git show-ref" do
-      github_pages.instance_variable_set(:@branch, "gh-pages")
-      expect(github_pages).to receive(:system).with("git show-ref --verify --quiet refs/heads/gh-pages")
-      github_pages.send(:branch_exists?)
-    end
-  end
-
-  describe "#commit_and_push" do
-    before do
-      github_pages.instance_variable_set(:@branch, "gh-pages")
-    end
-
-    context "when branch exists" do
-      it "updates the ref and pushes" do
-        allow(github_pages).to receive(:branch_exists?).and_return(true)
-        expect(github_pages).to receive(:run!).with("git update-ref refs/heads/gh-pages commit123")
-        expect(github_pages).to receive(:run!).with("git push -f origin gh-pages:refs/heads/gh-pages")
-        github_pages.send(:commit_and_push, "commit123")
-      end
-    end
-
-    context "when branch doesn't exist" do
-      it "creates the branch and pushes" do
-        allow(github_pages).to receive(:branch_exists?).and_return(false)
-        expect(github_pages).to receive(:run!).with("git branch gh-pages commit123")
-        expect(github_pages).to receive(:run!).with("git push -f origin gh-pages:refs/heads/gh-pages")
-        github_pages.send(:commit_and_push, "commit123")
-      end
-    end
-  end
-end

data/spec/bard/provision/app_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/app"
-
-describe Bard::Provision::App do
-  let(:config) { { production: double("production") } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:app) { Bard::Provision::App.new(config, ssh_url) }
-
-  before do
-    allow(app).to receive(:provision_server).and_return(provision_server)
-    allow(app).to receive(:print)
-    allow(app).to receive(:puts)
-  end
-
-  describe "#call" do
-    it "runs bin/setup on the server" do
-      expect(provision_server).to receive(:run!).with("bin/setup")
-
-      app.call
-    end
-
-    it "prints status messages" do
-      allow(provision_server).to receive(:run!)
-
-      expect(app).to receive(:print).with("App:")
-      expect(app).to receive(:puts).with(" ✓")
-
-      app.call
-    end
-  end
-end

data/spec/bard/provision/apt_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/apt"
-
-describe Bard::Provision::Apt do
-  let(:config) { { production: double("production") } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:apt) { Bard::Provision::Apt.new(config, ssh_url) }
-
-  before do
-    allow(apt).to receive(:provision_server).and_return(provision_server)
-    allow(apt).to receive(:print)
-    allow(apt).to receive(:puts)
-  end
-
-  describe "#call" do
-    it "updates and installs packages on the server" do
-      expected_commands = [
-        %(echo "\\$nrconf{restart} = \\"a\\";" | sudo tee /etc/needrestart/conf.d/90-autorestart.conf),
-        "sudo apt-get update -y",
-        "sudo apt-get upgrade -y",
-        "sudo apt-get install -y curl"
-      ].join("; ")
-
-      expect(provision_server).to receive(:run!).with(expected_commands, home: true)
-
-      apt.call
-    end
-
-    it "prints status messages" do
-      allow(provision_server).to receive(:run!)
-      expect(apt).to receive(:print).with("Apt:")
-      expect(apt).to receive(:puts).with(" ✓")
-
-      apt.call
-    end
-  end
-end

data/spec/bard/provision/authorizedkeys_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/authorizedkeys"
-
-describe Bard::Provision::AuthorizedKeys do
-  let(:config) { { production: double("production") } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:authorized_keys) { Bard::Provision::AuthorizedKeys.new(config, ssh_url) }
-
-  before do
-    allow(authorized_keys).to receive(:provision_server).and_return(provision_server)
-    allow(authorized_keys).to receive(:print)
-    allow(authorized_keys).to receive(:puts)
-  end
-
-  describe "#call" do
-    it "adds authorized keys to the server" do
-      expect(provision_server).to receive(:run!).at_least(:once).with(/grep -F -q/, home: true)
-
-      authorized_keys.call
-    end
-
-    it "prints status messages" do
-      allow(provision_server).to receive(:run!)
-      expect(authorized_keys).to receive(:print).with("Authorized Keys:")
-      expect(authorized_keys).to receive(:puts).with(" ✓")
-
-      authorized_keys.call
-    end
-  end
-
-  describe "KEYS constant" do
-    it "should have predefined SSH keys" do
-      expect(Bard::Provision::AuthorizedKeys::KEYS).to be_a(Hash)
-      expect(Bard::Provision::AuthorizedKeys::KEYS).not_to be_empty
-      expect(Bard::Provision::AuthorizedKeys::KEYS.keys.first).to match(/@/)
-    end
-  end
-end

data/spec/bard/provision/data_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/data"
-
-describe Bard::Provision::Data do
-  let(:server) { double("server", key: :production) }
-  let(:config) { double("config", data: ["uploads", "assets"]) }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:data_provisioner) { Bard::Provision::Data.new(config, ssh_url) }
-
-  before do
-    allow(data_provisioner).to receive(:server).and_return(server)
-    allow(data_provisioner).to receive(:config).and_return(config)
-    allow(data_provisioner).to receive(:provision_server).and_return(provision_server)
-    allow(data_provisioner).to receive(:print)
-    allow(data_provisioner).to receive(:puts)
-  end
-
-  describe "#call" do
-    it "dumps, transfers, and loads database data" do
-      expect(server).to receive(:run!).with("bin/rake db:dump")
-      expect(server).to receive(:copy_file).with("db/data.sql.gz", to: provision_server, verbose: false)
-      expect(provision_server).to receive(:run!).with("bin/rake db:load")
-
-      allow(server).to receive(:copy_dir)
-
-      data_provisioner.call
-    end
-
-    it "synchronizes configured data directories" do
-      allow(server).to receive(:run!)
-      allow(server).to receive(:copy_file)
-      allow(provision_server).to receive(:run!)
-
-      expect(server).to receive(:copy_dir).with("uploads", to: provision_server, verbose: false)
-      expect(server).to receive(:copy_dir).with("assets", to: provision_server, verbose: false)
-
-      data_provisioner.call
-    end
-
-    it "prints status messages" do
-      allow(server).to receive(:run!)
-      allow(server).to receive(:copy_file)
-      allow(server).to receive(:copy_dir)
-      allow(provision_server).to receive(:run!)
-
-      expect(data_provisioner).to receive(:print).with("Data:")
-      expect(data_provisioner).to receive(:puts).with(" ✓")
-
-      data_provisioner.call
-    end
-  end
-end

data/spec/bard/provision/deploy_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/deploy"
-
-describe Bard::Provision::Deploy do
-  let(:config) { { production: double("production") } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:deploy) { Bard::Provision::Deploy.new(config, ssh_url) }
-
-  before do
-    allow(deploy).to receive(:provision_server).and_return(provision_server)
-    allow(deploy).to receive(:print)
-    allow(deploy).to receive(:puts)
-  end
-
-  describe "#call" do
-    it "runs bin/setup on the server" do
-      expect(provision_server).to receive(:run!).with("bin/setup")
-
-      deploy.call
-    end
-
-    it "prints status messages" do
-      allow(provision_server).to receive(:run!)
-
-      expect(deploy).to receive(:print).with("Deploy:")
-      expect(deploy).to receive(:puts).with(" ✓")
-
-      deploy.call
-    end
-  end
-end

data/spec/bard/provision/http_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/http"
-
-describe Bard::Provision::HTTP do
-  let(:server) { double("server", ping: ["https://example.com"]) }
-  let(:config) { { production: server } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:http) { Bard::Provision::HTTP.new(config, ssh_url) }
-
-  before do
-    allow(http).to receive(:server).and_return(server)
-    allow(http).to receive(:provision_server).and_return(provision_server)
-    allow(provision_server).to receive_message_chain(:ssh_uri, :host).and_return("192.168.1.100")
-    allow(http).to receive(:print)
-    allow(http).to receive(:puts)
-    allow(http).to receive(:system)
-  end
-
-  describe "#call" do
-    context "when HTTP test passes" do
-      it "shows success message" do
-        allow(http).to receive(:system).and_return(true)
-
-        expect(http).to receive(:puts).with(" ✓")
-
-        http.call
-      end
-    end
-
-    context "when HTTP test fails" do
-      it "shows failure message" do
-        allow(http).to receive(:system).and_return(false)
-
-        expect(http).to receive(:puts).with(" !!! not serving a rails app from 192.168.1.100")
-
-        http.call
-      end
-    end
-
-    it "prints status header" do
-      allow(http).to receive(:system).and_return(true)
-
-      expect(http).to receive(:print).with("HTTP:")
-
-      http.call
-    end
-
-    it "tests the correct URL" do
-      expected_command = /curl -s --resolve example\.com:80:192\.168\.1\.100 http:\/\/example\.com/
-      expect(http).to receive(:system).with(expected_command)
-
-      http.call
-    end
-  end
-end