bard 1.9.6 → 2.0.0

data/lib/bard/target.rb

@@ -1,23 +1,14 @@
-require "uri"
 require "bard/command"
-require "bard/copy"
-require "bard/deploy_strategy"
-require "bard/deprecation"
 
 module Bard
   class Target
     attr_reader :key, :config
-    attr_accessor :server
 
     def initialize(key, config)
       @key = key
       @config = config
       @capabilities = []
-      @ping_urls = []
-      @strategy_options_hash = {}
-      @deploy_strategy = nil
       @path = nil
-      @server = nil
     end
 
     # Capability tracking
@@ -31,234 +22,25 @@ module Bard
 
     def require_capability!(capability)
       unless has_capability?(capability)
-        error_message = case capability
-        when :ssh
-          "SSH not configured for this target"
-        when :ping
-          "Ping URL not configured for this target"
-        else
-          "#{capability} capability not configured for this target"
-        end
-        raise error_message
+        raise "#{capability} capability not configured for this target"
       end
     end
 
-    # SSH configuration
-    def ssh(uri_or_false = nil, **options)
-      if uri_or_false.nil?
-        # Getter - return false if explicitly disabled, otherwise return server
-        return @ssh_disabled ? false : @server
-      elsif uri_or_false == false
-        # Disable SSH
-        @server = nil
-        @ssh_disabled = true
-        @capabilities.delete(:ssh)
-      else
-        # Enable SSH
-        require "bard/ssh_server"
-        @server = SSHServer.new(uri_or_false, **options)
-        @path = options[:path] if options[:path]
-        @gateway = options[:gateway] if options[:gateway]
-        @ssh_key = options[:ssh_key] if options[:ssh_key]
-        @env = options[:env] if options[:env]
-        enable_capability(:ssh)
-
-        # Set SSH as default deployment strategy if none set
-        @deploy_strategy ||= :ssh
-
-        # Auto-configure ping from hostname
-        hostname = @server.hostname
-        ping("https://#{hostname}") if hostname
-      end
-    end
-
-    def ssh_uri
-      server&.ssh_uri
-    end
-
-    # Path configuration
-    def path(new_path = nil)
-      if new_path
-        Deprecation.warn "Separate `path` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", path: \"#{new_path}\"` (will be removed in v2.0)"
-        @path = new_path
-      else
-        @path || config.project_name
-      end
+    def path
+      @path || config.project_name
     end
 
-    # Deprecated separate setter methods - use ssh(..., option: value) instead
-    def gateway(value = nil)
-      if value
-        Deprecation.warn "Separate `gateway` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", gateway: \"#{value}\"` (will be removed in v2.0)"
-        @gateway = value
-      else
-        @gateway
-      end
-    end
-
-    def ssh_key(value = nil)
-      if value
-        Deprecation.warn "Separate `ssh_key` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", ssh_key: \"#{value}\"` (will be removed in v2.0)"
-        @ssh_key = value
-      else
-        @ssh_key
-      end
-    end
-
-    def env(value = nil)
-      if value
-        Deprecation.warn "Separate `env` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", env: \"#{value}\"` (will be removed in v2.0)"
-        @env = value
-      else
-        @env
-      end
-    end
-
-    # Ping configuration
-    def ping(*urls)
-      if urls.empty?
-        # Getter - normalize URLs like Server does
-        @ping_urls.map { |url| normalize_ping(url) }
-      elsif urls.first == false
-        # Disable ping
-        @ping_urls = []
-        @capabilities.delete(:ping)
-      else
-        # Enable ping
-        @ping_urls = urls.flatten
-        enable_capability(:ping)
-      end
-    end
-
-    def ping_urls
-      @ping_urls
-    end
-
-    def ping!
-      require_capability!(:ping)
-      require "bard/ping"
-      failed_urls = Bard::Ping.call(self)
-      if failed_urls.any?
-        raise "Ping failed for: #{failed_urls.join(', ')}"
-      end
-    end
-
-    def open
-      require_capability!(:ping)
-      system "open #{ping_urls.first}"
-    end
-
-    # Deploy strategy
-    attr_reader :deploy_strategy
-
-    # GitHub Pages deployment configuration
-    def github_pages(url = nil)
-      if url.nil?
-        # Getter
-        @github_pages_url
-      else
-        # Setter
-        @deploy_strategy = :github_pages
-        @github_pages_url = url
-        enable_capability(:github_pages)
-      end
-    end
-
-    # Deprecated strategy configuration methods
-    def strategy(name)
-      Deprecation.warn "`strategy` is deprecated; use the strategy method directly, e.g., `#{name} \"url\"` instead of `strategy :#{name}` (will be removed in v2.0)"
-      @deploy_strategy = name
-    end
-
-    def option(key, value)
-      Deprecation.warn "`option` is deprecated; pass options as keyword arguments to the strategy method, e.g., `jets \"url\", #{key}: #{value.inspect}` (will be removed in v2.0)"
-      @strategy_options_hash[@deploy_strategy] ||= {}
-      @strategy_options_hash[@deploy_strategy][key] = value
-    end
-
-    def strategy_options(strategy_name)
-      @strategy_options_hash[strategy_name] || {}
-    end
-
-    def deploy_strategy_instance
-      raise "No deployment strategy configured for target #{key}" unless @deploy_strategy
-
-      strategy_class = DeployStrategy[@deploy_strategy]
-      raise "Unknown deployment strategy: #{@deploy_strategy}" unless strategy_class
-
-      strategy_class.new(self)
-    end
-
-    # Dynamic strategy DSL via method_missing
-    def method_missing(method, *args, **kwargs, &block)
-      strategy_class = DeployStrategy[method]
-
-      if strategy_class
-        # This is a deployment strategy
-        @deploy_strategy = method
-
-        # Store options
-        @strategy_options_hash[method] = kwargs
-
-        # Auto-configure ping if first arg is a URL
-        if args.first && args.first.to_s =~ /^https?:\/\//
-          ping(args.first)
-        end
-
-        # Call the strategy's initializer if it wants to configure the target
-        # (This will be handled by the strategy class)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      DeployStrategy[method] || super
-    end
-
-    # Remote command execution
     def run!(command, home: false, verbose: false, quiet: false, capture: false)
-      require_capability!(:ssh)
-      result = Command.run!(command, on: self, home: home, verbose: verbose, quiet: quiet)
+      result = Command.run!(command, verbose:, quiet:)
       result if capture
     end
 
     def run(command, home: false, verbose: false, quiet: false)
-      require_capability!(:ssh)
-      Command.run(command, on: self, home: home, verbose: verbose, quiet: quiet)
+      Command.run(command, verbose:, quiet:)
     end
 
     def exec!(command, home: false)
-      require_capability!(:ssh)
-      Command.exec!(command, on: self, home: home)
-    end
-
-    # File transfer
-    def copy_file(path, to:, verbose: false)
-      require_capability!(:ssh)
-      to.require_capability!(:ssh) if to.respond_to?(:require_capability!)
-      Copy.file(path, from: self, to: to, verbose: verbose)
-    end
-
-    def copy_dir(path, to:, verbose: false)
-      require_capability!(:ssh)
-      to.require_capability!(:ssh) if to.respond_to?(:require_capability!)
-      Copy.dir(path, from: self, to: to, verbose: verbose)
-    end
-
-    # URI methods for compatibility
-    def scp_uri(file_path = nil)
-      full_path = "/#{path}"
-      full_path += "/#{file_path}" if file_path
-      URI::Generic.build(scheme: "scp", userinfo: server.user, host: server.host, port: server.port.to_i, path: full_path)
-    end
-
-    def rsync_uri(file_path = nil)
-      uri = ssh_uri
-      str = "#{uri.user}@#{uri.host}"
-      str += ":#{path}"
-      str += "/#{file_path}" if file_path
-      str
+      Command.exec!(command)
     end
 
     # Utility methods
@@ -278,13 +60,22 @@ module Bard
       end
     end
 
-    private
+    def ==(other)
+      return false unless other.is_a?(Bard::Target)
+      comparable_state == other.comparable_state
+    end
+    alias_method :eql?, :==
+
+    def hash
+      comparable_state.hash
+    end
+
+    protected
 
-    def normalize_ping(value)
-      return nil if value == false || value.nil?
-      normalized = value.to_s
-      normalized = "https://#{normalized}" unless normalized.start_with?("http")
-      normalized
+    def comparable_state
+      (instance_variables - [:@key, :@config]).sort.map do |ivar|
+        [ivar, instance_variable_get(ivar)]
+      end
     end
   end
 end

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.9.6"
+  VERSION = "2.0.0"
 end
 

data/lib/bard.rb

@@ -1,3 +1 @@
-module Bard
-end
-
+require "bard/cli"

data/spec/acceptance/docker/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 # Prevent interactive prompts
 ENV DEBIAN_FRONTEND=noninteractive

data/spec/bard/capability_spec.rb

@@ -1,5 +1,7 @@
 require "spec_helper"
 require "bard/target"
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/ping/target_methods"
 
 describe "Capability System" do
   let(:config) { double("config", project_name: "testapp") }
@@ -13,9 +15,9 @@ describe "Capability System" do
 
     it "can enable multiple capabilities" do
       target.enable_capability(:ssh)
-      target.enable_capability(:ping)
+      target.enable_capability(:url)
       expect(target.has_capability?(:ssh)).to be true
-      expect(target.has_capability?(:ping)).to be true
+      expect(target.has_capability?(:url)).to be true
     end
   end
 
@@ -38,59 +40,15 @@ describe "Capability System" do
 
     it "raises an error if capability is not enabled" do
       expect { target.require_capability!(:ssh) }
-        .to raise_error(/SSH not configured for this target/)
-    end
-
-    it "provides custom error message for ping capability" do
-      expect { target.require_capability!(:ping) }
-        .to raise_error(/Ping URL not configured for this target/)
-    end
-
-    it "provides generic error message for unknown capabilities" do
-      expect { target.require_capability!(:unknown) }
-        .to raise_error(/unknown capability not configured for this target/)
+        .to raise_error(/ssh capability not configured for this target/)
     end
   end
 
   describe "capability dependency checking" do
-    context "SSH-dependent methods" do
-      it "run! requires SSH capability" do
-        expect { target.run!("ls") }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "run requires SSH capability" do
-        expect { target.run("ls") }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "exec! requires SSH capability" do
-        expect { target.exec!("ls") }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "copy_file requires SSH capability" do
-        other_target = Bard::Target.new(:staging, config)
-        expect { target.copy_file("test.txt", to: other_target) }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "copy_dir requires SSH capability" do
-        other_target = Bard::Target.new(:staging, config)
-        expect { target.copy_dir("test/", to: other_target) }
-          .to raise_error(/SSH not configured/)
-      end
-    end
-
-    context "Ping-dependent methods" do
-      it "ping! requires ping capability" do
+    context "URL-dependent methods" do
+      it "ping! requires url capability" do
         expect { target.ping! }
-          .to raise_error(/Ping URL not configured/)
-      end
-
-      it "open requires ping capability" do
-        expect { target.open }
-          .to raise_error(/Ping URL not configured/)
+          .to raise_error(/url capability not configured/)
       end
     end
   end

data/spec/bard/ci/github_actions_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "bard/ci/github_actions"
+require "bard/plugins/deploy/ci/github_actions"
 
 BASE_URL = "https://api.github.com/repos/botandrosedesign/metrc"
 

data/spec/bard/ci/jenkins_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "bard/ci/jenkins"
+require "bard/plugins/deploy/ci/jenkins"
 
 RSpec.describe Bard::CI::Jenkins do
   let(:jenkins) { described_class.new("test-project", "master", "abc123") }

data/spec/bard/ci/runner_spec.rb

@@ -1,4 +1,4 @@
-require "bard/ci/runner"
+require "bard/plugins/deploy/ci/runner"
 
 RSpec.describe Bard::CI::Runner do
   describe ".runners" do
@@ -9,8 +9,8 @@ RSpec.describe Bard::CI::Runner do
 
   describe ".[]" do
     before do
-      require "bard/ci/local"
-      require "bard/ci/github_actions"
+      require "bard/plugins/deploy/ci/local"
+      require "bard/plugins/deploy/ci/github_actions"
     end
 
     it "looks up runners by name" do

data/spec/bard/ci_spec.rb

@@ -1,4 +1,4 @@
-require "bard/ci"
+require "bard/plugins/deploy/ci"
 
 describe Bard::CI do
   subject { described_class.new("tracker", "master") }

data/spec/bard/cli/ci_spec.rb

@@ -1,33 +1,14 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/ci"
-require "thor"
 require "ostruct"
 
-class TestCICLI < Thor
-  include Bard::CLI::CI
-
-  attr_reader :options
-
-  def initialize
-    super
-    @options = {}
-  end
-
-  def project_name
-    "test_project"
-  end
-
-  def config
-    @config ||= OpenStruct.new(ci: nil)
-  end
-end
-
-describe Bard::CLI::CI do
-  let(:cli) { TestCICLI.new }
+describe "bard ci" do
+  let(:cli) { Bard::CLI.new }
   let(:ci_runner) { double("ci_runner") }
 
   before do
+    allow(cli).to receive(:config).and_return(OpenStruct.new(ci: nil))
+    allow(cli).to receive(:project_name).and_return("test_project")
     allow(cli).to receive(:puts)
     allow(cli).to receive(:print)
     allow(cli).to receive(:exit)

data/spec/bard/cli/data_spec.rb

@@ -1,35 +1,15 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/data"
 
-require "thor"
-
-require "term/ansicolor"
-
-class TestCLI < Thor
-  include Bard::CLI::Data
-  include Term::ANSIColor
-
-  attr_reader :config
-
-  def initialize
-    @config = {}
-  end
-
-  def options
-    {}
-  end
-end
-
-describe Bard::CLI::Data do
-  let(:cli) { TestCLI.new }
+describe "bard data" do
+  let(:cli) { Bard::CLI.new }
 
   it "should have a data command" do
     expect(cli).to respond_to(:data)
   end
 
   context "data" do
-    let(:from) { double("from", key: :production, run!: nil, copy_file: nil, copy_dir: nil) }
+    let(:from) { double("from", key: :production, run!: nil, require_capability!: nil) }
     let(:to) { double("to", key: :local, run!: nil) }
 
     let(:config) do
@@ -42,17 +22,18 @@ describe Bard::CLI::Data do
     before do
       allow(cli).to receive(:config).and_return(config)
       allow(cli).to receive(:options).and_return({from: "production", to: "local"})
+      allow(cli).to receive(:puts)
     end
 
     it "should run the data command" do
       expect(from).to receive(:run!).with("bin/rake db:dump")
-      expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+      expect(Bard::Copy).to receive(:file).with("db/data.sql.gz", from: from, to: to, verbose: true)
       expect(to).to receive(:run!).with("bin/rake db:load")
       cli.data
     end
 
     context "pushing to production" do
-      let(:to) { double("to", key: :production, ping: ["https://example.com"]) }
+      let(:to) { double("to", key: :production, url: "https://example.com", run!: nil, require_capability!: nil) }
 
       before do
         allow(cli).to receive(:options).and_return({from: "local", to: "production"})
@@ -68,7 +49,7 @@ describe Bard::CLI::Data do
       it "should allow pushing to production if the user confirms" do
         expect(cli).to receive(:ask).and_return("https://example.com")
         expect(from).to receive(:run!).with("bin/rake db:dump")
-        expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+        expect(Bard::Copy).to receive(:file).with("db/data.sql.gz", from: from, to: to, verbose: true)
         expect(to).to receive(:run!).with("bin/rake db:load")
         cli.data
       end