wayfarer 0.0.3 → 0.4.3

data/lib/wayfarer/page.rb

@@ -1,94 +1,37 @@
 # frozen_string_literal: true
 
-require "ostruct"
-require "forwardable"
-require "mime/types"
-require "mime-types"
-
-require "pismo" unless RUBY_PLATFORM == "java"
-
 module Wayfarer
-  # The representation of fetched pages
   class Page
-    extend Forwardable
-
-    include Finders
-
-    # @!attribute [r] uri
-    # @return [URI] the URI of the page.
-    attr_reader :uri
-
-    # @!attribute [r] status_code
-    # @return [Fixnum] the response status code.
-    attr_reader :status_code
-
-    # @!attribute [r] body
-    # @return [String] the response body.
-    attr_accessor :body
-
-    # @!attribute [r] headers
-    # @return [Hash] the response headers.
-    attr_reader :headers
-
-    def initialize(attrs = {})
-      @uri         = attrs[:uri]
-      @status_code = attrs[:status_code]
-      @body        = attrs[:body]
-      @headers     = attrs[:headers]
+    attr_reader :url,
+                :status_code,
+                :body,
+                :headers
+
+    def initialize(url:, status_code:, body:, headers:)
+      @url = url
+      @status_code = status_code
+      @body = body
+      @headers = headers.transform_keys(&:downcase)
     end
 
-    # Returns a parsed representation of the fetched document depending on the
-    # Content-Type field.
-    # @return [OpenStruct] if the Content-Type field's sub-type is "json".
-    # @return [Nokogiri::XML::Document] if the Content-Type field's sub-type is "xml".
-    # @return [Nokogiri::HTML::Document] otherwise.
     def doc
       return @doc if @doc
 
       # If no Content-Type field is present, assume HTML/XML
-      # TODO: Test
-      unless @headers["content-type"]
-        return @doc = Parsers::XMLParser.parse_html(@body)
-      end
+      return @doc = Wayfarer::Parsing::XML.parse_html(body) unless headers["content-type"]
 
-      content_type = @headers["content-type"].first
+      content_type = headers["content-type"]
       sub_type = MIME::Types[content_type].first.sub_type
 
-      # TODO: Tests
       @doc = case sub_type
-             when "json"
-               Parsers::JSONParser.parse(@body)
-             when "xml"
-               Parsers::XMLParser.parse_xml(@body)
-             else
-               Parsers::XMLParser.parse_html(@body)
+             when "json" then Wayfarer::Parsing::JSON.parse(body)
+             when "xml" then Wayfarer::Parsing::XML.parse_xml(body)
+             else Wayfarer::Parsing::XML.parse_html(body)
              end
     end
 
-    # Pismo is not supported on JRuby.
-    unless RUBY_PLATFORM == "java"
-      # `#images` is included from the Helpers module
-      # `#body` is an attribute reader defined above
-      delegate (Pismo::Document::ATTRIBUTE_METHODS - %i[images body]) => :pismo
-    end
-
-    private
-
-    # Returns a Pismo document.
-    # @note Not available on JRuby.
-    # @note Only succeeds when {#doc} returns a `Nokogiri::HTML::Document`.
-    # @return [Pismo::Document]
-    def pismo
-      @pismo_doc ||= instantiate_pismo_document
-    end
-
-    def instantiate_pismo_document
-      doc = Pismo::Document.allocate
-      doc.instance_variable_set(:@options, {})
-      doc.instance_variable_set(:@url, uri)
-      doc.instance_variable_set(:@html, body)
-      doc.instance_variable_set(:@doc, self.doc)
-      doc
+    def meta
+      @meta ||= MetaInspector.new(url, document: body)
     end
   end
 end

data/lib/wayfarer/parsing/json.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Parsing
+    module JSON
+    module_function
+
+      def parse(json)
+        if defined?(Oj)
+          Oj.load(json)
+        else
+          ::JSON.parse(json)
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/parsing/xml.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Parsing
+    module XML
+    module_function
+
+      def parse_xml(xml)
+        Nokogiri::XML(xml)
+      end
+
+      def parse_html(html)
+        Nokogiri::HTML(html)
+      end
+    end
+  end
+end

data/lib/wayfarer/redis/.#barrier.rb

@@ -0,0 +1 @@
+lib/wayfarer/redis/bauerd@Dominics-MacBook-Pro.local.61933

data/lib/wayfarer/redis/barrier.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Redis
+    Barrier = Struct.new(:batch) do
+      include Connection
+
+      def redis_key
+        "wayfarer-barrier-#{batch}"
+      end
+
+      def reset!
+        redis { |conn| conn.del(redis_key) }
+      end
+
+      def seen?(url)
+        !redis { |conn| conn.sadd(redis_key, url) }
+      end
+
+      def peek(urls)
+        major, minor, = Version.determine
+
+        # SMISMEMBER is only supported on Redis >= 6.2.0
+        if major > 6 || (major == 6 && minor >= 2)
+          redis { |conn| conn.smismember(redis_key, urls) }.map { |val| val == 1 }
+        else
+          urls.map { |url| redis { |conn| conn.sismember(redis_key, url) } }
+        end
+      end
+
+      def unsee(url)
+        redis { |conn| conn.srem(redis_key, url) }
+      end
+    end
+  end
+end

data/lib/wayfarer/redis/connection.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Redis
+    module Connection
+      extend Forwardable
+
+      delegate with: "Wayfarer::Redis::Pool.instance"
+
+      alias redis with
+    end
+  end
+end

data/lib/wayfarer/redis/counter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Redis
+    Counter = Struct.new(:batch) do
+      include Connection
+
+      def redis_key
+        "wayfarer-counter-#{batch}"
+      end
+
+      def reset!
+        redis { |conn| conn.del(redis_key) }
+      end
+
+      def value
+        redis { |conn| conn.get(redis_key) }.to_i
+      end
+
+      def increment
+        redis { |conn| conn.incr(redis_key) }
+      end
+
+      def decrement
+        redis { |conn| conn.decr(redis_key) }
+      end
+    end
+  end
+end

data/lib/wayfarer/redis/pool.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Redis
+    class Pool
+      include Singleton
+      extend Forwardable
+
+      attr_reader :pool
+
+      def initialize
+        @pool = ConnectionPool.new do
+          Wayfarer.config.redis.factory.call(Wayfarer.config.redis)
+        end
+      end
+
+      delegate with: :pool
+    end
+  end
+end

data/lib/wayfarer/redis/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Redis
+    module Version
+      extend Connection
+
+    module_function
+
+      def determine
+        @determine ||= server_version.split(".").first(3).map(&:to_i)
+      end
+
+      def server_version
+        redis { |conn| conn.info["redis_version"] }
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/dsl.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module DSL
+      def url(url, options = {}, &block)
+        add_child_route(Matchers::URL.new(url), path_offset, options, &block)
+      end
+
+      def host(host, 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 = Matchers::Path.new(offset, route)
+        end
+      end
+
+      def query(fields, options = {}, &block)
+        add_child_route(Matchers::Query.new(fields), path_offset, options, &block)
+      end
+
+      def scheme(scheme, options = {}, &block)
+        add_child_route(Matchers::Scheme.new(scheme), path_offset, options, &block)
+      end
+
+      def suffix(suffix, options = {}, &block)
+        add_child_route(Matchers::Suffix.new(suffix), path_offset, options, &block)
+      end
+
+      def to(action, options = {}, &block)
+        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(Matchers::Custom.new(delegate), path_offset, options, &block)
+      end
+
+    private
+
+      # rubocop:disable Style/OptionalArguments
+      def add_child_route(matcher, path_offset, klass = Route, options, &block)
+        klass.new(matcher, path_offset, &block).tap do |route|
+          route.parent = self
+          leaf = options.reduce(route) { |acc, (key, val)| acc.public_send(key, val) }
+          children.push(route)
+          Docile.dsl_eval(leaf, &block) if block_given?
+        end
+      end
+      # rubocop:enable Style/OptionalArguments
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      class Custom
+        include Stringify
+
+        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,49 @@
+# 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 true if route.is_a?(TargetRoute)
+
+          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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      URL = Struct.new(:url) do
+        def match(url)
+          url == Addressable::URI.parse(self.url)
+        end
+
+        def params(_)
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/path_finder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    class PathFinder
+      def self.result(route, url)
+        finder = new(url)
+        route.accept(finder)
+        return Result::Mismatch.new if finder.path.none?
+
+        Result::Match.new(finder.action, finder.params)
+      end
+
+      attr_reader :url,
+                  :path,
+                  :action,
+                  :params
+
+      def initialize(url)
+        @url = url
+        @path = []
+        @action = nil
+        @params = {}
+      end
+
+      def visit(route)
+        return false if path.any?
+        return false unless route.match(url)
+
+        follow(route) if route.children.none?
+        true
+      end
+
+    private
+
+      # Follows the route back to the root. Collects parameters and action on
+      # the way.
+      def follow(route)
+        path.unshift(route)
+        @params.merge!(route.matcher.params(url))
+        @action = route.action unless action
+        follow(route.parent) if route.parent
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Result
+      # Signals that a URL matched a route.
+      # @!attribute [rw] action
+      #   @return [Page] the retrieved page.
+      Match = Struct.new(:action, :params)
+
+      # Signals that a URL matched no route.
+      Mismatch = Class.new
+    end
+  end
+end

data/lib/wayfarer/routing/root_route.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    class RootRoute < Route; end
+  end
+end

data/lib/wayfarer/routing/route.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    class Route
+      include DSL
+      include Stringify
+
+      attr_reader :children
+
+      attr_accessor :matcher,
+                    :parent,
+                    :action,
+                    :path_offset
+
+      stringify :matcher,
+                :action,
+                :path_offset,
+                :children
+
+      def initialize(matcher = Matchers::Custom.new { children.any? }, path_offset = "/")
+        @matcher = matcher
+        @children = []
+        @path_offset = path_offset
+      end
+
+      def match(url)
+        matcher.match(url)
+      end
+
+      def matches?(url)
+        invoke(url).is_a?(Result::Match)
+      end
+
+      def invoke(url)
+        PathFinder.result(self, url)
+      end
+
+      # Accepts a visitor for in-order traversal.
+      def accept(visitor)
+        return unless visitor.visit(self)
+
+        children.each { |child| child.accept(visitor) }
+      end
+    end
+  end
+end