http_mimic 0.3.0

data/lib/http_mimic/response_parser.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module HttpMimic
+  class ResponseParser
+    HTTP_STATUS_LINE_REGEX = /\AHTTP\/(?<version>[\d\.]+)\s+(?<code>\d{3})(?:\s+(?<message>.*))?/i
+
+    attr_reader :raw_output, :exit_status, :stderr, :command, :request_url
+
+    def initialize(raw_output, exit_status: nil, stderr: nil, command: nil, request_url: nil)
+      @raw_output   = raw_output.to_s
+      @exit_status  = exit_status
+      @stderr       = stderr.to_s
+      @command      = command
+      @request_url  = request_url
+    end
+
+    def parse
+      # Split header blocks and body
+      header_blocks, body = split_headers_and_body(@raw_output)
+
+      final_header_block = header_blocks.last || ''
+      history_header_blocks = header_blocks.size > 1 ? header_blocks[0...-1] : []
+
+      # Parse final status line and headers
+      code, http_version, status_message, headers, cookies = parse_header_block(final_header_block)
+
+      # Parse redirect history
+      history = history_header_blocks.map do |block|
+        h_code, h_version, h_msg, h_headers, h_cookies = parse_header_block(block)
+        {
+          code: h_code,
+          http_version: h_version,
+          status_message: h_msg,
+          headers: h_headers,
+          cookies: h_cookies,
+          raw_headers: block
+        }
+      end
+
+      # Parse body (auto-detect JSON)
+      parsed_body = parse_body(body, headers)
+
+      Response.new(
+        code: code,
+        http_version: http_version,
+        status_message: status_message,
+        headers: headers,
+        cookies: cookies,
+        body: body,
+        parsed_response: parsed_body,
+        raw_headers: final_header_block,
+        history: history,
+        request_url: request_url,
+        stderr: stderr,
+        exit_code: exit_status ? exit_status.exitstatus : 0,
+        command: command
+      )
+    end
+
+    private
+
+    # Split raw_output into header blocks and body by \r?\n\r?\n
+    def split_headers_and_body(text)
+      return [[], ''] if text.nil? || text.empty?
+
+      # Normalize line endings
+      normalized = text.gsub(/\r\n/, "\n")
+      parts = normalized.split("\n\n")
+
+      header_blocks = []
+      body_index = 0
+
+      parts.each_with_index do |part, idx|
+        trimmed = part.strip
+        if trimmed =~ HTTP_STATUS_LINE_REGEX
+          header_blocks << part
+          body_index = idx + 1
+        else
+          # Once a non-HTTP status block is encountered, the rest is body
+          break
+        end
+      end
+
+      # Combine remaining parts as body
+      body = parts[body_index..-1] ? parts[body_index..-1].join("\n\n") : ''
+
+      [header_blocks, body]
+    end
+
+    def parse_header_block(block)
+      return [0, nil, nil, Headers.new, Cookies.new] if block.nil? || block.empty?
+
+      lines = block.split(/\r?\n/).map(&:strip).reject(&:empty?)
+      status_line = lines.first || ''
+      header_lines = lines[1..-1] || []
+
+      code = 0
+      http_version = nil
+      status_message = nil
+
+      if match = status_line.match(HTTP_STATUS_LINE_REGEX)
+        code = match[:code].to_i
+        http_version = match[:version]
+        status_message = match[:message] ? match[:message].strip : ''
+      end
+
+      headers = Headers.new
+      set_cookies = []
+
+      header_lines.each do |line|
+        key, val = line.split(':', 2)
+        next unless key && val
+
+        key = key.strip
+        val = val.strip
+
+        if key.downcase == 'set-cookie'
+          set_cookies << val
+          headers.add(key, val)
+        else
+          headers[key] = val
+        end
+      end
+
+      cookies = Cookies.parse_set_cookie(set_cookies)
+
+      [code, http_version, status_message, headers, cookies]
+    end
+
+    def parse_body(body, headers)
+      return nil if body.nil? || body.empty?
+
+      content_type = headers['content-type'].to_s.downcase
+
+      if content_type.include?('json') || body.strip.start_with?('{', '[')
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          body
+        end
+      else
+        body
+      end
+    end
+  end
+end

data/lib/http_mimic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HttpMimic
+  VERSION = "0.3.0"
+end

data/lib/http_mimic.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'uri'
+require 'json'
+
+require 'http_mimic/version'
+require 'http_mimic/exceptions'
+require 'http_mimic/configuration'
+require 'http_mimic/downloader'
+require 'http_mimic/headers'
+require 'http_mimic/cookies'
+require 'http_mimic/response'
+require 'http_mimic/response_parser'
+require 'http_mimic/command_builder'
+require 'http_mimic/request'
+require 'http_mimic/client'
+require 'http_mimic/module_methods'
+
+module HttpMimic
+  extend ModuleMethods
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    # Manually download and install curl-impersonate binary driver
+    def download_driver!(version: nil, force: false)
+      Downloader.download!(version: version, force: force)
+    end
+
+    # Check if curl-impersonate driver is installed locally
+    def driver_installed?(version: nil)
+      Downloader.installed?(version: version)
+    end
+
+    def included(base)
+      base.extend(ModuleMethods)
+      base.send(:include, InstanceMethods)
+    end
+  end
+
+  module InstanceMethods
+    def get(url, options = {})
+      self.class.get(url, options)
+    end
+
+    def post(url, options = {})
+      self.class.post(url, options)
+    end
+
+    def put(url, options = {})
+      self.class.put(url, options)
+    end
+
+    def patch(url, options = {})
+      self.class.patch(url, options)
+    end
+
+    def delete(url, options = {})
+      self.class.delete(url, options)
+    end
+
+    def head(url, options = {})
+      self.class.head(url, options)
+    end
+
+    def options(url, options = {})
+      self.class.options(url, options)
+    end
+
+    def request(method, url, options = {})
+      self.class.request(method, url, options)
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: http_mimic
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- anxgang
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simplifies making HTTP requests using curl-impersonate to mimic real
+  browser TLS/HTTP2 fingerprints.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- http_mimic.gemspec
+- lib/http_mimic.rb
+- lib/http_mimic/client.rb
+- lib/http_mimic/command_builder.rb
+- lib/http_mimic/configuration.rb
+- lib/http_mimic/cookies.rb
+- lib/http_mimic/downloader.rb
+- lib/http_mimic/exceptions.rb
+- lib/http_mimic/headers.rb
+- lib/http_mimic/module_methods.rb
+- lib/http_mimic/request.rb
+- lib/http_mimic/response.rb
+- lib/http_mimic/response_parser.rb
+- lib/http_mimic/version.rb
+homepage: https://github.com/anxgang/http_mimic
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/anxgang/http_mimic
+  source_code_uri: https://github.com/anxgang/http_mimic
+  bug_tracker_uri: https://github.com/anxgang/http_mimic/issues
+  changelog_uri: https://github.com/anxgang/http_mimic/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: A HTTParty-like Ruby client wrapping curl-impersonate via Open3.
+test_files: []