sitehub 0.4.2 → 0.4.3

data/lib/sitehub/forward_proxies.rb

@@ -7,9 +7,8 @@ require 'em-http'
 
 class SiteHub
   class ForwardProxies
-
     NOT_FOUND = Rack::Response.new(['page not found'], 404, {})
-    def call env
+    def call(env)
       source_request = Rack::Request.new(env)
 
       forward_proxy = mapped_route(path: source_request.path, request: source_request)
@@ -19,32 +18,32 @@ class SiteHub
     end
 
     def init
-      forward_proxies.values.each { |proxy| proxy.build }
+      forward_proxies.values.each(&:build)
       self
     end
 
-    def << route
+    def <<(route)
       forward_proxies[route.mapped_path] = route
     end
 
     def mapped_route(path:, request:)
+      fwd_proxy_builder = forward_proxies[mapping(path)]
+      fwd_proxy_builder ? fwd_proxy_builder.resolve(id: request.cookies[RECORDED_ROUTES_COOKIE], env: request.env) : nil
+    end
 
-      key = forward_proxies.keys.find do |key|
+    def mapping(path)
+      forward_proxies.keys.find do |key|
         case key
-          when Regexp
-            key.match(path)
-          else
-            path == key
+        when Regexp
+          key.match(path)
+        else
+          path == key
         end
       end
-
-      forward_proxy_builder = forward_proxies[key]
-      forward_proxy_builder ? forward_proxy_builder.resolve(id: request.cookies[RECORDED_ROUTES_COOKIE], env: request.env) : nil
     end
 
     def forward_proxies
       @forward_proxies ||= {}
     end
-
   end
 end

data/lib/sitehub/forward_proxy.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Metrics/ParameterLists
 require 'sitehub/http_headers'
 require 'sitehub/request_mapping'
 require 'sitehub/rules'
@@ -6,7 +7,6 @@ require 'faraday'
 require 'sitehub/constants'
 class SiteHub
   class ForwardProxy
-
     ERROR_RESPONSE = Rack::Response.new(['error'], 500, {})
 
     include HttpHeaders, Rules, Resolver, Constants
@@ -14,39 +14,48 @@ class SiteHub
     attr_reader :url, :id, :mapped_path, :http_client, :sitehub_cookie_path, :sitehub_cookie_name
 
     def initialize(url:, id:, mapped_path: nil, rule: nil, sitehub_cookie_path: nil, sitehub_cookie_name:)
-      @id, @url, @rule, @mapped_path = id, url, rule, mapped_path
+      @id = id
+      @url = url
+      @rule = rule
+      @mapped_path = mapped_path
       @sitehub_cookie_path = sitehub_cookie_path
       @sitehub_cookie_name = sitehub_cookie_name
-      @http_client = Faraday.new(ssl: {verify:false}) do |con|
+      @http_client = Faraday.new(ssl: { verify: false }) do |con|
         con.adapter :em_synchrony
       end
     end
 
-    def call env
+    def call(env)
       source_request = Rack::Request.new(env)
+      request_mapping = env[REQUEST_MAPPING] = request_mapping(source_request)
+      mapped_uri = URI(request_mapping.computed_uri)
 
-      request_mapping = request_mapping(source_request)
+      downstream_response = proxy_call(request_headers(mapped_uri, source_request), mapped_uri, source_request)
 
-      mapped_uri = URI(request_mapping.computed_uri)
+      response(downstream_response, source_request)
+    rescue StandardError => e
+      env[ERRORS] << e.message
+      ERROR_RESPONSE.dup
+    end
 
-      request_headers = sanitise_headers(extract_http_headers(source_request.env))
-      request_headers[HOST_HEADER] = "#{mapped_uri.host}:#{mapped_uri.port}"
-      request_headers[X_FORWARDED_HOST_HEADER] = append_host(request_headers[X_FORWARDED_HOST_HEADER].to_s, source_request.url)
-      env[REQUEST_MAPPING] = request_mapping
+    def response(response, source_request)
+      Rack::Response.new(response.body, response.status, sanitise_headers(response.headers)).tap do |r|
+        r.set_cookie(sitehub_cookie_name, path: (sitehub_cookie_path || source_request.path), value: id)
+      end
+    end
 
-      begin
-        response = http_client.send(source_request.request_method.downcase, mapped_uri) do |request|
-          request.headers = request_headers
-          request.body = source_request.body.read
-          request.params = source_request.params
-        end
+    def request_headers(mapped_uri, source_request)
+      headers = sanitise_headers(extract_http_headers(source_request.env))
+      headers[HOST_HEADER] = "#{mapped_uri.host}:#{mapped_uri.port}"
+      headers[X_FORWARDED_HOST_HEADER] = append_host(headers[X_FORWARDED_HOST_HEADER].to_s, source_request.url)
+      headers
+    end
 
-        Rack::Response.new(response.body, response.status, sanitise_headers(response.headers)).tap do |r|
-          r.set_cookie(sitehub_cookie_name, path: (sitehub_cookie_path || source_request.path), value: id)
-        end
-      rescue Exception => e
-        env[ERRORS] << e.message
-        ERROR_RESPONSE.dup
+    def proxy_call(headers, mapped_uri, source_request)
+      http_client.send(source_request.request_method.downcase, mapped_uri) do |request|
+        request.headers = headers
+        request.body = source_request.body.read
+        request.params = source_request.params
       end
     end
 
@@ -54,14 +63,19 @@ class SiteHub
       RequestMapping.new(source_url: source_request.url, mapped_url: url, mapped_path: mapped_path)
     end
 
-    def == other
+    def ==(other)
       other.is_a?(ForwardProxy) && url == other.url
     end
 
     private
+
     def append_host(forwarded_host, destination_uri)
       destination_uri = URI(destination_uri)
-      forwarded_host == EMPTY_STRING ? "#{destination_uri.host}:#{destination_uri.port}" : "#{forwarded_host},#{destination_uri.host}"
+      if forwarded_host == EMPTY_STRING
+        "#{destination_uri.host}:#{destination_uri.port}"
+      else
+        "#{forwarded_host},#{destination_uri.host}"
+      end
     end
   end
 end

data/lib/sitehub/forward_proxy_builder.rb

@@ -6,17 +6,20 @@ require_relative 'collection/route_collection'
 require_relative 'middleware'
 
 class SiteHub
-
   class ForwardProxyBuilder
     include Middleware
     include Rules, Resolver
 
-    class InvalidDefinitionException < Exception;
+    class InvalidDefinitionException < Exception
     end
 
+    INVALID_SPLIT_MSG = 'label and url must be defined if not supplying a block'.freeze
+    ROUTES_WITH_SPLITS_MSG = 'you cant register routes and splits at the same level'.freeze
+    INVALID_ROUTE_DEF_MSG = 'rule must be specified when supplying a block'.freeze
+
     attr_reader :mapped_path, :default_proxy, :routes, :middlewares, :splits, :sitehub_cookie_name
 
-    def initialize(url: nil, mapped_path:, rule:nil, sitehub_cookie_name: nil, &block)
+    def initialize(url: nil, mapped_path:, rule: nil, sitehub_cookie_name: nil, &block)
       @mapped_path = mapped_path
       @middlewares = []
       @splits = Collection::SplitRouteCollection.new
@@ -24,10 +27,11 @@ class SiteHub
       @sitehub_cookie_name = sitehub_cookie_name
       rule(rule) if rule
       default(url: url) if url
-      if block
-        instance_eval(&block)
-        raise InvalidDefinitionException unless valid?
-      end
+
+      return unless block
+
+      instance_eval(&block)
+      raise InvalidDefinitionException unless valid?
     end
 
     def valid?
@@ -35,23 +39,34 @@ class SiteHub
       endpoints.valid?
     end
 
-    def endpoints collection=nil
+    def endpoints(collection = nil)
       return @endpoints || Collection::RouteCollection.new unless collection
 
-      raise InvalidDefinitionException, 'you cant register routes and splits at the same level' if @endpoints && @endpoints != collection
+      raise InvalidDefinitionException, ROUTES_WITH_SPLITS_MSG if @endpoints && @endpoints != collection
       @endpoints = collection
     end
 
-    def split(percentage:, url:, label:, &block)
+    def split(percentage:, url: nil, label: nil, &block)
       endpoints(splits)
-      endpoints.add label.to_sym, forward_proxy(label: label, url: url), percentage
+
+      raise InvalidDefinitionException, INVALID_SPLIT_MSG unless block || [url, label].all?
+
+      label = label ? label.to_sym : UUID.generate(:compact)
+
+      proxy = block ? new(&block).build : forward_proxy(label: label, url: url)
+
+      endpoints.add label, proxy, percentage
+    end
+
+    def new(&block)
+      self.class.new(mapped_path: mapped_path, &block)
     end
 
-    def route url:nil, label:nil, rule: nil, &block
+    def route(url: nil, label: nil, rule: nil, &block)
       endpoints(routes)
 
       if block
-        raise InvalidDefinitionException, 'rule must be specified when supplying a block'unless rule
+        raise InvalidDefinitionException, INVALID_ROUTE_DEF_MSG unless rule
         builder = self.class.new(mapped_path: mapped_path, rule: rule, &block).build
         endpoints.add UUID.generate(:compact), builder
       else
@@ -63,12 +78,11 @@ class SiteHub
       @default_proxy = forward_proxy(label: :default, url: url)
     end
 
-    def sitehub_cookie_path path=nil
+    def sitehub_cookie_path(path = nil)
       return @sitehub_cookie_path unless path
       @sitehub_cookie_path = path
     end
 
-
     def build
       endpoints.transform do |proxy|
         apply_middleware(proxy).tap do |wrapped_proxy|
@@ -86,14 +100,17 @@ class SiteHub
       endpoints[id] || endpoints.resolve(env: env) || default_proxy
     end
 
-    def == other
-      other.is_a?(ForwardProxyBuilder) && self.default_proxy == other.default_proxy && self.endpoints == other.endpoints
+    def ==(other)
+      other.is_a?(ForwardProxyBuilder) && default_proxy == other.default_proxy && endpoints == other.endpoints
     end
 
-
     def forward_proxy(label:, url:, rule: nil)
-      ForwardProxy.new(url: url, id: label.to_sym, mapped_path: mapped_path, sitehub_cookie_path: sitehub_cookie_path, sitehub_cookie_name: sitehub_cookie_name, rule: rule)
+      ForwardProxy.new(url: url,
+                       id: label.to_sym,
+                       mapped_path: mapped_path,
+                       sitehub_cookie_path: sitehub_cookie_path,
+                       sitehub_cookie_name: sitehub_cookie_name,
+                       rule: rule)
     end
   end
-
-end
+end

data/lib/sitehub/http_headers.rb

@@ -9,52 +9,65 @@ class SiteHub
     RACK_HTTP_HEADER_ID = /#{HTTP_PREFIX.source}[A-Z_]+$/
     COMMAND_FOLLOWED_BY_SPACES = /,\s+/
 
+    SHOULD_NOT_TRANSFER = [PROXY_CONNECTION].freeze
+
+    HOP_BY_HOP = [CONNECTION_HEADER,
+                  KEEP_ALIVE,
+                  PROXY_AUTHENTICATE,
+                  PROXY_AUTHORIZATION,
+                  TE,
+                  TRAILERS,
+                  TRANSFER_ENCODING,
+                  CONTENT_ENCODING].freeze
+
     def split_field(f)
-      f ? f.split(COMMAND_FOLLOWED_BY_SPACES).collect { |i| i.downcase } : []
+      f ? f.split(COMMAND_FOLLOWED_BY_SPACES).collect(&:downcase) : []
     end
 
     def sanitise_headers(src)
-
-      sanitised_headers = {}
-
       connections = split_field(src[CONNECTION_HEADER])
-      src.each do |key, value|
-        key = key.downcase.gsub(UNDERSCORE, HYPHEN)
-        if HopByHop.member?(key) ||
-            connections.member?(key) ||
-            ShouldNotTransfer.member?(key)
-          next
-        end
-        sanitised_headers[key] = value
-      end
 
-      sanitised_headers[LOCATION_HEADER].gsub!(HTTP_OR_SSL_PORT, EMPTY_STRING) if sanitised_headers[LOCATION_HEADER]
+      {}.tap do |sanitised_headers|
+        src.each do |key, value|
+          key = key.downcase.gsub(UNDERSCORE, HYPHEN)
+          next if HOP_BY_HOP.member?(key) || connections.member?(key) || SHOULD_NOT_TRANSFER.member?(key)
+          sanitised_headers[key] = value
+        end
 
-      sanitised_headers
+        sanitised_headers[LOCATION_HEADER].gsub!(HTTP_OR_SSL_PORT, EMPTY_STRING) if sanitised_headers[LOCATION_HEADER]
+      end
     end
 
-
-
     def extract_http_headers(env)
-      headers = env.reject do |k, v|
-        !RackHttpHeaderKeys::HTTP_HEADER_FILTER_EXCEPTIONS.include?(k.to_s.upcase) && (!(RACK_HTTP_HEADER_ID === k) || v.nil?)
-      end.map do |k, v|
-        [reconstruct_header_name(k), v]
-      end.inject(Rack::Utils::HeaderHash.new) do |hash, k_v|
+      headers = remove_excluded_headers(env)
+
+      headers = headers.to_a.each_with_object(Rack::Utils::HeaderHash.new) do |k_v, hash|
         k, v = k_v
-        hash[k] = v
+        hash[reconstruct_header_name(k)] = v
         hash
       end
 
-      x_forwarded_for = (headers[X_FORWARDED_FOR_HEADER].to_s.split(COMMAND_FOLLOWED_BY_SPACES) << env[RackHttpHeaderKeys::REMOTE_ADDRESS_ENV_KEY]).join(COMMA_WITH_SPACE)
+      remote_address = env[RackHttpHeaderKeys::REMOTE_ADDRESS_ENV_KEY]
+      headers.merge!(X_FORWARDED_FOR_HEADER => x_forwarded_for_value(headers, remote_address))
+    end
 
-      headers.merge!(X_FORWARDED_FOR_HEADER => x_forwarded_for)
+    def x_forwarded_for_value(headers, remote_address)
+      (forwarded_address_list(headers) << remote_address).join(COMMA_WITH_SPACE)
     end
 
+    def forwarded_address_list(headers)
+      headers[X_FORWARDED_FOR_HEADER].to_s.split(COMMAND_FOLLOWED_BY_SPACES)
+    end
 
+    def remove_excluded_headers(env)
+      env.reject do |k, v|
+        !RackHttpHeaderKeys::HTTP_HEADER_FILTER_EXCEPTIONS.include?(k.to_s.upcase) &&
+          (!RACK_HTTP_HEADER_ID.match(k) || v.nil?)
+      end
+    end
 
     def reconstruct_header_name(name)
       name.sub(HTTP_PREFIX, EMPTY_STRING).gsub(UNDERSCORE, HYPHEN)
     end
   end
-end
+end

data/lib/sitehub/logging/access_logger.rb

@@ -1,9 +1,10 @@
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
 require 'logger'
 require 'rack/commonlogger'
 require_relative 'log_wrapper'
 require 'sitehub/constants'
 
-#Very heavily based on Rack::CommonLogger
+# Very heavily based on Rack::CommonLogger
 class SiteHub
   module Logging
     class AccessLogger
@@ -11,54 +12,57 @@ class SiteHub
 
       include Constants
 
-      FORMAT = %{%s - %s [%s] transaction_id:%s: "%s %s%s => %s %s" %d %s %0.4f\n}.freeze
-      PATH_INFO = RackHttpHeaderKeys::PATH_INFO
-      REQUEST_METHOD = RackHttpHeaderKeys::REQUEST_METHOD
-      SCRIPT_NAME = RackHttpHeaderKeys::SCRIPT_NAME
-      QUERY_STRING = RackHttpHeaderKeys::QUERY_STRING
-      X_FORWARDED_FOR = RackHttpHeaderKeys::X_FORWARDED_FOR
-      REMOTE_ADDR = RackHttpHeaderKeys::REMOTE_ADDR
-      HTTP_VERSION = RackHttpHeaderKeys::HTTP_VERSION
-      REMOTE_USER = RackHttpHeaderKeys::REMOTE_USER
-      TRANSACTION_ID = RackHttpHeaderKeys::TRANSACTION_ID
-      CONTENT_LENGTH = HttpHeaderKeys::CONTENT_LENGTH
-      ZERO_STRING = '0'
+      FORMAT = %(%s - %s [%s] transaction_id:%s: "%s %s%s => %s %s" %d %s %0.4f\n).freeze
+      ZERO_STRING = '0'.freeze
       STATUS_RANGE = 0..3
 
-      def initialize app, logger = ::Logger.new(STDOUT)
+      def initialize(app, logger = ::Logger.new(STDOUT))
         @app = app
         @logger = LogWrapper.new(logger)
       end
 
-      def call env
+      def call(env)
         start_time = Time.now
 
         @app.call(env).tap do |response|
-          status, headers, body = response.to_a
-          log env, status, headers, env[REQUEST_MAPPING], start_time
+          status, headers, _body = response.to_a
+          log_message = format(log_template, *log_content(start_time, env, headers, env[REQUEST_MAPPING], status))
+          logger.write(log_message)
         end
       end
 
-      def log(env, status, header, mapped_request, began_at)
+      def log_content(began_at, env, header, mapped_request, status)
         now = Time.now
-        length = extract_content_length(header)
+        [
+          source_address(env),
+          remote_user(env[RackHttpHeaderKeys::REMOTE_USER]),
+          now.strftime(TIME_STAMP_FORMAT),
+          env[RackHttpHeaderKeys::TRANSACTION_ID],
+          env[RackHttpHeaderKeys::REQUEST_METHOD],
+          env[RackHttpHeaderKeys::PATH_INFO],
+          query_string(env[RackHttpHeaderKeys::QUERY_STRING]),
+          mapped_url(mapped_request),
+          env[RackHttpHeaderKeys::HTTP_VERSION],
+          status.to_s[STATUS_RANGE],
+          extract_content_length(header),
+          now - began_at
+        ]
+      end
 
+      def mapped_url(mapped_request)
+        mapped_request ? mapped_request.mapped_url.to_s : EMPTY_STRING
+      end
 
-        msg = log_template % [
-            env[X_FORWARDED_FOR] || env[REMOTE_ADDR] || HYPHEN,
-            env[REMOTE_USER] || "-",
-            now.strftime(TIME_STAMP_FORMAT),
-            env[TRANSACTION_ID],
-            env[REQUEST_METHOD],
-            env[PATH_INFO],
-            env[QUERY_STRING].empty? ? EMPTY_STRING : QUESTION_MARK+env[QUERY_STRING],
-            mapped_request ? mapped_request.mapped_url.to_s : EMPTY_STRING,
-            env[HTTP_VERSION],
-            status.to_s[STATUS_RANGE],
-            length,
-            now - began_at]
+      def query_string(query_string)
+        query_string.empty? ? EMPTY_STRING : QUESTION_MARK + query_string
+      end
+
+      def remote_user(remote_user)
+        remote_user || '-'
+      end
 
-        logger.write(msg)
+      def source_address(env)
+        env[RackHttpHeaderKeys::X_FORWARDED_FOR] || env[RackHttpHeaderKeys::REMOTE_ADDR] || HYPHEN
       end
 
       def log_template
@@ -66,9 +70,9 @@ class SiteHub
       end
 
       def extract_content_length(headers)
-        value = headers[CONTENT_LENGTH] or return HYPHEN
+        (value = headers[HttpHeaderKeys::CONTENT_LENGTH]) || (return HYPHEN)
         value.to_s == ZERO_STRING ? HYPHEN : value
       end
     end
   end
-end
+end

data/lib/sitehub/logging/error_logger.rb

@@ -6,8 +6,7 @@ class SiteHub
   module Logging
     class ErrorLogger
       include Constants
-      LOG_TEMPLATE = '[%s] ERROR: %s - %s'
-
+      LOG_TEMPLATE = '[%s] ERROR: %s - %s'.freeze
 
       attr_reader :logger
 
@@ -16,11 +15,13 @@ class SiteHub
         @logger = LogWrapper.new(logger)
       end
 
-      def call env
+      def call(env)
         env[ERRORS] ||= LogStash.new
         @app.call(env).tap do
           unless env[ERRORS].empty?
-            messages = env[ERRORS].collect { |log_entry| log_message(error: log_entry.message, transaction_id: env[RackHttpHeaderKeys::TRANSACTION_ID]) }
+            messages = env[ERRORS].collect do |log_entry|
+              log_message(error: log_entry.message, transaction_id: env[RackHttpHeaderKeys::TRANSACTION_ID])
+            end
 
             logger.write(messages.join(NEW_LINE))
           end
@@ -28,9 +29,8 @@ class SiteHub
       end
 
       def log_message(error:, transaction_id:)
-        LOG_TEMPLATE % [Time.now.strftime(TIME_STAMP_FORMAT), transaction_id, error]
+        format(LOG_TEMPLATE, Time.now.strftime(TIME_STAMP_FORMAT), transaction_id, error)
       end
-
     end
   end
-end
+end

data/lib/sitehub/logging/log_entry.rb

@@ -2,13 +2,14 @@ class SiteHub
   module Logging
     class LogEntry
       attr_reader :message, :time
-      def initialize message, time=Time.now
-        @message, @time = message, time
+      def initialize(message, time = Time.now)
+        @message = message
+        @time = time
       end
 
-      def == other
-        other.is_a?(LogEntry) && self.message == other.message && self.time == other.time
+      def ==(other)
+        other.is_a?(LogEntry) && message == other.message && time == other.time
       end
     end
   end
-end
+end

data/lib/sitehub/logging/log_stash.rb

@@ -2,9 +2,9 @@ require_relative 'log_entry'
 class SiteHub
   module Logging
     class LogStash < Array
-      def << message
+      def <<(message)
         super(LogEntry.new(message))
       end
     end
   end
-end
+end

data/lib/sitehub/logging/log_wrapper.rb

@@ -3,11 +3,11 @@ class SiteHub
     class LogWrapper
       attr_reader :logger
 
-      def initialize logger
+      def initialize(logger)
         @logger = logger
       end
 
-      def write msg
+      def write(msg)
         if logger.respond_to?(:<<)
           logger << msg
         elsif logger.respond_to?(:write)
@@ -15,9 +15,9 @@ class SiteHub
         end
       end
 
-      def == other
-        other.is_a?(LogWrapper) && self.logger == other.logger
+      def ==(other)
+        other.is_a?(LogWrapper) && logger == other.logger
       end
     end
   end
-end
+end

data/lib/sitehub/logging.rb

@@ -2,4 +2,4 @@ require_relative 'logging/access_logger'
 require_relative 'logging/error_logger'
 require_relative 'logging/log_entry'
 require_relative 'logging/log_stash'
-require_relative 'logging/log_wrapper'
+require_relative 'logging/log_wrapper'

data/lib/sitehub/middleware.rb

@@ -5,7 +5,7 @@ class SiteHub
     end
 
     def use(middleware_clazz, *args, &block)
-      middlewares << [middleware_clazz, args, block|| proc{}]
+      middlewares << [middleware_clazz, args, block || proc {}]
     end
 
     def apply_middleware(forward_proxy)
@@ -18,4 +18,4 @@ class SiteHub
       end
     end
   end
-end
+end

data/lib/sitehub/path_directive.rb

@@ -2,31 +2,31 @@ class SiteHub
   class PathDirective
     attr_reader :matcher, :path_template
 
-    def initialize matcher, path_template
-      @matcher, @path_template = matcher, path_template
+    def initialize(matcher, path_template)
+      @matcher = matcher
+      @path_template = path_template
     end
 
-    def match? url
-      !!matcher.match(url)
+    def match?(url)
+      !matcher.match(url).nil?
     end
 
     def path_template
       @path_template.dup
     end
 
-    def apply url
+    def apply(url)
       url_components = matcher.match(url).captures
 
       path_template.tap do |p|
         url_components.each_with_index do |m, index|
-          p.gsub!(RequestMapping::CAPTURE_GROUP_REFERENCE % (index+1), m)
+          p.gsub!(RequestMapping::CAPTURE_GROUP_REFERENCE % (index + 1), m)
         end
       end
-
     end
 
-    def == other
-      other.is_a?(PathDirective) && self.matcher == other.matcher && self.path_template == other.path_template
+    def ==(other)
+      other.is_a?(PathDirective) && matcher == other.matcher && path_template == other.path_template
     end
   end
-end
+end

data/lib/sitehub/path_directives.rb

@@ -1,11 +1,12 @@
 require 'sitehub/path_directive'
 class SiteHub
   class PathDirectives < Array
-    def initialize map={}
+    def initialize(map = {})
       enriched = map.map do |array|
-        matcher,path_template = array.first, array.last
+        matcher = array.first
+        path_template = array.last
 
-        matcher = matcher.is_a?(Regexp) ? matcher : %r{#{matcher}}
+        matcher = matcher.is_a?(Regexp) ? matcher : /#{matcher}/
         PathDirective.new(matcher, path_template)
       end
 
@@ -18,4 +19,4 @@ class SiteHub
       end
     end
   end
-end
+end