Capybara session pool

# frozen_string_literal: true

require 'capybara'
require 'capybara/poltergeist'

class CapybaraSessionPool
  attr_reader :size

  attr_reader :pool, :mutex
  private     :pool, :mutex

  def initialize(size:)
    @size = size.to_i
    raise 'invalid session size' unless @size > 0

    @pool = []
    @mutex = Mutex.new

    self.size.times { pool << Wrapper.new(Capybara::Session.new(:poltergeist), 0) }
  end

  def get(time:)
    mutex.synchronize do
      expired, index = pool.each_with_index.select { |wrapper, _index| wrapper.expired? }.first
      raise EmptyPoolError if expired.nil?
      pool[index] = Wrapper.new expired.expire, time
    end
  end

  class EmptyPoolError < StandardError
  end

  class Wrapper
    attr_reader :session, :expires_in, :expired
    private     :session, :expires_in, :expired

    def initialize(session, time)
      @session = session
      @expires_in = Time.now.utc + time
      @expired = false
    end

    def expired?
      expired || Time.now.utc >= expires_in
    end

    def expire
      @expired = true
      session.reset!
      session
    end

    def respond_to_missing?(method_name, include_private = false)
      session.respond_to?(method_name, include_private)
    end

    def method_missing(method_name, *args)
      raise SessionExpiredError if expired
      session.public_send(method_name, *args)
    end

    class SessionExpiredError < StandardError
    end
  end
end