reaxar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b2fd9a3dbf706503da293b66d5837c30f93625db9fc37d74b7bc7acfe342340
+  data.tar.gz: a9959db54d8cc2a0c64ef02dce21023c6118fc673df8cd9f0dfbc5cbc434d23b
+SHA512:
+  metadata.gz: '00081eadeb2c21f70cb2382d8a6c0a472d350383cf8dc10d6143ec8b35de1da7bc2d4b059cd2e3ba7f8f1fd81df6535d564b23185fb896b8c8a0f94842b73a8f'
+  data.tar.gz: d118de9ec7ddc0c3676ad93057a16322548a6bd95e200e36ab125bcf7c8560dadad390d4356d29d3a0a0a5db538b89ea3a660ec0f12249f75a38a41602c576ca

data/lib/reaxar/client.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'async/http/internet'
+require_relative 'middleware/middleware_stack'
+require_relative 'middleware/redirect'
+require_relative 'middleware/log'
+
+module Reaxar
+  # HTTP client for performing asynchronous web requests with middleware support.
+  #
+  # @example Basic usage
+  #   client = Reaxar::Client.new(Logger.new($stdout))
+  #   response = client.get('https://example.com')
+  #   puts response.read
+  #
+  # @!attribute [r] cookies
+  #   @return [Hash] The cookies stored by the client, keyed by cookie name.
+  class Client
+    attr_reader :cookies
+
+    # Initializes a new Client instance.
+    # @param logger [Logger, nil] Logger instance for logging requests (optional).
+    def initialize(logger)
+      @cookies = {}
+      @logger = logger || Logger.new($stdout)
+      @internet = Async::HTTP::Internet.new
+      @middleware = Reaxar::Middleware::MiddlewareStack.new
+
+      @middleware.use Reaxar::Middleware::Log.new(@logger)
+    end
+
+    # Performs an HTTP GET request.
+    # @param uri [String] The URI to request.
+    # @return [Object] The HTTP response object.
+    def get(uri)
+      request(uri, :get)
+    end
+
+    # Performs an HTTP POST request.
+    # @param uri [String] The URI to request.
+    # @param form_data [Hash] The form data to send in the POST body.
+    # @return [Object] The HTTP response object.
+    def post(uri, form_data = {})
+      request(uri, :post, form_data)
+    end
+
+    # Closes the underlying HTTP connection.
+    # @return [void]
+    def close
+      @internet.close
+    end
+
+    # Adds a middleware to the middleware stack.
+    # @param middleware_class [Class] The middleware class to add.
+    # @param args [Array] Arguments to pass to the middleware initializer.
+    # @yield [block] Optional block for middleware initialization.
+    # @return [void]
+    def use(middleware_class, *args, &block)
+      @middleware.use(middleware_class.new(*args, &block))
+    end
+
+    private
+
+    # Internal method to perform an HTTP request with middleware processing.
+    # @param uri [String] The URI to request.
+    # @param method [Symbol] The HTTP method (:get, :post, etc.).
+    # @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
+      }
+
+      loop do
+        # Process request through middleware
+        processed_request = @middleware.run(request_env)
+
+        # Execute HTTP request
+        response = execute_http_request(
+          processed_request[:uri],
+          processed_request[:method],
+          processed_request[:body],
+          processed_request[:headers]
+        )
+
+        # Process response through middleware
+        middleware_result = @middleware.process_response(response, processed_request)
+
+        # Retry request if needed (e.g., redirect)
+        if middleware_result == :retry_request
+          request_env = processed_request
+          next
+        end
+
+        # Update cookies if needed
+        # update_cookies(middleware_result, URI(processed_request[:uri]).host)
+
+        return middleware_result
+      end
+    end
+
+    # Executes the actual HTTP request using Async::HTTP::Internet.
+    # @param uri [String] The URI to request.
+    # @param method [Symbol] The HTTP method.
+    # @param body [Object, nil] The request body.
+    # @param headers [Hash] The request headers.
+    # @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)
+      when :post
+        headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        @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/element/a.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Reaxar
+  module Element
+    # Represents an HTML anchor (`<a>`) element on a page.
+    #
+    # @example Accessing link attributes and clicking
+    #   link = Reaxar::Element::A.new(nokogiri_element, page)
+    #   puts link.href
+    #   link.click { |new_page| puts new_page.title }
+    #
+    # @!attribute [r] element
+    #   @return [Nokogiri::XML::Element] The underlying Nokogiri element.
+    # @!attribute [r] page
+    #   @return [Reaxar::Page] The page this element belongs to.
+    class A
+      attr_reader :element, :page
+
+      # Initializes a new anchor element wrapper.
+      # @param element [Nokogiri::XML::Element] The Nokogiri element.
+      # @param page [Reaxar::Page] The parent page.
+      def initialize(element, page)
+        @element = element
+        @page = page
+      end
+
+      # Returns the absolute URL for the link.
+      # @return [String] The resolved href attribute.
+      def href
+        URI.join(page.url, element[:href]).to_s
+      end
+
+      # Opens the link in a new page context.
+      # @yield [page] Optional block with the new page instance.
+      # @return [Async::Task] The async task wrapping the new page.
+      def click(&block)
+        Page.open(href, page.client, &block)
+      end
+    end
+  end
+end

data/lib/reaxar/element/iframe.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Reaxar
+  module Element
+    class Iframe
+    end
+  end
+end

data/lib/reaxar/element/img.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Reaxar
+  module Element
+    class Img
+    end
+  end
+end

data/lib/reaxar/middleware/log.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'time'
+
+module Reaxar
+  module Middleware
+    # Middleware for logging HTTP requests and responses.
+    #
+    # @example Usage
+    #   logger = Logger.new($stdout)
+    #   middleware = Reaxar::Middleware::Log.new(logger)
+    #
+    # @!attribute [r] logger
+    #   @return [Logger] The logger used for output.
+    class Log < MiddlewareAbstract
+      # Initializes the Log middleware.
+      # @param logger [Logger, nil] Logger instance for output (defaults to $logger).
+      def initialize(logger = nil)
+        super()
+        @logger = logger || Logger.new($stdout)
+      end
+
+      # Logs information about the HTTP request.чц
+      # @param request [Hash] The request data.
+      # @return [Hash] The original request.
+      def process_request(request)
+        @start_time = Time.now
+        log_request_info(request, @start_time)
+        log_request_headers(request)
+        request
+      end
+
+      # Logs information about the HTTP response.
+      # @param response [Object] The HTTP response.
+      # @param request [Hash] The original request.
+      # @return [Object] The HTTP response.
+      def process_response(response, request)
+        duration = Time.now - @start_time
+        status = response.respond_to?(:status) ? response.status : '???'
+        log_response_info(request, response, status, duration)
+        log_response_headers(response)
+        response
+      end
+
+      private
+
+      def log_request_info(request, _start_time)
+        @logger.info("➡️  [#{@start_time.iso8601}] #{request[:method].upcase} #{request[:uri]}")
+      end
+
+      def log_request_headers(request)
+        return unless request[:headers] && !request[:headers].empty?
+
+        @logger.info('Request headers:')
+        request[:headers].each do |key, value|
+          @logger.info("  #{key}: #{value}")
+        end
+      end
+
+      def log_response_info(request, _response, status, duration)
+        @logger.info("⬅️  [#{Time.now.iso8601}] #{request[:method].upcase} #{request[:uri]} - " \
+        "#{status} (#{duration.round(2)}s)")
+      end
+
+      def log_response_headers(response)
+        return unless response.respond_to?(:headers) && response.headers && !response.headers.empty?
+
+        @logger.info('Response headers:')
+        response.headers.each do |key, value|
+          @logger.info("  #{key}: #{value}")
+        end
+      end
+    end
+  end
+end

data/lib/reaxar/middleware/middleware_abstract.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Reaxar
+  module Middleware
+    # Abstract base class for HTTP middleware.
+    #
+    # All middleware should inherit from this class and implement
+    # the {#process_request} and {#process_response} methods.
+    #
+    # @abstract
+    class MiddlewareAbstract
+      # Processes the HTTP request before it is sent.
+      # @param request [Hash] The request data.
+      # @return [Hash] The modified request.
+      # @raise [NotImplementedError] If not implemented in subclass.
+      def process_request(request)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      # Processes the HTTP response after it is received.
+      # @param response [Object] The HTTP response.
+      # @param _request [Hash] The original request.
+      # @return [Object] The modified response.
+      # @raise [NotImplementedError] If not implemented in subclass.
+      def process_response(response, request)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+  end
+end

data/lib/reaxar/middleware/middleware_stack.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Reaxar
+  module Middleware
+    # Manages a stack of HTTP middleware and applies them to requests and responses.
+    #
+    # @example
+    #   stack = Reaxar::Middleware::MiddlewareStack.new
+    #   stack.use(MyMiddleware.new)
+    #   request = stack.run(request)
+    #   response = stack.process_response(response, request)
+    class MiddlewareStack
+      # Initializes a new, empty middleware stack.
+      def initialize
+        @stack = []
+      end
+
+      # Adds a middleware to the stack.
+      # @param middleware [Object] The middleware instance to add.
+      # @return [void]
+      def use(middleware)
+        @stack << middleware
+      end
+
+      # Runs all middleware on the request in order.
+      # @param request [Hash] The request data.
+      # @return [Hash] The processed request.
+      def run(request)
+        @stack.reduce(request) do |req, middleware|
+          middleware.process_request(req) || req
+        end
+      end
+
+      # Runs all middleware on the response in reverse order.
+      # @param response [Object] The HTTP response.
+      # @param request [Hash] The original request.
+      # @return [Object, Symbol] The processed response or :retry_request.
+      def process_response(response, request)
+        @stack.reverse.reduce(response) do |resp, middleware|
+          result = middleware.process_response(resp, request)
+
+          return :retry_request if result == :retry_request
+
+          result || resp
+        end
+      end
+    end
+  end
+end

data/lib/reaxar/middleware/redirect.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'middleware_abstract'
+
+module Reaxar
+  module Middleware
+    # Middleware for handling HTTP redirects.
+    #
+    # @example
+    #   middleware = Reaxar::Middleware::Redirect.new
+    #
+    # @!attribute [r] redirect_count
+    #   @return [Integer] The number of redirects for the request.
+    class Redirect < MiddlewareAbstract
+      # The maximum number of allowed redirects.
+      MAX_REDIRECTS = 5
+
+      # Initializes the Redirect middleware.
+      def initialize
+        super
+        @redirect_count = 0
+      end
+
+      # Initializes the redirect counter for the request.
+      # @param request [Hash] The request data.
+      # @return [Hash] The modified request.
+      def process_request(request)
+        request[:redirect_count] ||= 0
+        request
+      end
+
+      # Processes the HTTP response and handles redirects if needed.
+      # @param response [Object] The HTTP response.
+      # @param request [Hash] The original request.
+      # @return [Object, Symbol] The response or :retry_request for another attempt.
+      def process_response(response, request)
+        return response unless response.headers['location']
+        return response if request[:redirect_count] >= MAX_REDIRECTS
+
+        request[:redirect_count] += 1
+
+        redirect_uri = process_location_url(request, response)
+
+        request[:uri] = redirect_uri
+        request[:method] = :get if [301, 302].include?(response.status)
+
+        :retry_request
+      end
+
+      private
+
+      def process_location_url(request, response)
+        location = response.headers['location']
+        base_uri = URI(request[:uri])
+        if location.start_with?('http')
+          location
+        else
+          "#{base_uri.scheme}://#{base_uri.host}#{location}"
+        end
+      end
+    end
+  end
+end

data/lib/reaxar/page.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative 'element/a'
+
+module Reaxar
+  # Represents a web page and provides methods for interacting with its content.
+  #
+  # @example Open a page and print its title
+  #   page = Reaxar::Page.open('https://example.com')
+  #   puts page.title
+  #
+  # @!attribute [r] url
+  #   @return [String] The URL of the page.
+  # @!attribute [r] client
+  #   @return [Client] The HTTP client used to fetch the page.
+  # @!attribute [r] response
+  #   @return [Object] The HTTP response object.
+  # @!attribute [r] document
+  #   @return [Nokogiri::HTML::Document] The parsed HTML document.
+  class Page
+    attr_reader :url, :client, :response, :document
+
+    class << self
+      # @!attribute [rw] logger
+      #   @return [Logger, nil] The logger instance used by the client.
+      attr_accessor :logger
+
+      # Configures the logger for the Page class.
+      # @param logger [Logger] The logger to use.
+      # @return [void]
+      def configure(logger:)
+        self.logger = logger
+      end
+    end
+
+    # Opens a page asynchronously.
+    # @param url [String] The URL to open.
+    # @param client [Client, nil] Optional HTTP client.
+    # @yield [page] Optional block to yield the page instance.
+    # @yieldparam page [Page] The page instance.
+    # @return [Async::Task] The async task wrapping the page.
+    def self.open(url, client = nil, &block)
+      Async { new(url, client, &block) }
+    end
+
+    # Initializes a new Page instance.
+    # @param url [String] The URL of the page.
+    # @param client [Client, nil] Optional HTTP client.
+    # @yield [self] Optional block to yield the page instance.
+    def initialize(url, client = nil)
+      @url = url
+      @client = client || Client.new(self.class.logger)
+      @client.use Reaxar::Middleware::Redirect
+      @response = @client.get(url)
+      @document = Nokogiri::HTML(@response.read)
+
+      yield self if block_given?
+    end
+
+    # Returns the title of the page.
+    # @return [String, nil] The page title or nil if not found.
+    def title
+      document.title
+    end
+
+    # Returns all links (<a> elements) on the page.
+    # @return [Array<Reaxar::Element::A>] The array of link elements.
+    def links
+      @links ||= document.css('a[href]').map do |link|
+        Reaxar::Element::A.new(link, self)
+      end
+    end
+
+    # Returns the HTML content of the page.
+    # @return [String] The HTML content.
+    def html
+      document.to_html
+    end
+
+    # Finds a form on the page.
+    # @param selector [String] CSS selector for the form (default: 'form').
+    # @return [Object, nil] The form element or nil if not found.
+    def form(selector = 'form')
+      # Реализация работы с формами (можно расширить)
+    end
+
+    # Submits a form on the page.
+    # @param selector [String] CSS selector for the form.
+    # @param data [Hash] Data to submit with the form.
+    # @return [Object] The result of the form submission.
+    def submit_form(selector, data = {})
+      # Реализация отправки формы
+    end
+  end
+end

data/lib/reaxar/version.rb

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

data/lib/reaxar.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'reaxar/client'
+require_relative 'reaxar/page'
+require_relative 'reaxar/element/a'
+require_relative 'reaxar/middleware/redirect'
+
+module Reaxar
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: reaxar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Petr Ustyugov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.89.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.89.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+description: REST client with cookie support and page navigation
+email:
+- peter.ustyugov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/reaxar.rb
+- lib/reaxar/client.rb
+- lib/reaxar/element/a.rb
+- lib/reaxar/element/iframe.rb
+- lib/reaxar/element/img.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/version.rb
+homepage: https://github.com/senap/reaxar
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Simple HTTP browser with cookie persistence
+test_files: []