wayfarer 0.4.0 → 0.4.1

data/lib/wayfarer/middleware/worker.rb

@@ -6,6 +6,7 @@ module Wayfarer
       def self.included(base)
         base.include(Wayfarer::Redis::Connection)
         base.include(Wayfarer::Middleware::Stage::API)
+        base.include(Wayfarer::Callbacks)
         base.include(InstanceMethods)
         base.extend(ClassMethods)
       end
@@ -21,25 +22,27 @@ module Wayfarer
       module InstanceMethods
         extend Forwardable
 
-        attr_accessor :task
-
-        delegate %i[params adapter] => "task.metadata"
-        delegate %i[browser capybara] => :adapter
+        delegate %i[params agent] => "task.metadata"
 
         def call(task)
-          self.task = task
-          public_send(task.metadata.action)
-          yield if block_given?
+          run_callbacks :action do
+            public_send(task.metadata.action)
+            yield if block_given? # TODO: Should be excluded from callback block
+          end
         end
 
         def chain
-          Wayfarer::Middleware::Chain.new([*Wayfarer.core_middleware, self])
+          Wayfarer::Middleware::Chain.new([*Wayfarer.middleware, self])
+        end
+
+        def browser
+          agent.instance
         end
 
         def page(live: false)
           return task.metadata.page unless live
 
-          task.metadata.page = adapter.live(task.metadata.page)
+          task.metadata.page = agent.live&.page || task.metadata.page
         end
       end
     end

data/lib/wayfarer/networking/capybara.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Networking
+    class Capybara
+      include Strategy
+
+      def create
+        ::Capybara::Session.new(Wayfarer.config.capybara.driver, nil)
+      end
+
+      def destroy(instance)
+        instance.quit
+      end
+
+      def navigate(instance, url)
+        instance.visit(url)
+      end
+
+      def live(instance)
+        success(url: instance.current_url,
+                body: instance.html,
+                status_code: instance.status_code,
+                headers: instance.response_headers)
+      end
+    end
+  end
+end

data/lib/wayfarer/networking/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Networking
+    Context = Struct.new(:strategy) do
+      def fetch(url)
+        supervise { strategy.fetch(instance, url) }
+      end
+
+      def live
+        supervise { strategy.live(instance) }
+      end
+
+      def renew
+        strategy.destroy(instance)
+      ensure
+        @instance = nil
+      end
+
+      def instance
+        @instance ||= strategy.create
+      end
+
+    private
+
+      def supervise
+        yield
+      rescue *strategy.renew_on => e
+        renew
+      ensure
+        # If renewing raises, re-raise the originally caught exception
+        raise e if e
+      end
+    end
+  end
+end

data/lib/wayfarer/networking/ferrum.rb

@@ -3,67 +3,32 @@
 module Wayfarer
   module Networking
     class Ferrum
-      def self.renew_on
-        [::Ferrum::DeadBrowserError]
-      end
-
-      attr_reader :browser
-
-      def initialize
-        @browser = instantiate_browser
-      end
-
-      def fetch(url)
-        browser.goto(url)
-        Result::Success.new(live(nil))
-      end
-
-      def live(_)
-        Wayfarer::Page.new(url: browser.current_url,
-                           body: body,
-                           status_code: browser.network.response.status,
-                           headers: browser.network.response.headers)
-      end
+      include Strategy
 
-      def body
-        browser.body
+      def renew_on
+        [::Ferrum::DeadBrowserError]
       end
 
-      def renew
-        free
-        @browser = instantiate_browser
+      def create
+        ::Ferrum::Browser.new(Wayfarer.config.ferrum.options).tap do |browser|
+          browser.headers.set(Wayfarer.config.network.http_headers)
+        end
       end
 
-      def free
-        browser&.reset
-        browser&.quit
-        @browser = nil
-        @capybara = nil
+      def destroy(instance)
+        instance.reset
+        instance.quit
       end
 
-      def capybara
-        @capybara ||= instantiate_capybara_driver
+      def navigate(instance, url)
+        instance.goto(url)
       end
 
-    private
-
-      def instantiate_browser
-        ::Ferrum::Browser.new(Wayfarer.config.ferrum_options).tap do |browser|
-          browser.headers.set(Wayfarer.config.http_headers)
-        end
-      end
-
-      def instantiate_capybara_driver
-        Capybara.run_server = false
-        Capybara.current_driver = :cuprite
-
-        capybara_driver = Capybara::Cuprite::Driver.new(nil)
-        capybara_driver.instance_variable_set(:@capybara, browser)
-
-        session = Capybara::Session.new(:cuprite, nil)
-        session.instance_variable_set(:@driver, capybara_driver)
-
-        session
+      def live(instance)
+        success(url: instance.current_url,
+                body: instance.body,
+                status_code: instance.network.response.status,
+                headers: instance.network.response.headers)
       end
     end
   end

data/lib/wayfarer/networking/http.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Networking
+    class HTTP
+      include Strategy
+
+      CONNECTION_NAME = "wayfarer"
+
+      def create
+        Net::HTTP::Persistent.new(name: CONNECTION_NAME).tap do |conn|
+          Wayfarer.config.network.http_headers.each do |key, val|
+            conn.override_headers[key] = val
+          end
+        end
+      end
+
+      def destroy(instance)
+        instance.shutdown
+      end
+
+      def fetch(instance, url)
+        res = instance.request(URI(url))
+
+        return redirect(res["location"]) if res.is_a?(Net::HTTPRedirection)
+
+        success(url: url,
+                status_code: res.code.to_i,
+                body: res.body,
+                headers: res.to_hash.transform_values(&:first))
+      end
+    end
+  end
+end

data/lib/wayfarer/networking/pool.rb

@@ -6,28 +6,33 @@ module Wayfarer
       include Singleton
       extend Forwardable
 
+      cattr_accessor :registry, default: { http: HTTP,
+                                           ferrum: Ferrum,
+                                           selenium: Selenium,
+                                           capybara: Capybara }
+
       attr_reader :pool
 
       def initialize
-        @pool = ConnectionPool.new(size: Wayfarer.config.adapter_pool_size,
-                                   timeout: Wayfarer.config.adapter_pool_timeout,
-                                   &method(:instantiate_adapter))
+        @pool = ConnectionPool.new(size: Wayfarer.config.network.pool_size,
+                                   timeout: Wayfarer.config.network.pool_timeout,
+                                   &method(:context))
       end
 
       delegate with: :pool
 
       def free
-        pool.shutdown(&:free)
+        pool.shutdown(&:renew)
       end
 
     private
 
-      def instantiate_adapter
-        Healer.new(case Wayfarer.config.adapter
-                   when :net_http then Wayfarer::Networking::NetHTTP.instance
-                   when :selenium then Wayfarer::Networking::Selenium.new
-                   when :ferrum then Wayfarer::Networking::Ferrum.new
-                   end)
+      def context
+        Wayfarer::Networking::Context.new(strategy)
+      end
+
+      def strategy
+        self.class.registry[Wayfarer.config.network.agent].new
       end
     end
   end

data/lib/wayfarer/networking/result.rb

@@ -12,7 +12,7 @@ module Wayfarer
       # Signals that a URL resulted in response with 3xx.
       # @!attribute [rw] redirect_url
       #   @return [URI] Where to go next.
-      Redirect = Struct.new(:request_url, :redirect_url)
+      Redirect = Struct.new(:redirect_url)
     end
   end
 end

data/lib/wayfarer/networking/selenium.rb

@@ -3,67 +3,40 @@
 module Wayfarer
   module Networking
     class Selenium
-      def self.renew_on
-        [] # TODO: Figure out when to renew
-      end
-
-      FAKE_STATUS_CODE = 200
-      FAKE_RESPONSE_HEADERS = {}.freeze
-
-      attr_reader :browser
+      include Strategy
 
-      def initialize
-        @browser = instantiate_browser
-      end
-
-      def fetch(url)
-        browser.navigate.to(url)
-        Result::Success.new(live(nil))
-      end
+      MOCK_STATUS_CODE = 200
+      MOCK_RESPONSE_HEADERS = {}.freeze
 
-      def live(_)
-        Wayfarer::Page.new(url: browser.current_url,
-                           body: browser.page_source,
-                           status_code: FAKE_STATUS_CODE,
-                           headers: FAKE_RESPONSE_HEADERS)
+      def create
+        ::Selenium::WebDriver.for(Wayfarer.config.selenium.driver, **options)
       end
 
-      def body
-        browser.page_source
+      def destroy(instance)
+        instance.quit
       end
 
-      def renew
-        free
-        @browser = instantiate_browser
+      def navigate(instance, url)
+        instance.navigate.to(url)
       end
 
-      def free
-        browser&.quit
-        @browser = nil
-        @capybara = nil
-      end
-
-      def capybara
-        @capybara ||= instantiate_capybara_driver
+      def live(instance)
+        success(url: instance.current_url,
+                body: instance.page_source,
+                status_code: MOCK_STATUS_CODE,
+                headers: MOCK_RESPONSE_HEADERS)
       end
 
     private
 
-      def instantiate_browser
-        ::Selenium::WebDriver.for(*Wayfarer.config.selenium_argv)
+      def options
+        Wayfarer.config.selenium.options.merge(http_client: http_client)
       end
 
-      def instantiate_capybara_driver
-        Capybara.run_server = false
-        Capybara.current_driver = :selenium
-
-        capybara_driver = Capybara::Selenium::Driver.new(nil)
-        capybara_driver.instance_variable_set(:@capybara, browser)
-
-        session = Capybara::Session.new(:selenium, nil)
-        session.instance_variable_set(:@driver, capybara_driver)
-
-        session
+      def http_client
+        ::Selenium::WebDriver::Remote::Http::Default.new.tap do |client|
+          client.read_timeout = Wayfarer.config.selenium.client_timeout
+        end
       end
     end
   end

data/lib/wayfarer/networking/strategy.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Networking
+    module Strategy
+      def renew_on
+        []
+      end
+
+      def fetch(instance, url)
+        navigate(instance, url)
+        live(instance)
+      end
+
+      def navigate(_instance, _url)
+        raise NoMethodError
+      end
+
+      def live(_instance); end
+
+      def create
+        raise NoMethodError
+      end
+
+      def destroy(_instance); end
+
+    private
+
+      def success(...)
+        Wayfarer::Networking::Result::Success.new(Wayfarer::Page.new(...))
+      end
+
+      def redirect(...)
+        Wayfarer::Networking::Result::Redirect.new(...)
+      end
+    end
+  end
+end

data/lib/wayfarer/page.rb

@@ -4,11 +4,10 @@ module Wayfarer
   class Page
     attr_reader :url,
                 :status_code,
+                :body,
                 :headers
 
-    attr_accessor :body
-
-    def initialize(url:, status_code:, headers:, body:)
+    def initialize(url:, status_code:, body:, headers:)
       @url = url
       @status_code = status_code
       @body = body

data/lib/wayfarer/redis/pool.rb

@@ -9,7 +9,9 @@ module Wayfarer
       attr_reader :pool
 
       def initialize
-        @pool = ConnectionPool.new(&Wayfarer.config.redis_factory)
+        @pool = ConnectionPool.new do
+          Wayfarer.config.redis.factory.call(Wayfarer.config.redis)
+        end
       end
 
       delegate with: :pool

data/lib/wayfarer/routing/dsl.rb

@@ -4,40 +4,40 @@ module Wayfarer
   module Routing
     module DSL
       def url(url, options = {}, &block)
-        add_child_route(URLMatcher.new(url), path_offset, options, &block)
+        add_child_route(Matchers::URL.new(url), path_offset, options, &block)
       end
 
       def host(host, options = {}, &block)
-        add_child_route(HostMatcher.new(host), path_offset, options, &block)
+        add_child_route(Matchers::Host.new(host), path_offset, options, &block)
       end
 
       def path(path, options = {}, &block)
         offset = File.join(path_offset, path)
         add_child_route(nil, offset, options, &block).tap do |route|
-          route.matcher = PathMatcher.new(offset, route)
+          route.matcher = Matchers::Path.new(offset, route)
         end
       end
 
       def query(fields, options = {}, &block)
-        add_child_route(QueryMatcher.new(fields), path_offset, options, &block)
+        add_child_route(Matchers::Query.new(fields), path_offset, options, &block)
       end
 
       def scheme(scheme, options = {}, &block)
-        add_child_route(SchemeMatcher.new(scheme), path_offset, options, &block)
+        add_child_route(Matchers::Scheme.new(scheme), path_offset, options, &block)
       end
 
       def suffix(suffix, options = {}, &block)
-        add_child_route(SuffixMatcher.new(suffix), path_offset, options, &block)
+        add_child_route(Matchers::Suffix.new(suffix), path_offset, options, &block)
       end
 
       def to(action, options = {}, &block)
-        add_child_route(CustomMatcher.new { true }, path_offset, TargetRoute, options, &block).tap do |route|
+        add_child_route(Matchers::Custom.new { true }, path_offset, TargetRoute, options, &block).tap do |route|
           route.action = action
         end
       end
 
       def custom(delegate, options = {}, &block)
-        add_child_route(CustomMatcher.new(delegate), path_offset, options, &block)
+        add_child_route(Matchers::Custom.new(delegate), path_offset, options, &block)
       end
 
     private

data/lib/wayfarer/routing/matchers/custom.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      class Custom
+        attr_reader :delegate
+
+        def initialize(delegate = proc)
+          @delegate = delegate
+        end
+
+        def match(url)
+          !!delegate.call(url)
+        end
+
+        def params(_)
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/matchers/host.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      Host = Struct.new(:host) do
+        # rubocop:disable Style/CaseEquality
+        def match(url)
+          host === url.host
+        end
+        # rubocop:enable Style/CaseEquality
+
+        def params(_)
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/matchers/path.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      class Path
+        attr_reader :path,
+                    :route,
+                    :peeking,
+                    :matcher
+
+        def initialize(path, route)
+          @path = path
+          @route = route
+          @peeking = false
+          @matcher = Mustermann.new(path, type: "sinatra")
+        end
+
+        def match(url)
+          route.accept(self)
+
+          # If the route's branch contains other path matchers in child routes,
+          # match the beginning of the path (peeking), instead of the whole path.
+          !!(if peeking
+               matcher.peek(url.path)
+             else
+               matcher.match(url.path)
+             end)
+        end
+
+        def params(url)
+          return {} unless match(url)
+
+          matcher.params(url.path) || {}
+        end
+
+        def visit(route)
+          return true if route == self.route
+
+          return unless route.matcher.is_a?(self.class)
+
+          @peeking = true
+          false
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/matchers/query.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      Query = Struct.new(:fields) do
+        def match(url)
+          query = url.query
+
+          # CGI::parse throws a NoMethodError if the query is an empty string
+          return false if query.nil? || query.empty?
+
+          CGI.parse(query).none? { |field, vals| violates?(field, vals) }
+        end
+
+        def params(url)
+          return {} unless match(url)
+
+          CGI.parse(url.query)
+             .select { |(k, _)| fields.keys.include?(k.to_sym) }
+             .transform_values(&:last)
+        end
+
+      private
+
+        # rubocop:disable Lint/AssignmentInCondition
+        def violates?(field, vals)
+          return false unless constraint = fields[field.to_sym]
+
+          violates_constraint?(constraint, vals)
+        end
+        # rubocop:enable Lint/AssignmentInCondition
+
+        def violates_constraint?(constraint, vals)
+          case constraint
+          when String  then violates_string?(constraint, vals)
+          when Integer then violates_integer?(constraint, vals)
+          when Regexp  then violates_regexp?(constraint, vals)
+          when Range   then violates_range?(constraint, vals)
+          end
+        end
+
+        def violates_string?(str, vals)
+          vals.none? { |val| str == val }
+        end
+
+        def violates_integer?(int, vals)
+          vals.none? { |val| int == Integer(val) }
+        rescue ArgumentError
+          true
+        end
+
+        def violates_regexp?(regexp, vals)
+          vals.none? { |val| regexp.match(val) }
+        end
+
+        def violates_range?(range, vals)
+          vals.none? { |val| range.include?(val.to_i) }
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/matchers/scheme.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      Scheme = Struct.new(:scheme) do
+        def match(url)
+          url.scheme == scheme.to_s
+        end
+
+        def params(_)
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/matchers/suffix.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      Suffix = Struct.new(:suffix) do
+        def match(url)
+          url.path.end_with?(suffix)
+        end
+
+        def params(_)
+          {}
+        end
+      end
+    end
+  end
+end