ballast 1.9.3 → 2.0.0

data/lib/ballast/concerns/ajax_handling.rb

@@ -0,0 +1,73 @@
+#
+# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Ballast
+  # A set of concerns to address common issues.
+  module Concerns
+    # A concern to handle AJAX and HTTP requests.
+    module AjaxHandling
+      extend ActiveSupport::Concern
+
+      # Checks if the current request is AJAX.
+      #
+      # @return [Boolean] `true` if the request is AJAX, `false` otherwise.
+      def ajax_request?
+        request.safe_send(:xhr?).to_boolean || params[:xhr].to_boolean
+      end
+
+      # Prepares an AJAX response.
+      #
+      # @param status [Symbol|Fixnum] The HTTP status of the response.
+      # @param data [Object] The data of the response.
+      # @param error [Object|NilClass] The error of the response.
+      def prepare_ajax_response(status: :ok, data: {}, error: nil)
+        Ballast::AjaxResponse.new(status: status, data: data, error: error, transport: self)
+      end
+
+      # Prevents HTTP caching.
+      def prevent_caching
+        response.headers.merge!({
+          "Cache-Control" => "no-cache, no-store, max-age=0, must-revalidate",
+          "Pragma" => "no-cache",
+          "Expires" => "Fri, 01 Jan 1990 00:00:00 GMT"
+        })
+      end
+
+      # Allows HTTP Cross-Origin Resource Sharing.
+      #
+      # @param allow_origin [String] The value for the `Access-Control-Allow-Origin` header.
+      # @param allow_methods [Array] A list of methods for the `Access-Control-Allow-Methods` header.
+      # @param allow_headers [String] The value for the `Access-Control-Allow-Headers` header.
+      # @param max_age [Float|Fixnum] The value for the `Access-Control-Max-Age` header.
+      # @param allow_credentials [Boolean] The value for the `Access-Control-Allow-Credentials` header.
+      def allow_cors(allow_origin: "*", allow_methods: [:post, :get, :options], allow_headers: "*", max_age: 1.year, allow_credentials: false)
+        headers.merge!({
+          "Access-Control-Allow-Origin" => allow_origin,
+          "Access-Control-Allow-Methods" => allow_methods.map { |m| m.to_s.upcase }.join(", "),
+          "Access-Control-Allow-Headers" => allow_headers,
+          "Access-Control-Max-Age" => max_age.to_i.to_s
+        })
+
+        headers["Access-Control-Allow-Credentials"] = "true" if allow_credentials
+      end
+
+      # Generates a `robots.txt file.
+      #
+      # @param configuration [Hash|NilClass] An hash of agent and list of paths to include.
+      def generate_robots_txt(configuration = nil)
+        configuration ||= {"*" => "/"}
+        rv = configuration.reduce([]) { |accu, (agent, paths)|
+          paths = paths.ensure_array.map { |e| "Disallow: #{e}" }
+
+          accu << "User-agent: #{agent}\n#{paths.join("\n")}"
+          accu
+        }.join("\n\n")
+
+        render(text: rv, content_type: "text/plain")
+      end
+      alias_method :disallow_robots, :generate_robots_txt
+    end
+  end
+end

data/lib/ballast/concerns/common.rb

@@ -9,53 +9,32 @@ module Ballast
     module Common
       # Checks if the current request wants JSON or JSONP as response.
       #
-      # @return [Boolean] `true` if the request is JSON, `false` otherwise.
-      def is_json?
-        ([:json, :jsonp].include?(request.format.to_sym) || params[:json].to_boolean) ? true : false
+      # @return [Boolean] `true` if the request is JSON(P), `false` otherwise.
+      def json?
+        [:json, :jsonp].include?(request.format.to_sym) || params[:json].to_boolean
       end
 
       # Checks if the user is sending any data.
       #
       # @return [Boolean] `true` if the user is sending data, `false` otherwise.
-      def sending_data?
-        request.post? || request.put?
-      end
-
-      # Performs an operation, using itself as owner by default.
-      #
-      # @param klass [Class] The operation to perform.
-      # @param owner [Object] The owner to use. By default it uses itself.
-      # @param kwargs [Hash] The arguments for performing.
-      # @return [Operation] The performed operation.
-      def perform_operation(klass, owner = nil, **kwargs)
-        @operation = klass.perform(owner || self, **kwargs)
-      end
-
-      # Performs an operations chain, using itself as owner by default.
-      #
-      # @param klasses [Array] The operations to perform.
-      # @param owner [Object] The owner to use. By default it uses itself.
-      # @param kwargs [Hash] The arguments for performing.
-      # @return [OperationChain] The performed operation chain.
-      def perform_operations_chain(klasses, owner = nil, **kwargs)
-        @operation = Ballast::OperationsChain.perform(owner || self, klasses, **kwargs)
+      def request_data?
+        request.post? || request.put? || request.patch?
       end
 
       # Formats a relative date using abbreviation or short formats.
       #
       # @param date [DateTime] The date to format.
-      # @param reference [DateTime] The reference date.
+      # @param reference [DateTime|NilClass] The reference date.
       # @param suffix [String] The suffix to add to the formatted date.
       # @return [String] The formatted date.
-      def format_short_duration(date, reference = nil, suffix = "")
-        reference ||= Time.now
-        amount = (reference.to_i - date.to_i).to_i
+      def format_short_duration(date, reference: nil, suffix: "")
+        amount = (reference || Time.now).to_i - date.to_i
 
-        if amount <= 0 then
+        if amount <= 0
           "now"
-        elsif amount < 1.day then
+        elsif amount < 1.day
           format_short_amount(amount, suffix)
-        elsif amount < 1.year then
+        elsif amount < 1.year
           date.strftime("%b %d")
         else
           date.strftime("%b %d %Y")
@@ -68,9 +47,9 @@ module Ballast
       # @param suffix [String] The suffix to add to the formatted amount.
       # @return [String] The formatted amount.
       def format_short_amount(amount, suffix = "")
-        if amount < 1.minute then
+        if amount < 1.minute
           "#{amount.floor}s#{suffix}"
-        elsif amount < 1.hour then
+        elsif amount < 1.hour
           "#{(amount / 60).floor}m#{suffix}"
         else
           "#{(amount / 3600).floor}h#{suffix}"
@@ -83,29 +62,28 @@ module Ballast
       # @param separator [String] The separator between date and time.
       # @param format [String] The format of the date, like in strftime. Use `%-` for the separator, `%o` for the ordinalized version of the day of the month
       #   and `%:Z` for the zone name considering also DST.
-      def format_long_date(date, separator = "•", format = "%I:%M%p %- %b %o, %Y (%:Z)")
+      def format_long_date(date, separator: "•", format: "%I:%M%p %- %b %o, %Y (%:Z)")
         tz = Time.zone
-        replacements = {"%-" => separator, "%o" => date.day.ordinalize, "%:Z" => tz.send(tz.uses_dst? && date.dst? ? :dst_name : :name)}
-        date.strftime(format).gsub(/%(-|o|(:Z))/) {|r| replacements.fetch(r, r) }
+        replacements = {"%-" => separator, "%o" => date.day.ordinalize, "%:Z" => tz.current_name(tz.uses_dst? && date.dst?)}
+        date.strftime(format).gsub(/%(-|o|(:Z))/) { |r| replacements.fetch(r, r) }
       end
 
       # Authenticates a user via HTTP, handling the error if the authentication failed.
       #
-      # @param area [String] The name of the area.
-      # @param title [String] A title for authentication errors.
-      # @param message [String] A message for authentication errors.
+      # @param area [String|NilClass] The name of the area.
+      # @param title [String|NilClass] A title for authentication errors.
+      # @param message [String|NilClass] A message for authentication errors.
       # @param authenticator [Proc] A block to verify if authentication is valid.
-      def authenticate_user(area = nil, title = nil, message = nil, &authenticator)
+      def authenticate_user(area: nil, title: nil, message: nil, &authenticator)
+        return if authenticate_with_http_basic { |username, password| authenticator.call(username, password) }
+
         area ||= "Private Area"
         title ||= "Authentication required."
         message ||= "To view this resource you have to authenticate."
-        authenticated = authenticate_with_http_basic { |username, password| authenticator.call(username, password) }
 
-        if !authenticated then
-          headers["WWW-Authenticate"] = "Basic realm=\"#{area}\""
-          handle_error({status: 401, title: title, message: message})
-        end
+        headers["WWW-Authenticate"] = "Basic realm=\"#{area}\""
+        handle_error({status: 401, title: title, message: message})
       end
     end
   end
-end
+end

data/lib/ballast/concerns/errors_handling.rb

@@ -12,44 +12,35 @@ module Ballast
       # Handles an error in the application.
       #
       # @param exception [Hash|Exception] The exception to handle.
-      # @param layout [String] The layout to use to render the error.
+      # @param layout [String] The layout to use to render the error. The `@error` variable will be exposed.
       # @param title [String] The title to set in case of custom errors.
-      # @param format [String|Symbol] The format of the response.
-      def handle_error(exception = nil, layout = "error", title = "Error - Application", format = nil)
-        @error ||= exception
-
-        if @error.is_a?(Lazier::Exceptions::Debug) then
-          @error_title = "Debug"
-          @error_code = 503
-        elsif @error.is_a?(Hash) then
-          @error_title = @error[:title] || title
-          @error_code = @error[:status]
-          @error_message = @error[:error]
-        else
-          @error_title = "Error - #{@error.class.to_s}"
-          @error_code = 500
-        end
+      # @param format [String|Symbol|NilClass] The format of the response.
+      def handle_error(exception, layout: "error", title: "Error - Application", format: nil)
+        @error =
+          if exception.is_a?(Lazier::Exceptions::Debug)
+            {status: 503, title: "Debug", error: exception.message, exception: exception}
+          elsif exception.is_a?(::Hash)
+            exception.reverse_merge({title: title})
+          else
+            {status: 500, title: "Error - #{exception.class}", error: exception.message, exception: exception}
+          end
 
         send_or_render_error(layout, format)
       end
 
       private
-        # Send an AJAX error o renders it.
-        #
-        # @param layout [String] The layout to use to render the error.
-        # @param format [String|Symbol] The format of the response.
-        def send_or_render_error(layout, format = nil)
-          format ||= request.format.to_sym
 
-          if is_ajax? || format.to_s =~ /^json/ then
-            details = {type: @error_title}
-            details[:backtrace] = @error.backtrace if @error.respond_to?(:backtrace)
-            data = prepare_ajax(@error_code, details, @error_message || @error.message)
-            send_ajax(data, format: format)
-          else
-            render(html: "", status: @error_code, layout: layout, formats: [:html])
-          end
+      # :nodoc:
+      def send_or_render_error(layout, format = nil)
+        format ||= request.format.to_sym
+
+        if ajax_request? || format.match(/^json/)
+          details = {description: @error[:title], backtrace: @error[:exception].safe_send(:backtrace)}
+          prepare_ajax_response(status: @error[:status], data: details, error: @error[:error]).reply(format: format)
+        else
+          render(html: "", status: @error[:status], layout: layout, formats: [:html])
         end
+      end
     end
   end
 end

data/lib/ballast/concerns/view.rb

@@ -11,30 +11,30 @@ module Ballast
       #
       # @return [String] The scoped string.
       def scope_css
-        "%s %s" % [controller_path.gsub("/", "-"), action_name]
+        format("%s %s", controller_path.gsub("/", "-"), action_name)
       end
 
       # Returns an instance of the browser.
       #
       # @return [Browser] A browser object.
       def browser
-        @browser ||= Brauser::Browser.new(request.user_agent)
+        @browser ||= Brauser::Browser.new(request.user_agent, request.headers["Accept-Language"])
       end
 
       # Checks if the current browser is supported according to a definition YAML file.
       #
-      # @param conf_file [String] The configuration file which holds the definitions.
+      # @param file [String] The configuration file which holds the definitions.
+      # @param root [String|NilClass] The directory that contains the configuration file.
       # @return [Boolean] `true` if the browser is supported, `false` otherwise.
-      def browser_supported?(conf_file = nil)
-        conf_file ||= (Rails.root + "config/supported-browsers.yml").to_s if defined?(Rails)
-        browser.supported?(conf_file)
+      def browser_supported?(file = "config/supported-browsers.yml", root: nil)
+        browser.supported?(((Ballast::Configuration.default_root || root) + "/" + file).to_s)
       end
 
       # Returns one or all layout parameters.
       #
       # @param key [String|Symbol|NilClass] The parameter to return. If set to `nil`, all the parameters will be returned as an hash.
-      # @param default_value [Object] The default value if the parameter is not present.
-      # @return [Object|Hash] The parameter or the entire layout parameters hash.
+      # @param default_value [Object|NilClass] The default value if the parameter is not present.
+      # @return [Object|Hash|NilClass] The parameter or the entire layout parameters hash.
       def layout_params(key = nil, default_value = nil)
         initialize_view_params
         key ? @layout_params.fetch(key, default_value) : @layout_params
@@ -43,8 +43,8 @@ module Ballast
 
       # Adds/Replaces layout parameters.
       #
-      # @param args [Hash] The new parameters to add.
-      def set_layout_params(**args)
+      # @param args [Hash] The parameters to add or replace.
+      def update_layout_params(**args)
         initialize_view_params
         @layout_params.merge!(args)
       end
@@ -53,18 +53,19 @@ module Ballast
       #
       # @param id [String|NilClass|FalseClass] The id for the tag. If `nil` or `false`, the parameters will be returned as an hash.
       # @param tag [Symbol] The tag to use for HTML.
-      # @return [String|Hash] Javascript parameters as HTML or the hash.
-      def javascript_params(id = nil, tag = :details)
+      # @param attribute [Symbol] The attribute to use for the HTML element id.
+      # @return [String|Hash] Javascript parameters as HTML or as an hash.
+      def javascript_params(id = nil, tag: :details, attribute: "data-jid")
         initialize_view_params
-        id ? content_tag(tag, @javascript_params.to_json.html_safe, "data-jid" => id): @javascript_params
+        id ? content_tag(tag, @javascript_params.to_json.html_safe, attribute => id) : @javascript_params
       end
 
-      # Appends new Javascript parameters.
+      # Adds/Replaces Javascript parameters.
       #
       # @param key [String|Symbol] The key of the new parameters. If `nil`, the root will be merged/replaced.
-      # @param data [Hash] The data to add.
+      # @param data [Hash] The data to add or replace.
       # @param replace [Boolean] Whether to replace existing data rather than merge.
-      def add_javascript_params(key, data, replace = false)
+      def update_javascript_params(key, data, replace: false)
         initialize_view_params
 
         if key
@@ -79,11 +80,12 @@ module Ballast
       end
 
       private
-        # Prepares parameters for views.
-        def initialize_view_params
-          @layout_params ||= HashWithIndifferentAccess.new
-          @javascript_params ||= HashWithIndifferentAccess.new
-        end
+
+      # :nodoc:
+      def initialize_view_params
+        @layout_params ||= HashWithIndifferentAccess.new
+        @javascript_params ||= HashWithIndifferentAccess.new
+      end
     end
   end
-end
+end

data/lib/ballast/configuration.rb

@@ -7,24 +7,44 @@ module Ballast
   # A class which loads a list of YAML files in a folder and expose them in a dotted notation.
   #   For each file, only the subsection for the current environment is loaded, so each YAML document should be an hash.
   class Configuration < HashWithIndifferentAccess
+    # Returns the default root directory to lookup a configuration. It will be the Rails root if set or the current folder.
+    #
+    # @return [String] The default root directory to lookup a configuration.
+    def self.default_root
+      defined?(Rails) ? Rails.root.to_s : Dir.pwd
+    end
+
+    # Returns the default environment. It will be the first non-nil of the following: Rails environment, the Rack environment or "production".
+    #
+    # @return [String] The default environment.
+    def self.default_environment
+      defined?(Rails) ? Rails.env : ENV.fetch("RACK_ENV", "production")
+    end
+
     # Creates a new configuration.
     #
     # @param sections [Array] A list of sections to load. Each section name should be the basename (without extension) of a file in the root folder.
     #   Subfolders are not supported.
-    # @param root [String] The root folder where look for file. Default is the Rails root.
-    # @param environment [String] The environment to load. Default is the Rails environment.
-    def initialize(sections: [], root: nil, environment: nil)
+    # @param root [String|NilClass] The root folder where look for file.
+    # @param environment [String|NilClass] The environment to load.
+    def initialize(*sections, root: nil, environment: nil)
       super()
-      root ||= Rails.root.to_s
-      environment ||= Rails.env
+      root ||= ::Ballast::Configuration.default_root
+      environment ||= ::Ballast::Configuration.default_environment
 
       sections.each do |section|
-        content = (YAML.load_file("#{root}/config/#{section}.yml") rescue {}).with_indifferent_access
-        self[section] = content[environment]
-        self[section.underscore] = self[section] if section.index("-")
+        content = load_section(root, section)
+        self[section.underscore] = content.fetch(environment, {})
       end
 
-      self.enable_dotted_access
+      enable_dotted_access
+    end
+
+    private
+
+    # :nodoc:
+    def load_section(root, section)
+      YAML.load_file("#{root}/config/#{section}.yml") rescue {}
     end
   end
-end
+end

data/lib/ballast/emoji.rb

@@ -0,0 +1,114 @@
+#
+# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Ballast
+  # A module to ease emoji handling.
+  module Emoji
+    # General utility methods.
+    #
+    # @attribute url_mapper
+    #   @return [Proc] The current URL mapper or a default one (which will return the relative URL unmodified).
+    module Utils
+      attr_accessor :url_mapper
+
+      # Returns the regular expression which matches all the known emojis.
+      #
+      # @return [Regexp] The regular expression which matches all the known emojis.
+      def replace_regex
+        @replace_regex ||= /(#{::Emoji.send(:unicodes_index).keys.join("|")})/
+      end
+
+      # Replaces all the emojis in the text using the requested mod.
+      #
+      # @param text [String] The text to manipulate.
+      # @param mode [Symbol] The method to use when replacing icons.
+      # @param options [Hash] The options to pass to the replacing method.
+      # @return [String] The text with all emojis replaced.
+      def replace(text, mode: :html, **options)
+        mode = :markup unless mode && ::Emoji::Character.new(nil).respond_to?(mode)
+        text.ensure_string.gsub(replace_regex) { invoke(::Emoji.find_by_unicode(Regexp.last_match[1]), mode, options) }
+      end
+
+      # Lists all the emoji known in a hash.
+      #
+      # @param keys_method [Symbol] The method to use for keys.
+      # @param values_method [Symbol] The method to use for values.
+      # @param options [Hash] The options to pass to all methods.
+      # @return [Hash] A hash of all known emojis.
+      def enumerate(keys_method: :markup, values_method: :html, **options)
+        tester = ::Emoji::Character.new(nil)
+        keys_method = :markup unless keys_method && tester.respond_to?(keys_method)
+        values_method = :html unless values_method && tester.respond_to?(values_method)
+
+        ::Emoji.all.reduce({}) { |accu, icon|
+          accu[invoke(icon, keys_method, options)] = invoke(icon, values_method, options)
+          accu
+        }
+      end
+
+      # Returns the URL mapper for the emojis.
+      #
+      # @return [Proc] The current URL mapper or a default one (which will return the relative URL unmodified).
+      def url_mapper
+        @url_mapper || ->(url) { url }
+      end
+
+      # Returns a absolute URL for a emoji image.
+      #
+      # @param image [String] The relative URL of the emoji filename.
+      # @return [String] The absolute URL of the emoji filename.
+      def url_for(image)
+        url_mapper.call(image)
+      end
+
+      private
+
+      # :nodoc:
+      def invoke(subject, method, options)
+        subject.method(method).arity == 1 ? subject.send(method, options) : subject.send(method)
+      end
+    end
+
+    # Extensions for a emoji character.
+    module Character
+      include ActionView::Helpers::TagHelper
+      include ActiveSupport::Concern
+
+      # Returns a markup for the current character.
+      #
+      # @return [String] The markup for a character.
+      def markup
+        ":#{name}:"
+      end
+
+      # Returns a image URL for the current character.
+      #
+      # @return [String] The image URL for the current character.
+      def url
+        ::Emoji.url_for(image_filename)
+      end
+
+      # Returns a image tag for the current character.
+      # @see ActionView::Helpers::TagHelper#tag
+      #
+      # @return [String] The options for the tag generation.
+      def image_tag(options = {})
+        options = options.reverse_merge({alt: markup, title: markup, rel: "tooltip"})
+        classes = options[:class].ensure_string.tokenize(pattern: /[\s,]+/, no_duplicates: true)
+        classes << "emoji" unless classes.include?("emoji")
+
+        options[:src] = url
+        options[:class] = classes.uniq.join(" ")
+
+        tag(:img, options)
+      end
+      alias_method :image, :url
+      alias_method :html, :image_tag
+    end
+  end
+end
+
+::Emoji.extend(Ballast::Emoji::Utils)
+::Emoji::Character.include(Ballast::Emoji::Character)

data/lib/ballast/errors.rb

@@ -8,27 +8,30 @@ module Ballast
   module Errors
     # The base error raised from an application.
     #
-    # @attribute [r] response
-    #   @return [String|Hash] The response which contains either a message or an hash with status code and a error message.
-    class BaseError < RuntimeError
-      attr_reader :response
+    # @attribute [r] details
+    #   @return [String|Hash|NilClass] The details of the error. If a Hash, it should contain the keys `status` and `error`.
+    class Base < RuntimeError
+      attr_reader :details
 
-      def initialize(msg = nil)
-        super(msg)
-        @response = msg
+      # Creates a new error.
+      #
+      # @param details [String|Hash|NilClass] The details of this error.
+      def initialize(details = nil)
+        super("")
+        @details = details
       end
     end
 
     # This is raised when an invalid domain is requested.
-    class InvalidDomain < BaseError
+    class InvalidDomain < Base
     end
 
-    # This is raised when something went wrong during the processing of a operation.
-    class PerformError < BaseError
+    # This is raised when something went wrong during the processing of a operation or a service.
+    class Failure < Base
     end
 
-    # This is raised when some invalid parameters are passed to a operation.
-    class ValidationError < BaseError
+    # This is raised when some invalid parameters are passed to a operation or a service.
+    class ValidationFailure < Failure
     end
   end
-end
+end

data/lib/ballast/middlewares/default_host.rb

@@ -22,9 +22,9 @@ module Ballast
       # @param env [Hash] A Rack environment.
       def call(env)
         old_host = env["SERVER_NAME"].ensure_string
-        new_host = @hosts[ENV["RACK_ENV"]]
+        new_host = @hosts[ENV.fetch("RACK_ENV", "production")]
 
-        if old_host =~ /^\d/ && new_host then
+        if old_host =~ /^\d/ && new_host
           env["ORIG_SERVER_NAME"] = old_host
           env["ORIG_HTTP_HOST"] = env["HTTP_HOST"].dup
           env["SERVER_NAME"] = new_host
@@ -35,4 +35,4 @@ module Ballast
       end
     end
   end
-end
+end

data/lib/ballast/request_domain_matcher.rb

@@ -9,20 +9,20 @@ module Ballast
   # @attribute domains
   #   @return [Array] The list of domains which mark a positive match.
   # @attribute replace_pattern
-  #   @return [String|Regexp] A optional pattern to replace in the request host. See `String#gsub`.
+  #   @return [String|Regexp] A optional pattern to manipulate the request host before trying the match. See `String#gsub`.
   # @attribute replace_string
-  #   @return [String] A string to use for replacement in the request host. See `String#gsub`.
+  #   @return [String] A string to manipulate the request host before trying the match. See `String#gsub`.
   # @attribute replace_block
-  #   @return [Proc] A block to use for replacement in the request host. See `String#gsub`.
+  #   @return [Proc] A block to use to manipulate the request host before trying the match. See `String#gsub`.
   class RequestDomainMatcher
     attr_accessor :domains, :replace_pattern, :replace_string, :replace_block
 
     # Creates a new matcher.
     #
     # @param domains [String|Array] The list of domains which mark a positive match.
-    # @param replace_pattern [String|Regexp] A optional pattern to replace in the request host. See `String#gsub`.
-    # @param replace_string [String] A string to use for replacement in the request host. See `String#gsub`.
-    # @param replace_block [Proc] A block to use for replacement in the request host. See `String#gsub`.
+    # @param replace_pattern [String|Regexp] A optional pattern to manipulate the request host before trying the match. See `String#gsub`.
+    # @param replace_string [String] A string to manipulate the request host before trying the match. See `String#gsub`.
+    # @param replace_block [Proc] A block to use to manipulate the request host before trying the match. See `String#gsub`.
     def initialize(domains, replace_pattern = /\.dev$/, replace_string = "", &replace_block)
       @domains = domains.ensure_array
       @replace_pattern = replace_pattern
@@ -39,4 +39,4 @@ module Ballast
       @domains.include?(final_host)
     end
   end
-end
+end