request_via 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4966442b32fe09b091c1ba940658f3ae1330210
-  data.tar.gz: d28c20e0ad6709eaa801f7751a3d2947d3e65c2c
+  metadata.gz: f958dbee6653251da7b8fb72818eea82aa23f72f
+  data.tar.gz: 5389f3b568ff5252afdafc8c23cde8ddf8005190
 SHA512:
-  metadata.gz: 470c31a0b38d42987f41eb9cbeff68f333ccdc875efa77098ec7a7fc3e544baa9476471ab7fc52d5b31070726d8d896438d7fedc865b33a667a3a8285afc058a
-  data.tar.gz: a78cf82f0077abcbd8d312072c5d0a26c32e90d5ee228aefe25dc216ebf2b4e81d3da3403828a83e6efe67bdb8763d154268fecc9eb5e96ece9eb55793d33b2d
+  metadata.gz: dd93888e3fbcfa00674033042de2ae7a9c2a6dff4531d4b7c92df651d08d9b3857de47a100e317bc9cebb2b164d938c7269037a29a8f5002c3dabd11b83dd61b
+  data.tar.gz: '039a3b536b0d5ef5ef4d905aa347ceee583e73ef4338b89fc35541ea6c63cab9bfe6bb808ce630ee78355cd572d4c220bf9795a7d798f60f771a2d96a610b096'

data/README.md

@@ -18,14 +18,21 @@ response.body
 # --- Make requests over a map iteration
 
 dogs = [ 'akita', 'chihuahua', 'beagle' ]
-dogs_images = dogs.map { |breed_name| "https://dog.ceo/api/breed/#{breed_name}/images/random" }
-dogs_images.map(&RequestVia::Get).map(&:body)
+dog_images = dogs.map { |breed_name| "https://dog.ceo/api/breed/#{breed_name}/images/random" }
+dog_images.map(&RequestVia::Get).map(&:body)
+
+# If do you want to pass common arguments to each request use the GetR function (R = reversed arguments)
+# Available options: port, params, headers, open_timeout read_timeout, response_and_request, net_http
+dog_images.map(&RequestVia::GetR.(open_timeout: 10)).map(&:body)
 
 # --- Make requests over an ASYNC map iteration
 
 require 'parallel' # https://rubygems.org/gems/parallel
 
 Parallel.map(dogs_images, &RequestVia::Get).map(&:body)
+
+# Apply common options to each request
+Parallel.map(dogs_images, &RequestVia::GetR.(open_timeout: 10)).map(&:body)
 ```
 
 ## Installation
@@ -68,8 +75,18 @@ response, request = RequestVia::Get.('example.com/foo', response_and_request: tr
 
 # Request with the reversed arguments order
 %w[
-    example.com/foo example.com/bar
+  example.com/foo example.com/bar
 ].map &RequestVia::GetR.(headers: { 'X-Requested-With': 'RequestVia gem' })
+
+# Other options
+RequestVia::Get.('example.io', port: 2000,
+                               open_timeout: 10,  # Default: 60
+                               read_timeout: 120, # Default: 60
+                               net_http: -> (host, port) {
+                                   net_http = Net::HTTP.new(host, port)
+                                   # Make your customizations
+                                   net_http
+                               })
 ```
 
 Supported HTTP methods.
@@ -79,7 +96,7 @@ RequestVia::Post.()    # RequestVia::PostR.()
 
 RequestVia::Put.()     # RequestVia::PutR.()
 
-RequestVia::Delete.()  # RequestVia::DeteteR.()
+RequestVia::Delete.()  # RequestVia::DeleteR.()
 
 RequestVia::Options.() # RequestVia::OptionsR.()
 

data/lib/request_via.rb

@@ -3,26 +3,26 @@
 require 'net/https'
 require 'uri'
 
+require "request_via/func"
 require "request_via/version"
 require "request_via/http_client"
-require "request_via/func"
 
 module RequestVia
-  Get     = Func::FetchStrategyTo.(Net::HTTP::Get).freeze
-  Head    = Func::FetchStrategyTo.(Net::HTTP::Head).freeze
-  Post    = Func::FetchStrategyTo.(Net::HTTP::Post).freeze
-  Put     = Func::FetchStrategyTo.(Net::HTTP::Put).freeze
-  Delete  = Func::FetchStrategyTo.(Net::HTTP::Delete).freeze
-  Options = Func::FetchStrategyTo.(Net::HTTP::Options).freeze
-  Trace   = Func::FetchStrategyTo.(Net::HTTP::Trace).freeze
-  Patch   = Func::FetchStrategyTo.(Net::HTTP::Patch).freeze
+  Get     = Func::FetchStrategyTo.(Net::HTTP::Get)
+  Head    = Func::FetchStrategyTo.(Net::HTTP::Head)
+  Post    = Func::FetchStrategyTo.(Net::HTTP::Post)
+  Put     = Func::FetchStrategyTo.(Net::HTTP::Put)
+  Delete  = Func::FetchStrategyTo.(Net::HTTP::Delete)
+  Options = Func::FetchStrategyTo.(Net::HTTP::Options)
+  Trace   = Func::FetchStrategyTo.(Net::HTTP::Trace)
+  Patch   = Func::FetchStrategyTo.(Net::HTTP::Patch)
 
-  GetR     = Func::ReverseRequestArgsTo.(Get).freeze
-  HeadR    = Func::ReverseRequestArgsTo.(Head).freeze
-  PostR    = Func::ReverseRequestArgsTo.(Post).freeze
-  PutR     = Func::ReverseRequestArgsTo.(Put).freeze
-  DeleteR  = Func::ReverseRequestArgsTo.(Delete).freeze
-  OptionsR = Func::ReverseRequestArgsTo.(Options).freeze
-  TraceR   = Func::ReverseRequestArgsTo.(Trace).freeze
-  PatchR   = Func::ReverseRequestArgsTo.(Patch).freeze
+  GetR     = Func::ReverseRequestArgsTo.(Get)
+  HeadR    = Func::ReverseRequestArgsTo.(Head)
+  PostR    = Func::ReverseRequestArgsTo.(Post)
+  PutR     = Func::ReverseRequestArgsTo.(Put)
+  DeleteR  = Func::ReverseRequestArgsTo.(Delete)
+  OptionsR = Func::ReverseRequestArgsTo.(Options)
+  TraceR   = Func::ReverseRequestArgsTo.(Trace)
+  PatchR   = Func::ReverseRequestArgsTo.(Patch)
 end

data/lib/request_via/func.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 module RequestVia
+  Freeze = -> object { object.freeze }.freeze
+
   module Func
-    ReverseRequestArgsTo = -> request {
-      -> (options, url) {
+    ReverseRequestArgsTo = Freeze.(-> request {
+      Freeze.(-> (options, url) {
         request.(url, **options)
-      }.curry
-    }.freeze
+      }.curry)
+    })
 
-    ParseURI = -> url {
+    ParseURI = Freeze.(-> url {
       if url.start_with?('http://', 'https://')
         ::URI.parse(url)
       elsif /([^:]+)?:?\/\// !~ url
@@ -16,58 +18,69 @@ module RequestVia
       else
         fail ::URI::InvalidURIError, 'URI scheme must be http:// or https://'
       end
-    }.freeze
+    })
 
-    IsAHash = -> data { data.is_a?(::Hash) }.freeze
+    IsAHash = Freeze.(-> data {
+      data.is_a?(::Hash)
+    })
 
-    SetRequestHeaders = -> (request, headers) {
+    SetRequestHeaders = Freeze.(-> (request, headers) {
       return request unless IsAHash.(headers)
       headers.each { |key, value| request[key] = value }
       return request
-    }.freeze
+    })
 
-    URIWithoutParams = -> (url, _) { ParseURI.(url) }.freeze
+    URIWithoutParams = Freeze.(-> (url, _) {
+      ParseURI.(url)
+    })
 
-    URIWithParams = -> (url, params) {
+    URIWithParams = Freeze.(-> (url, params) {
       ParseURI.(url).tap do |uri|
         uri.query = ::URI.encode_www_form(params) if IsAHash.(params)
       end
-    }.freeze
+    })
 
-    RequestWithoutBody = -> http_method {
+    RequestWithoutBody = Freeze.(-> http_method {
       -> (uri, _) { http_method.new(uri) }
-    }.freeze
+    })
 
-    RequestWithBody = -> http_method {
+    RequestWithBody = Freeze.(-> http_method {
       -> (uri, params) {
         req = http_method.new(uri)
         req.set_form_data(params) if IsAHash.(params)
         return req
       }
-    }.freeze
+    })
 
-    FetchWith = -> (uri_builder, request_builder) {
-      -> (url, params: nil, headers: nil, response_and_request: false) {
+    FetchWith = Freeze.(-> (uri_builder, request_builder) {
+      -> (url, port: nil,
+               params: nil,
+               headers: nil,
+               net_http: nil,
+               open_timeout: nil,
+               read_timeout: nil,
+               response_and_request: false) do
         uri = uri_builder.(url, params)
         req = SetRequestHeaders.(request_builder.(uri, params), headers)
-        res = HTTPClient.(uri).request(req)
-        response_and_request ? [res, req] : res
-      }
-    }.freeze
+        http = HTTPClient.(uri, port, open_timeout, read_timeout, net_http)
+        response = http.request(req)
+        response_and_request ? [response, req] : response
+      end
+    })
 
-    FetchWithBodyVia = -> http_method {
+    FetchWithBodyVia = Freeze.(-> http_method {
       FetchWith.(URIWithoutParams, RequestWithBody.(http_method))
-    }.freeze
+    })
 
-    FetchWithQueryStringVia = -> http_method {
+    FetchWithQueryStringVia = Freeze.(-> http_method {
       FetchWith.(URIWithParams, RequestWithoutBody.(http_method))
-    }.freeze
+    })
 
-    FetchStrategyTo = -> http_method {
+    FetchStrategyTo = Freeze.(-> http_method {
       strategy_to = \
         http_method::REQUEST_HAS_BODY ? FetchWithBodyVia : FetchWithQueryStringVia
 
-      strategy_to.(http_method)
-    }
+      Freeze.(strategy_to.(http_method))
+    })
   end
 end

data/lib/request_via/http_client.rb

@@ -4,8 +4,15 @@ module RequestVia
   module HTTPClient
     extend self
 
-    def call(uri)
-      net_http = Net::HTTP.new(uri.host, uri.port)
+    Build = Freeze.(-> (host, port) {
+      Net::HTTP.new(host, port)
+    })
+
+    def call(uri, port = nil, open_timeout = nil, read_timeout = nil, net_http = nil)
+      net_http = build!(uri, port, net_http)
+
+      net_http.open_timeout = Integer(open_timeout) unless open_timeout.nil?
+      net_http.read_timeout = Integer(read_timeout) unless read_timeout.nil?
 
       return net_http unless uri.is_a?(URI::HTTPS)
 
@@ -14,6 +21,16 @@ module RequestVia
 
     private
 
+    def build!(uri, port, net_http)
+      strategy = net_http.is_a?(Proc) ? net_http : Build
+
+      http = strategy.(uri.host, (port || uri.port))
+
+      return http if http.instance_of?(Net::HTTP)
+
+      fail TypeError, 'net_http proc must return a Net:HTTP instance'
+    end
+
     def set_https!(net_http)
       net_http.verify_mode = OpenSSL::SSL::VERIFY_NONE
       net_http.use_ssl = true

data/lib/request_via/version.rb

@@ -3,7 +3,7 @@
 module RequestVia
   module SemVer
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     PATCH = 0
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: request_via
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura