Extract Rule::Candidate

Author: waterlink

lib/rack_reverse_proxy/rule.rb

@@ -5,65 +5,26 @@ class Rule
     attr_reader :options
 
     def initialize(spec, url = nil, options = {})
-      @default_url = url
+      @custom_url = url.nil?
       @url = url
       @options = options
       @spec = build_matcher(spec)
     end
 
     def proxy?(path, *args)
-      match_path(path, *args).count > 0
+      _matches(path, *args).count > 0
     end
 
-    # Lots of calls with passing path and env around
-    # Sounds like a class to me, Candidate?
     def get_uri(path, env)
-      return nil unless url
-      evaluated_url = evaluate_url(env)
-      if with_substitutions?(evaluated_url)
-        substitute_matches(evaluated_url, path)
-      else
-        build_simple_url(evaluated_url, path)
-      end
+      Candidate.new(self, url, custom_url, path, env).build_uri
     end
 
     def to_s
       %("#{spec}" => "#{url}")
     end
 
-    private
-
-    attr_reader :spec, :url, :default_url
-
-    def build_simple_url(url, path)
-      return URI.parse(url) unless default_url
-      URI.join(url, path)
-    end
-
-    def evaluate_url(env)
-      return url.clone unless url.respond_to?(:call)
-      url.call(env)
-    end
-
-    def with_substitutions?(url)
-      url =~ /\$\d/
-    end
-
-    # FIXME: This function currently is stressful for GC
-    def substitute_matches(url, path)
-      match_path(path).each_with_index do |match, i|
-        url = url.gsub("$#{i}", match)
-      end
-      URI(url)
-    end
-
-    def build_matcher(spec)
-      return /^#{spec}/ if spec.is_a?(String)
-      return spec if spec.respond_to?(:match)
-      fail ArgumentError, "Invalid Rule for reverse_proxy"
-    end
-
-    def match_path(path, *args)
+    # @private
+    def _matches(path, *args)
       headers = args[0]
       rackreq = args[1]
       arity = spec.method(:match).arity
@@ -74,12 +35,77 @@ def match_path(path, *args)
         match = spec.match(*params[0..(arity - 1)])
       end
       # FIXME: This state mutation is very confusing
-      @url = match.url(path) if match && default_url.nil?
+      @url = match.url(path) if match && custom_url
       Array(match)
     end
 
-    # Candidate represents a path being verified
+    private
+
+    attr_reader :spec, :url, :custom_url
+
+    def build_matcher(spec)
+      return /^#{spec}/ if spec.is_a?(String)
+      return spec if spec.respond_to?(:match)
+      fail ArgumentError, "Invalid Rule for reverse_proxy"
+    end
+
+    # Candidate represents a request being matched
     class Candidate
+      def initialize(rule, url, custom_url, path, env)
+        @rule = rule
+        @env = env
+        @path = path
+        @custom_url = custom_url
+
+        @url = evaluate(url)
+      end
+
+      def build_uri
+        return nil unless url
+        URI(raw_uri)
+      end
+
+      private
+
+      attr_reader :rule, :url, :custom_url, :path, :env
+
+      def raw_uri
+        return substitute_matches if with_substitutions?
+        return just_uri if custom_url
+        uri_with_path
+      end
+
+      def just_uri
+        URI.parse(url)
+      end
+
+      def uri_with_path
+        URI.join(url, path)
+      end
+
+      def evaluate(url)
+        return unless url
+        return url.call(env) if lazy?(url)
+        url.clone
+      end
+
+      def lazy?(url)
+        url.respond_to?(:call)
+      end
+
+      def with_substitutions?
+        url =~ /\$\d/
+      end
+
+      def substitute_matches
+        matches.each_with_index.inject(url) do |url, (match, i)|
+          url.gsub("$#{i}", match)
+        end
+      end
+
+      def matches
+        rule._matches(path)
+      end
     end
   end
 end