reaxar 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01e89fabba1ce9ad462932c803b4b2b1e6a53e7b3ed15ad341623ba680603a76
-  data.tar.gz: 6d53ae34f6e18b0575a04233c0e9a859db3840b0a41f68615c3e26c22041e86e
+  metadata.gz: 77d79539eb20d915f08e88a6f913ec33e0941590735546d388e2d9cf10d6fd46
+  data.tar.gz: 2afcb3488c6c786b8ecd30ff1cc956ab70a6cae37be002794a03c7cade539541
 SHA512:
-  metadata.gz: 74fd153a23aea5ece45bdd6b673e49e500033ea51e7c029e09c3c9970472d779cf83faadd2ccc5449c504c02b076eb13ea7ad544b1385c35682513c08210936a
-  data.tar.gz: ed241bd8d808511990df8b62beb7ee664f857e5feb476fa11461c91252800fa2f5d545f71570ce65abca6826dfd4d50238c57931bed9f4fe43062192630d8cbb
+  metadata.gz: 4f38c65236f0a2c9e6a5162b7b903f909b4acf3db191a7a0c463bc70845b24e0fee79d60ba6056a580a04c32f1aac3a41077786227955299b837311168ed3bc2
+  data.tar.gz: 6349cb5b45f988829a41ee3b3bb718e1dd18143a025bba7080e55b356cd5c6da822901ceef9b916e6be21a944b590e0eae355bc6c711d0a2daee08ab43263f41

data/lib/reaxar/client.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'ostruct'
 require 'async/http/internet'
 require_relative 'middleware/middleware_stack'
 require_relative 'middleware/redirect'
+require_relative 'middleware/cookies'
 require_relative 'middleware/log'
 
 module Reaxar
@@ -67,13 +69,11 @@ module Reaxar
     # @param body [Object, nil] The request body (for POST, etc.).
     # @return [Object] The processed HTTP response.
     def request(uri, method, body = nil) # rubocop:disable Metrics/MethodLength
-      request_env = {
-        uri:,
-        method:,
-        body:,
-        headers: {},
-        cookies: @cookies
-      }
+      request_env = OpenStruct.new(uri: uri,
+                                   method: method,
+                                   body: body,
+                                   headers: {},
+                                   cookies:)
 
       loop do
         # Process request through middleware
@@ -111,8 +111,6 @@ module Reaxar
     # @return [Object] The HTTP response.
     def execute_http_request(uri, method, body, headers)
       url = URI(uri)
-      headers = headers.merge(headers_with_cookies(url))
-
       case method
       when :get
         @internet.get(url, headers)
@@ -121,35 +119,5 @@ module Reaxar
         @internet.post(url, headers, URI.encode_www_form(body))
       end
     end
-
-    # Builds headers including cookies for the given URL.
-    # @param url [URI] The URI object.
-    # @return [Hash] The headers including the 'Cookie' header if cookies are present.
-    def headers_with_cookies(url)
-      return {} if @cookies.empty?
-
-      domain_cookies = @cookies.select { |_key, cookie| cookie[:domain] == url.host }
-      cookie_string = domain_cookies.map { |key, cookie| "#{key}=#{cookie[:value]}" }.join('; ')
-
-      { 'Cookie' => cookie_string }
-    end
-
-    # Updates the client's cookies from the response.
-    # @param response [Object] The HTTP response object.
-    # @return [void]
-    def update_cookies(response)
-      return unless response.headers['set-cookie']
-
-      response.headers['set-cookie'].split("\n").each do |cookie|
-        name, value = cookie.split('=', 2).map(&:strip)
-        value = value.split(';').first
-
-        @cookies[name] = {
-          value:,
-          domain: response.endpoint.host,
-          path: '/'
-        }
-      end
-    end
   end
 end

data/lib/reaxar/middleware/cookies.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'http-cookie'
+
+module Reaxar
+  module Middleware
+    # Middleware to manage HTTP cookies for requests and responses.
+    #
+    # This middleware loads cookies from a cookie jar file on initialization,
+    # attaches cookies to outgoing requests, updates the cookie jar with any
+    # `Set-Cookie` headers received in responses, and saves the updated jar back to file.
+    #
+    # @example Usage in HTTP client middleware stack
+    #   client.use Reaxar::Middleware::Cookies, jar_file: './cookies.yml'
+    #
+    class Cookies < MiddlewareAbstract
+      # Initializes the Cookies middleware.
+      #
+      # Loads the cookie jar from the specified file if it exists.
+      #
+      # @param args [Hash] Arguments for configuration.
+      # @option args [String] :jar_file Path to the cookie jar file.
+      #
+      # @return [void]
+      def initialize(args) # rubocop:disable Lint/MissingSuper
+        @jar_file = args[:jar_file]
+        @jar = HTTP::CookieJar.new
+        @jar.load(@jar_file) if File.exist?(@jar_file)
+      end
+
+      # Processes the outgoing HTTP request to add cookies.
+      #
+      # Adds a `Cookie` header containing all relevant cookies from the jar
+      # matching the request URI.
+      #
+      # @param request [HTTP::Request] The HTTP request to process.
+      # @return [HTTP::Request] The modified request with cookies added.
+      def process_request(request)
+        request.headers['cookie'] = HTTP::Cookie.cookie_value(@jar.cookies(request.uri))
+        request
+      end
+
+      # Processes the incoming HTTP response to update the cookie jar.
+      #
+      # Parses all `Set-Cookie` headers from the response and adds them to the jar.
+      # Saves the updated cookie jar to the jar file.
+      #
+      # @param response [HTTP::Response] The HTTP response received.
+      # @param request [HTTP::Request] The original HTTP request sent.
+      # @return [HTTP::Response] The unmodified response.
+      def process_response(response, request)
+        response.headers['set-cookie']&.each do |value|
+          @jar.parse(value, request[:uri])
+        end
+        @jar.save(@jar_file)
+        response
+      end
+    end
+  end
+end

data/lib/reaxar/page.rb

@@ -2,6 +2,7 @@
 
 require 'nokogiri'
 require_relative 'element/a'
+require_relative 'parser/factory_parser'
 
 module Reaxar
   # Represents a web page and provides methods for interacting with its content.
@@ -44,6 +45,13 @@ module Reaxar
       Async { new(url, client, &block) }
     end
 
+    # Closes the page's HTTP client.
+    #
+    # @return [void]
+    def close
+      @client.close
+    end
+
     # Initializes a new Page instance.
     # @param url [String] The URL of the page.
     # @param client [Client, nil] Optional HTTP client.
@@ -51,13 +59,35 @@ module Reaxar
     def initialize(url, client = nil)
       @url = url
       @client = client || Client.new(self.class.logger)
+      @client.use Reaxar::Middleware::Cookies, jar_file: './cookies.yml'
       @client.use Reaxar::Middleware::Redirect
       @response = @client.get(url)
-      @document = Nokogiri::HTML(@response.read)
+      @document = Reaxar::Parser::FactoryParser.call(content: @response.read,
+                                                     mime_type: @response.headers['content-type'])
 
       yield self if block_given?
     end
 
+    # @return [Hash{String => String}, nil]
+    #   The response headers as a hash with lowercase keys, or nil if no response is set.
+    #   Headers are memoized after the first call.
+    def headers
+      @headers ||= @response&.headers&.to_h&.transform_keys(&:downcase)
+    end
+
+    # @return [String, nil]
+    #   The `Content-Type` header value from the response, or nil if not present.
+    def content_type
+      headers&.[]('content-type')
+    end
+
+    # @return [String, Integer]
+    #   The `Content-Length` header value from the response.
+    #   Falls back to the byte size of the HTML content if the header is missing.
+    def content_length
+      headers&.[]('content-length') || html.bytesize
+    end
+
     # Returns the title of the page.
     # @return [String, nil] The page title or nil if not found.
     def title

data/lib/reaxar/parser/base_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Reaxar
+  module Parser
+    # Base class for all parsers in the Reaxar system.
+    #
+    # This class provides a common interface for parsing operations.
+    # Subclasses must implement the {#parse} method to define
+    # specific parsing behavior for the given content.
+    #
+    # @abstract
+    class BaseParser
+      # @param content [String] The raw content to be parsed.
+      def initialize(content)
+        @content = content
+      end
+
+      # Parses the provided content.
+      #
+      # @return [Object] The result of the parsing process, defined by the subclass.
+      #
+      # @raise [NotImplementedError] Raised if the method is not implemented by a subclass.
+      #
+      # @abstract
+      def parse
+        raise NotImplementedError,
+              "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+  end
+end

data/lib/reaxar/parser/factory_parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'html_parser'
+require_relative 'xml_parser'
+
+module Reaxar
+  module Parser
+    # Factory class for selecting and invoking the correct parser based on MIME type.
+    #
+    # This class maintains a registry of MIME type to parser class mappings.
+    # Parsers must respond to `#parse` and accept the content in their initializer.
+    #
+    # @example Parsing HTML content
+    #   Reaxar::Parser::FactoryParser.call(
+    #     content: "<html><body>Hello</body></html>",
+    #     mime_type: "text/html"
+    #   )
+    #
+    # @example Registering a custom parser
+    #   Reaxar::Parser::FactoryParser.register(
+    #     "application/json",
+    #     MyJsonParser
+    #   )
+    #
+    class FactoryParser
+      class << self
+        # Selects the appropriate parser for the given MIME type and parses the content.
+        #
+        # @param content [String] The raw content to parse.
+        # @param mime_type [String, Symbol] The MIME type of the content.
+        #
+        # @return [Object] The result of the parsing process.
+        #
+        # @raise [NotImplementedError] If no parser is registered for the given MIME type.
+        def call(content:, mime_type:)
+          normalized_mime = normalize_mime_type(mime_type)
+          parser = registry[normalized_mime]
+          raise NotImplementedError, "No parser for MIME type: #{mime_type}" unless parser
+
+          parser.new(content).parse
+        end
+
+        # Normalizes a MIME type by removing parameters and trimming whitespace.
+        #
+        # @param mime_type [String, Symbol, nil] The MIME type to normalize.
+        # @return [String] The normalized MIME type.
+        def normalize_mime_type(mime_type)
+          mime_type.to_s.split(';').first.strip
+        end
+
+        # Registers a parser class for a given MIME type.
+        #
+        # @param mime_type [String] The MIME type to associate with the parser.
+        # @param klass [Class<#parse>] The parser class to use.
+        # @return [void]
+        def register(mime_type, klass)
+          registry[mime_type] = klass
+        end
+
+        # Returns the registry mapping MIME types to parser classes.
+        #
+        # @return [Hash{String => Class}] The MIME type → parser class mapping.
+        def registry
+          @registry ||= {
+            'text/html' => Reaxar::Parser::HtmlParser,
+            'text/xml' => Reaxar::Parser::XmlParser,
+            'application/xml' => Reaxar::Parser::XmlParser
+          }
+        end
+      end
+    end
+  end
+end

data/lib/reaxar/parser/html_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base_parser'
+
+module Reaxar
+  module Parser
+    # Parses HTML content into a Nokogiri document.
+    #
+    # This parser uses {https://nokogiri.org/ Nokogiri} to parse the provided
+    # HTML string into a `Nokogiri::HTML::Document` object for further processing.
+    #
+    # @example Parsing HTML
+    #   parser = Reaxar::Parser::HtmlParser.new("<html><body>Hello</body></html>")
+    #   doc = parser.parse
+    #   doc.at('body').text # => "Hello"
+    #
+    class HtmlParser < BaseParser
+      # Parses the HTML content into a Nokogiri HTML document.
+      #
+      # @return [Nokogiri::HTML::Document] The parsed HTML document.
+      def parse
+        Nokogiri::HTML(@content)
+      end
+    end
+  end
+end

data/lib/reaxar/parser/xml_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base_parser'
+
+module Reaxar
+  module Parser
+    # Parses XML content into a Nokogiri XML document.
+    #
+    # This parser uses {https://nokogiri.org/ Nokogiri} to parse the provided
+    # XML string into a `Nokogiri::XML::Document` object for further processing.
+    #
+    # @example Parsing XML
+    #   parser = Reaxar::Parser::XmlParser.new("<root><message>Hello</message></root>")
+    #   doc = parser.parse
+    #   doc.at('message').text # => "Hello"
+    #
+    class XmlParser < BaseParser
+      # Parses the XML content into a Nokogiri XML document.
+      #
+      # @return [Nokogiri::XML::Document] The parsed XML document.
+      def parse
+        Nokogiri::XML(@content)
+      end
+    end
+  end
+end

data/lib/reaxar/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Reaxar
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/lib/reaxar.rb

@@ -5,6 +5,11 @@ require_relative 'reaxar/page'
 require_relative 'reaxar/element/a'
 require_relative 'reaxar/middleware/redirect'
 
+require_relative 'reaxar/middleware/cookies'
+require_relative 'reaxar/parser/base_parser'
+require_relative 'reaxar/parser/html_parser'
+require_relative 'reaxar/parser/factory_parser'
+
 module Reaxar
   class Error < StandardError; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reaxar
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Petr Ustyugov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-05 00:00:00.000000000 Z
+date: 2025-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.18'
+- !ruby/object:Gem::Dependency
+  name: http-cookie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.8
 description: |
   Reaxar is a lightweight asynchronous HTTP/REST client for Ruby, built on top of async-http.
   It features automatic cookie management, support for redirects and relative navigation,
@@ -55,11 +69,16 @@ files:
 - lib/reaxar/element/a.rb
 - lib/reaxar/element/iframe.rb
 - lib/reaxar/element/img.rb
+- lib/reaxar/middleware/cookies.rb
 - lib/reaxar/middleware/log.rb
 - lib/reaxar/middleware/middleware_abstract.rb
 - lib/reaxar/middleware/middleware_stack.rb
 - lib/reaxar/middleware/redirect.rb
 - lib/reaxar/page.rb
+- lib/reaxar/parser/base_parser.rb
+- lib/reaxar/parser/factory_parser.rb
+- lib/reaxar/parser/html_parser.rb
+- lib/reaxar/parser/xml_parser.rb
 - lib/reaxar/version.rb
 homepage: https://github.com/senap/reaxar
 licenses: