bard 1.7.2 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 674739cf14af03776e5f892cb47463decdc1a3a6a493ee4e62dc3528a4fe2c36
-  data.tar.gz: 5685ced74cc962121ad634d9290aeba0663373c9db052ca3480d37f29ec8ec1b
+  metadata.gz: d1e8b7a7dc083d479b5322405ddbfc58ecab56967433c5f2a543c7637a86ce28
+  data.tar.gz: 3c09e62579e85fa615e2005ed6f5cc2d0068576eba46255791523a211b7c0387
 SHA512:
-  metadata.gz: 734fe59b6c52c355168637b37685bda6a54dc05faf66db0d7758bcb00305a00069056915f433fc5359b36236896a300ac5162632872cc00e71c5bc7d730239de
-  data.tar.gz: 924afe38e6cdf1dfa179917856d172c35c1d083571d1dfbfdce53d3c45e8b15950c94c3d6131c123d529005a80ba518ae7ffb420f9eb16fa700999a7cff8e432
+  metadata.gz: 2ab06301b535cfe5eb37bb3da892fc6e8a66cb46c6c346bfb0d8279bfd37bba9c495f3c9fc9ffda8663881b7fe333186820cc4c57d36f086c524191dc953da14
+  data.tar.gz: 0f55ad3b8d94900354005227d73b86ba3ab25847eb7d88242f89e28fafbd281256755a802a7ca10092bd1571040335a3a4d8de845406af94b4d5a10edd1e9e16

data/lib/bard/github_pages.rb

@@ -22,34 +22,55 @@ module Bard
     private
 
     def build_site
-      system "rm -rf #{@build_dir.sub(@sha, "*")}"
-      run! <<~SH
-        set -e
-        RAILS_ENV=production bundle exec rails s -p 3000 -d --pid tmp/pids/server.pid
-        OUTPUT=$(bundle exec rake assets:clean assets:precompile 2>&1) || echo "$OUTPUT"
-
-        # Create the output directory and enter it
-        BUILD=#{@build_dir}
-        rm -rf $BUILD
-        mkdir -p $BUILD
-        cp -R public/assets $BUILD/
-        cd $BUILD
-
-        # wait until server responds
-        echo waiting...
-        curl -s --retry 5 --retry-delay 2 http://localhost:3000 >/dev/null 2>&1
-
-        echo copying...
-        # Mirror the site to the build folder, ignoring links with query params
-        wget -nv -r -l inf --no-remove-listing -FEnH --reject-regex "(\\.*)\\?(.*)" http://localhost:3000/ 2>&1
-
-        echo #{@domain} > CNAME
-      SH
-    ensure # cleanup
-      run! <<~SH
-        cat tmp/pids/server.pid | xargs -I {} kill {}
-        rm -rf public/assets
-      SH
+      with_locked_port do |port|
+        system "rm -rf #{@build_dir.sub(@sha, "*")}"
+        run! <<~SH
+          set -e
+          RAILS_ENV=production bundle exec rails s -p #{port} -d --pid tmp/pids/server.pid
+          OUTPUT=$(bundle exec rake assets:clean assets:precompile 2>&1) || echo "$OUTPUT"
+
+          # Create the output directory and enter it
+          BUILD=#{@build_dir}
+          rm -rf $BUILD
+          mkdir -p $BUILD
+          cp -R public/assets $BUILD/
+          cd $BUILD
+
+          # wait until server responds
+          echo waiting...
+          curl -s --retry 5 --retry-delay 2 http://localhost:#{port} >/dev/null 2>&1
+
+          echo copying...
+          # Mirror the site to the build folder, ignoring links with query params
+          wget -nv -r -l inf --no-remove-listing -FEnH --reject-regex "(\\.*)\\?(.*)" http://localhost:#{port}/ 2>&1
+
+          echo #{@domain} > CNAME
+        SH
+      ensure # cleanup
+        run! <<~SH
+          cat tmp/pids/server.pid | xargs -I {} kill {}
+          rm -rf public/assets
+        SH
+      end
+    end
+
+    def with_locked_port
+      (3000..3020).each do |port|
+        lock_file = "/tmp/bard_github_pages_#{port}.lock"
+        file = File.open(lock_file, File::RDWR | File::CREAT, 0644)
+        if file.flock(File::LOCK_EX | File::LOCK_NB)
+          begin
+            yield port
+            return
+          ensure
+            file.flock(File::LOCK_UN)
+            file.close
+          end
+        else
+          file.close
+        end
+      end
+      raise "Could not find an available port for GitHub Pages deployment (checked 3000-3020)."
     end
 
     def create_tree_from_build

data/lib/bard/ping.rb

@@ -8,16 +8,26 @@ module Bard
     end
 
     def call
-      server.ping.reject do |url|
-        response = get_response_with_redirect(url) rescue nil
-        response.is_a?(Net::HTTPSuccess)
-      end
+      server.ping.reject { |url| reachable?(url) }
     end
 
     private
 
+    def reachable?(url)
+      attempts = 0
+      begin
+        attempts += 1
+        response = get_response_with_redirect(url)
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError
+        retry if attempts < 2
+        false
+      end
+    end
+
     def get_response_with_redirect uri_str, limit=5
-      response = Net::HTTP.get_response(URI(uri_str))
+      uri = URI(uri_str)
+      response = http_get(uri)
 
       case response
       when Net::HTTPRedirection
@@ -25,11 +35,32 @@ module Bard
           puts "too many HTTP redirects"
           response
         else
-          get_response_with_redirect(response["location"], limit - 1)
+          location = response["location"]
+          return response unless location
+
+          next_uri = begin
+            uri + location
+          rescue URI::InvalidURIError
+            URI(location)
+          end
+
+          get_response_with_redirect(next_uri, limit - 1)
         end
       else
         response
       end
     end
+
+    def http_get(uri)
+      Net::HTTP.start(
+        uri.host,
+        uri.port,
+        use_ssl: uri.scheme == "https",
+        open_timeout: 5,
+        read_timeout: 5,
+      ) do |http|
+        http.get(uri.request_uri)
+      end
+    end
   end
 end

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.7.2"
+  VERSION = "1.7.4"
 end
 

data/spec/bard/github_pages_spec.rb

@@ -38,6 +38,69 @@ describe Bard::GithubPages do
     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")
@@ -77,4 +140,4 @@ describe Bard::GithubPages do
       end
     end
   end
-end
+end

data/spec/bard/ping_spec.rb

@@ -3,29 +3,58 @@ require "bard/ping"
 
 describe Bard::Ping do
   let(:server) { double("server", ping: ["http://example.com"]) }
+  let(:ping) { described_class.new(server) }
+
+  def success_response
+    Net::HTTPSuccess.new(1.0, "200", "OK")
+  end
+
+  def not_found_response
+    Net::HTTPNotFound.new(1.0, "404", "Not Found")
+  end
 
   context "when the server is reachable" do
-    it "should return an empty array" do
-      allow(Net::HTTP).to receive(:get_response).and_return(Net::HTTPSuccess.new(1.0, "200", "OK"))
-      expect(Bard::Ping.call(server)).to be_empty
+    it "returns an empty array" do
+      allow(ping).to receive(:http_get).and_return(success_response)
+      expect(ping.call).to be_empty
     end
   end
 
   context "when the server is not reachable" do
-    it "should return the url" do
-      allow(Net::HTTP).to receive(:get_response).and_return(Net::HTTPNotFound.new(1.0, "404", "Not Found"))
-      expect(Bard::Ping.call(server)).to eq(["http://example.com"])
+    it "returns the url" do
+      allow(ping).to receive(:http_get).and_return(not_found_response)
+      expect(ping.call).to eq(["http://example.com"])
     end
   end
 
   context "when there is a redirect" do
-    it "should follow the redirect and return an empty array" do
+    it "follows the redirect and returns an empty array" do
       redirect_response = Net::HTTPRedirection.new(1.0, "301", "Moved Permanently")
-      redirect_response["location"] = "http://example.com/new"
-      success_response = Net::HTTPSuccess.new(1.0, "200", "OK")
-      allow(Net::HTTP).to receive(:get_response).with(URI("http://example.com")).and_return(redirect_response)
-      allow(Net::HTTP).to receive(:get_response).with(URI("http://example.com/new")).and_return(success_response)
-      expect(Bard::Ping.call(server)).to be_empty
+      redirect_response["location"] = "/new"
+      allow(ping).to receive(:http_get).with(URI("http://example.com")).and_return(redirect_response)
+      allow(ping).to receive(:http_get).with(URI("http://example.com/new")).and_return(success_response)
+      expect(ping.call).to be_empty
+    end
+  end
+
+  context "when a transient error occurs" do
+    it "retries once before marking down" do
+      calls = 0
+      allow(ping).to receive(:http_get) do
+        calls += 1
+        raise Errno::ECONNRESET if calls == 1
+
+        success_response
+      end
+
+      expect(ping.call).to be_empty
+    end
+  end
+
+  context "when errors persist across retries" do
+    it "returns the url" do
+      allow(ping).to receive(:http_get).and_raise(Errno::ECONNREFUSED)
+      expect(ping.call).to eq(["http://example.com"])
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bard
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.7.4
 platform: ruby
 authors:
 - Micah Geisel
 bindir: bin
 cert_chain: []
-date: 2025-12-11 00:00:00.000000000 Z
+date: 2025-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor