fast_curl 0.3.1 → 0.5.0

data/lib/fast_curl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastCurl
-  VERSION = "0.3.1"
+  VERSION = "0.5.0"
 end

data/lib/fast_curl.rb

@@ -1,13 +1,75 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'uri'
 require_relative "fast_curl/version"
-require_relative "fast_curl/fast_curl"
 
 module FastCurl
   class Error < StandardError; end
   class TimeoutError < Error; end
 
+  class Headers < Hash
+    def [](key)
+      super(normalize(key))
+    end
+
+    def []=(key, value)
+      super(normalize(key), value)
+    end
+    alias store []=
+
+    def fetch(key, *args, &block)
+      super(normalize(key), *args, &block)
+    end
+
+    def key?(key)
+      super(normalize(key))
+    end
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
+
+    def delete(key, &block)
+      super(normalize(key), &block)
+    end
+
+    def dig(key, *rest)
+      super(normalize(key), *rest)
+    end
+
+    def values_at(*keys)
+      super(*keys.map { |key| normalize(key) })
+    end
+
+    def assoc(key)
+      super(normalize(key))
+    end
+
+    def merge(*others, &block)
+      others.inject(dup) { |acc, other| acc.merge!(other, &block) }
+    end
+
+    def merge!(*others)
+      others.each do |other|
+        other.each do |key, value|
+          self[key] = block_given? && key?(key) ? yield(normalize(key), self[key], value) : value
+        end
+      end
+      self
+    end
+    alias update merge!
+
+    private
+
+    def normalize(key)
+      key.is_a?(String) || key.is_a?(Symbol) ? key.to_s.downcase : key
+    end
+  end
+end
+
+require_relative "fast_curl/fast_curl"
+
+module FastCurl
   DEFAULT_OPTIONS = {
     connections: 20,
     timeout: 30
@@ -16,13 +78,18 @@ module FastCurl
   METHODS = %i[get post put delete patch].freeze
   BODY_METHODS = %i[post put patch].freeze
 
+  JSON_TYPE = "application/json"
+  FORM_TYPE = "application/x-www-form-urlencoded"
+  BINARY_TYPE = "application/octet-stream"
+
   class << self
     METHODS.each do |method|
       define_method(method) do |requests, **options|
         execute(build_requests(requests, method), **DEFAULT_OPTIONS.merge(options))
       end
 
-      define_method(:"first_#{method}") do |requests, count: 1, **options|
+      define_method(:"first_#{method}") do |requests, count: 1, accept: nil, **options|
+        options[:accept] = accept unless accept.nil?
         first_execute(build_requests(requests, method), count: count, **DEFAULT_OPTIONS.merge(options))
       end
 
@@ -34,15 +101,71 @@ module FastCurl
     private
 
     def build_requests(requests, method)
-      requests.map do |req|
-        r = { url: req[:url], method: method.to_s.upcase }
-        r[:headers] = req[:headers] if req[:headers]
-        if req[:body] && BODY_METHODS.include?(method)
-          r[:body] = req[:body].is_a?(Hash) ? req[:body].to_json : req[:body].to_s
-          r[:headers] = (r[:headers] || {}).merge("Content-Type" => "application/json") if req[:body].is_a?(Hash)
+      source = requests.is_a?(Hash) ? [requests] : requests
+
+      if source.is_a?(Array)
+        source.map { |request| build_request(request, method) }
+      elsif source.respond_to?(:each)
+        Enumerator.new do |yielder|
+          source.each { |request| yielder << build_request(request, method) }
         end
-        r
+      else
+        raise ArgumentError, "requests must be a Hash, Array or respond to #each"
       end
     end
+
+    def build_request(req, method)
+      raise ArgumentError, "request must be a Hash" unless req.is_a?(Hash)
+
+      r = { url: build_url(req), method: method.to_s.upcase }
+      headers = req[:headers] ? req[:headers].dup : nil
+
+      if BODY_METHODS.include?(method)
+        body, content_type = build_body(req)
+        if body
+          r[:body] = body
+          if content_type && !content_type?(headers)
+            headers ||= {}
+            headers["Content-Type"] = content_type
+          end
+        end
+      end
+
+      r[:headers] = headers if headers && !headers.empty?
+      r
+    end
+
+    def build_url(req)
+      url = req[:url]
+      params = req[:params]
+      return url if params.nil? || params.empty? || !url.is_a?(String)
+
+      separator = url.include?("?") ? "&" : "?"
+      "#{url}#{separator}#{URI.encode_www_form(params)}"
+    end
+
+    # Returns [body_string, default_content_type].
+    #   json: {...} or "..."  -> application/json
+    #   form: {...}           -> application/x-www-form-urlencoded
+    #   body: "..."           -> application/octet-stream (set your own type)
+    #   body: {...}           -> application/json (kept for backwards compatibility)
+    def build_body(req)
+      if req.key?(:json)
+        value = req[:json]
+        [value.is_a?(String) ? value : value.to_json, JSON_TYPE]
+      elsif req.key?(:form)
+        value = req[:form]
+        [value.is_a?(String) ? value : URI.encode_www_form(value), FORM_TYPE]
+      elsif req.key?(:body) && !req[:body].nil?
+        value = req[:body]
+        value.is_a?(Hash) ? [value.to_json, JSON_TYPE] : [value.to_s, BINARY_TYPE]
+      end
+    end
+
+    def content_type?(headers)
+      return false unless headers
+
+      headers.any? { |k, _| k.to_s.casecmp("content-type").zero? }
+    end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: fast_curl
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - roman-haidarov
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -125,7 +124,6 @@ homepage: https://github.com/roman-haidarov/fast_curl
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -140,8 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ultra-fast parallel HTTP client as Ruby C extension on libcurl multi
 test_files: []