httparty_curl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b6326e21907094579b265b6058d10bbf324a232af78107014094f4f9302a664f
+  data.tar.gz: 6ea21e2db0aadefeef5814acfcb1a70c88022c2917f00679ec97b958bf378314
+SHA512:
+  metadata.gz: fb447d219baa96116854968bdd9b1e7e47733c02548dd4f57a8f1444a403ec12dd559ed9ab0267e1ce722d94a1937c788d94e5c5e64ec4427191165a84c709e5
+  data.tar.gz: 036730dc4ebf953d1aae54c7e7abfa0e1c9e899bdf184e9cd17e5893db0949ce05301b5911d9445bbb35f5e27456da93bdc683bc660e6540f34bc1a1e1c92381

data/README.md

@@ -0,0 +1,117 @@
+
+# HTTPartyCurl::Logger
+
+`HTTPartyCurl::Logger` is a module that extends HTTParty to log HTTP requests as cURL commands. This is useful for debugging and inspecting outgoing requests in a readable format, replicating them in a terminal if needed.
+
+## Features
+
+- Logs HTTP requests made using HTTParty as cURL commands.
+- Supports common HTTP methods: `GET`, `POST`, `PUT`, `PATCH`, `DELETE`.
+- Automatically includes headers, query parameters, authentication, and proxy settings in the cURL command.
+- Customizable logging configuration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'httparty_curl'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install httparty_curl
+```
+
+## Usage
+
+To use `HTTPartyCurl::Logger`, simply include it in your class that uses HTTParty _after_ you include `Http:
+
+```ruby
+require 'httparty_curl/logger'
+
+class MyApiClient
+  include HTTParty
+  include HTTPartyCurl::Logger
+
+  base_uri 'https://api.example.com'
+
+  def fetch_data
+    self.class.get('/data', headers: { 'Authorization' => 'Bearer token' })
+  end
+end
+```
+
+Now, every request will be logged as a cURL command if logging is enabled.
+
+### Enabling Logging
+
+To enable logging, you need to configure the `HTTPartyCurl` logger and set `curl_logging_enabled` to `true`. You can customize the logger based on your logging setup.
+
+```ruby
+HTTPartyCurl.configure do |config|
+  config.curl_logging_enabled = true
+  config.logger = Logger.new(STDOUT) # or any other logger
+end
+```
+
+## Example Output
+
+When a request is made, the cURL command will be logged like this:
+
+```bash
+HTTParty cURL command:
+curl -X GET 'https://api.example.com/data' \
+  -H 'Authorization: Bearer token'
+```
+
+### Proxy Support
+
+If you are using proxies, the proxy settings will also be included in the cURL command:
+
+```bash
+HTTParty cURL command:
+curl -X GET 'https://api.example.com/data' \
+  --proxy 'http://proxy_user:proxy_pass@proxy.example.com:8080' \
+  -H 'Authorization: Bearer token'
+```
+
+### Authentication
+
+Basic and Digest authentication methods are also supported and included in the cURL command:
+
+```bash
+curl -X GET 'https://api.example.com/data' \
+  -u 'username:password'
+```
+
+## Customization
+
+### Supported HTTP Methods
+
+By default, the following HTTP methods are overridden with logging:
+
+- `GET`
+- `POST`
+- `PUT`
+- `PATCH`
+- `DELETE`
+
+### Custom Headers, Body, and Query Parameters
+
+The cURL command generation handles headers, query parameters, and request body data (including multipart forms and JSON payloads).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/thescubageek/httparty_curl.
+
+## License
+
+The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/httparty_curl/logger.rb

@@ -0,0 +1,176 @@
+# lib/httparty_curl/logger.rb
+
+module HTTPartyCurl
+  # Module containing the cURL logging functionality.
+  module Logger
+    # List of proxy options to consider.
+    PROXY_OPTIONS = %i[http_proxyaddr http_proxyport http_proxyuser http_proxypass].freeze
+
+    # Hook method called when the module is included.
+    # Extends the base class with class methods.
+    # @param base [Class] the class including the module.
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods added to the including class.
+    module ClassMethods
+      # List of HTTP methods to override with logging functionality.
+      HTTP_METHODS = %i[get post put patch delete].freeze
+
+      # Dynamically defines overridden HTTP methods.
+      HTTP_METHODS.each do |http_method|
+        define_method(http_method) do |uri, options = {}, &block|
+          options ||= {}
+          log_curl(http_method, uri, options)
+          super(uri, options, &block)
+        end
+      end
+
+      # Converts an HTTParty request to a cURL command.
+      #
+      # @param method [Symbol] the HTTP method (e.g., :get, :post).
+      # @param uri [String] the request URI.
+      # @param options [Hash] the request options (headers, body, etc.).
+      # @return [String] the generated cURL command.
+      def to_curl(method, uri, options = {})
+        options ||= {}
+
+        # Prepare the URI and append query parameters if present
+        uri = prepare_uri(uri, options[:query])
+
+        curl_command = initialize_curl_command(method, uri)
+
+        # Add proxy settings if available
+        add_proxy_settings(curl_command)
+
+        # Add headers to the cURL command
+        add_headers(curl_command, options[:headers])
+
+        # Add authentication to the cURL command
+        add_authentication(curl_command, options[:basic_auth], options[:digest_auth])
+
+        # Add body data to the cURL command
+        add_body_data(curl_command, options[:body], options[:headers])
+
+        curl_command.join(" \\\n")
+      end
+
+      private
+
+      # Prepares the full URI, including base_uri and query parameters.
+      #
+      # @param uri [String] the request URI.
+      # @param query [Hash, nil] the query parameters.
+      # @return [String] the full URI with query parameters.
+      def prepare_uri(uri, query)
+        # Ensure base_uri is included if it's a relative path
+        unless uri.start_with?('http')
+          effective_base_uri = self.base_uri || 'http://localhost' #  rubocop:disable Style/RedundantSelf
+          uri = URI.join(effective_base_uri, uri).to_s
+        end
+
+        # Append query parameters to URI if present
+        if query
+          uri = URI(uri)
+          existing_query = URI.decode_www_form(uri.query || '')
+          new_query = existing_query + query.to_a
+          uri.query = URI.encode_www_form(new_query)
+          uri = uri.to_s
+        end
+
+        uri
+      end
+
+      # Initializes the cURL command with the HTTP method and URI.
+      #
+      # @param method [Symbol] the HTTP method.
+      # @param uri [String] the full request URI.
+      # @return [Array<String>] the initial cURL command array.
+      def initialize_curl_command(method, uri)
+        ["curl -X #{method.to_s.upcase} '#{uri}'"]
+      end
+
+      # Adds proxy settings to the cURL command if present.
+      #
+      # @param curl_command [Array<String>] the cURL command array.
+      def add_proxy_settings(curl_command)
+        if default_options && default_options.values_at(*PROXY_OPTIONS).any? { |opt| !opt.nil? && !opt.to_s.empty? }
+          proxy_parts = []
+          if default_options[:http_proxyuser] && default_options[:http_proxypass]
+            proxy_parts << "#{default_options[:http_proxyuser]}:#{default_options[:http_proxypass]}@"
+          end
+          proxy_parts << "#{default_options[:http_proxyaddr]}:#{default_options[:http_proxyport]}"
+          curl_command << "--proxy 'http://#{proxy_parts.join}'"
+        end
+      end
+
+      # Adds headers to the cURL command.
+      #
+      # @param curl_command [Array<String>] the cURL command array.
+      # @param headers [Hash, nil] the request headers.
+      def add_headers(curl_command, headers)
+        (headers || {}).each do |k, v|
+          curl_command << "-H '#{k}: #{v}'"
+        end
+      end
+
+      # Adds authentication options to the cURL command.
+      #
+      # @param curl_command [Array<String>] the cURL command array.
+      # @param basic_auth [Hash, nil] the basic authentication credentials.
+      # @param digest_auth [Hash, nil] the digest authentication credentials.
+      def add_authentication(curl_command, basic_auth, digest_auth)
+        if basic_auth
+          curl_command << "-u '#{basic_auth[:username]}:#{basic_auth[:password]}'"
+        elsif digest_auth
+          curl_command << "--digest -u '#{digest_auth[:username]}:#{digest_auth[:password]}'"
+        end
+      end
+
+      # Adds body data to the cURL command.
+      #
+      # @param curl_command [Array<String>] the cURL command array.
+      # @param body [String, Hash, nil] the request body.
+      # @param headers [Hash, nil] the request headers.
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_body_data(curl_command, body, headers)
+        return if body.nil?
+
+        headers ||= {}
+        content_type = headers['Content-Type'] || headers['content-type']
+
+        if content_type == 'application/x-www-form-urlencoded' && body.is_a?(Hash)
+          form_data = URI.encode_www_form(body)
+          curl_command << "-d '#{form_data}'"
+        elsif content_type == 'multipart/form-data' && body.is_a?(Hash)
+          body.each do |key, value|
+            if value.respond_to?(:path) && value.respond_to?(:read)
+              # File upload
+              curl_command << "-F '#{key}=@#{value.path}'"
+            else
+              curl_command << "-F '#{key}=#{value}'"
+            end
+          end
+        else
+          # Default to JSON encoding for hash bodies
+          body_data = body.is_a?(String) ? body : body.to_json
+          curl_command << "-d '#{body_data}'"
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      # Logs the cURL command for the request if logging is enabled.
+      #
+      # @param method [Symbol] the HTTP method.
+      # @param uri [String] the request URI.
+      # @param options [Hash] the request options.
+      def log_curl(method, uri, options)
+        return unless HTTPartyCurl.configuration.curl_logging_enabled
+
+        curl_command = to_curl(method, uri, options)
+        HTTPartyCurl.configuration.logger.info("\nHTTParty cURL command:\n#{curl_command}\n")
+      end
+    end
+  end
+end

data/lib/httparty_curl/version.rb

@@ -0,0 +1,6 @@
+# lib/httparty_curl/version.rb
+
+module HTTPartyCurl
+  # Gem version number.
+  VERSION = "0.1.0".freeze
+end

data/lib/httparty_curl.rb

@@ -0,0 +1,48 @@
+# lib/httparty_curl.rb
+
+require 'httparty'
+require 'httparty_curl/version'
+require 'logger'
+require 'json'
+
+# Main module for the HTTPartyCurl gem.
+# Provides functionality to log HTTParty requests as cURL commands.
+module HTTPartyCurl
+  # Custom error class for the gem.
+  class Error < StandardError; end
+
+  # Configuration class to store gem settings.
+  class Configuration
+    # @return [Boolean] whether cURL logging is enabled.
+    attr_accessor :curl_logging_enabled
+
+    # @return [Logger] the logger instance used for logging.
+    attr_accessor :logger
+
+    # Initializes the configuration with default values.
+    def initialize
+      @curl_logging_enabled = false
+      @logger = ::Logger.new($stdout)
+    end
+  end
+
+  class << self
+    # @return [Configuration] the current configuration instance.
+    attr_accessor :configuration
+
+    # Configures the gem settings.
+    # @yieldparam config [Configuration] the configuration object to set options.
+    # @example
+    #   HTTPartyCurl.configure do |config|
+    #     config.curl_logging_enabled = true
+    #     config.logger = Logger.new('log/httparty_curl.log')
+    #   end
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+  end
+
+  # Load the Logger module containing the cURL logging functionality.
+  require_relative 'httparty_curl/logger'
+end

data/test/httparty_curl/logger_test.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+# test/httparty_curl/logger_test.rb
+
+require 'minitest/autorun'
+require 'httparty_curl'
+require 'stringio'
+require 'webmock/minitest'
+
+class HTTPartyCurl::LoggerTest < Minitest::Test
+  def setup
+    @base_uri = 'http://example.com'
+
+    # Configure the gem for testing
+    HTTPartyCurl.configure do |config|
+      config.curl_logging_enabled = true
+      config.logger = ::Logger.new(StringIO.new) # Use StringIO to capture logger output
+    end
+
+    # Create a dynamic client class for testing
+    @client_class = Class.new do
+      include HTTParty
+      include HTTPartyCurl::Logger
+
+      base_uri 'http://example.com'
+    end
+
+    # Stub all HTTP requests to example.com
+    stub_request(:any, /example\.com/).to_return(status: 200, body: "", headers: {})
+
+    # Disable real network connections
+    WebMock.disable_net_connect!(allow_localhost: true)
+  end
+
+  def teardown
+    # Reset the configuration after each test
+    HTTPartyCurl.configuration = HTTPartyCurl::Configuration.new
+
+    # Reset WebMock after each test
+    WebMock.reset!
+  end
+
+  def test_get_request_logs_curl_command
+    mock_logger = Minitest::Mock.new
+    mock_logger.expect(:info, nil) do |message|
+      message.include?("curl -X GET '#{@base_uri}/'")
+    end
+
+    HTTPartyCurl.configuration.logger = mock_logger
+
+    @client_class.get('/')
+
+    mock_logger.verify
+  end
+
+  def test_post_request_with_body
+    body = { 'key' => 'value' }
+    expected_curl = "curl -X POST '#{@base_uri}/' \\\n-d '#{body.to_json}'"
+
+    captured_output = StringIO.new
+    logger = ::Logger.new(captured_output)
+    # Set a simple formatter to exclude timestamps and severity levels
+    logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
+    HTTPartyCurl.configuration.logger = logger
+
+    @client_class.post('/', body: body)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_request_with_headers
+    headers = { 'Content-Type' => 'application/json', 'Authorization' => 'Bearer token' }
+    expected_curl = "-H 'Content-Type: application/json' \\\n-H 'Authorization: Bearer token'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/', headers: headers)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_request_with_query_params
+    query = { 'param1' => 'value1', 'param2' => 'value2' }
+    expected_uri = "#{@base_uri}/?param1=value1&param2=value2"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/', query: query)
+
+    assert_includes captured_output.string, "curl -X GET '#{expected_uri}'"
+  end
+
+  def test_request_with_basic_auth
+    auth = { username: 'user', password: 'pass' }
+    expected_curl = "-u 'user:pass'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/', basic_auth: auth)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_request_with_digest_auth
+    auth = { username: 'user', password: 'pass' }
+    expected_curl = "--digest -u 'user:pass'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/', digest_auth: auth)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_post_request_with_form_data
+    body = { 'key1' => 'value1', 'key2' => 'value2' }
+    headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+    expected_data = "key1=value1&key2=value2"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.post('/', headers: headers, body: body)
+
+    assert_includes captured_output.string, "-d '#{expected_data}'"
+  end
+
+  def test_post_request_with_multipart_form_data
+    file = File.open(__FILE__)
+    body = { 'file' => file, 'key' => 'value' }
+    headers = { 'Content-Type' => 'multipart/form-data' }
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.post('/', headers: headers, body: body)
+
+    assert_includes captured_output.string, "-F 'file=@#{file.path}'"
+    assert_includes captured_output.string, "-F 'key=value'"
+
+    file.close
+  end
+
+  def test_request_with_proxy_settings
+    @client_class.http_proxy('proxy.example.com', 8080, 'proxyuser', 'proxypass')
+    expected_proxy = "--proxy 'http://proxyuser:proxypass@proxy.example.com:8080'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/')
+
+    assert_includes captured_output.string, expected_proxy
+  end
+
+  def test_logging_disabled
+    HTTPartyCurl.configuration.curl_logging_enabled = false
+    mock_logger = Minitest::Mock.new
+
+    HTTPartyCurl.configuration.logger = mock_logger
+
+    @client_class.get('/')
+
+    # If logger.info is called, the mock will raise an error
+    mock_logger.verify
+  end
+
+  def test_custom_logger
+    captured_output = StringIO.new
+    custom_logger = ::Logger.new(captured_output)
+
+    HTTPartyCurl.configuration.logger = custom_logger
+
+    @client_class.get('/')
+
+    assert_includes captured_output.string, "curl -X GET '#{@base_uri}/'"
+  end
+
+  def test_put_request
+    body = { 'update' => 'data' }
+    expected_curl = "curl -X PUT '#{@base_uri}/' \\\n-d '#{body.to_json}'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.put('/', body: body)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_patch_request
+    body = { 'patch' => 'data' }
+    expected_curl = "curl -X PATCH '#{@base_uri}/' \\\n-d '#{body.to_json}'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.patch('/', body: body)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_delete_request
+    expected_curl = "curl -X DELETE '#{@base_uri}/'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.delete('/')
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_body_as_string
+    body = '{"raw":"json"}'
+    expected_curl = "-d '#{body}'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.post('/', body: body)
+
+    assert_includes captured_output.string, expected_curl
+  end
+
+  def test_headers_case_insensitivity
+    headers = { 'content-type' => 'application/json', 'ACCEPT' => 'application/json' }
+    expected_curl_content_type = "-H 'content-type: application/json'"
+    expected_curl_accept = "-H 'ACCEPT: application/json'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/', headers: headers)
+
+    assert_includes captured_output.string, expected_curl_content_type
+    assert_includes captured_output.string, expected_curl_accept
+  end
+
+  def test_handles_nil_options
+    expected_curl = "curl -X GET '#{@base_uri}/'"
+
+    captured_output = StringIO.new
+    HTTPartyCurl.configuration.logger = ::Logger.new(captured_output)
+
+    @client_class.get('/', nil)
+
+    assert_includes captured_output.string, expected_curl
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "httparty_curl"
+
+require "minitest/autorun"
+
+require 'webmock/minitest'
+WebMock.disable_net_connect!

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: httparty_curl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- TheScubaGeek
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+description: HTTPartyCurl adds cURL logging capabilities to HTTParty requests for
+  debugging purposes.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/httparty_curl.rb
+- lib/httparty_curl/logger.rb
+- lib/httparty_curl/version.rb
+- test/httparty_curl/logger_test.rb
+- test/test_helper.rb
+homepage: https://github.com/thescubageek/httparty_curl
+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.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A gem to log HTTParty requests as cURL commands.
+test_files: []