http_fn 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5f163f75584cb8c3efd97c4086a5c6def7b7455ddd3a51325e4b205eff1c7932
+  data.tar.gz: 0d8c44e768a2cba2234c23294d1ac4bec17f78d3b792799387967438cd70e8a4
+SHA512:
+  metadata.gz: 2d9f0607650dea8a96dd44491e4de2a91b7a87e947a30fdfde6c039002690e693ad0aed4695bb6ec734a9baf6c41247a005515370cda8623170a5c94f97e0cd6
+  data.tar.gz: 794d6bf88255e7329e62a2b817f98c7c85b694aca48ccc884b89bc253bd00888267de1d5b9ed86414a8ee2059387aad4563d8574b23df4f225f2db54e6bd24f6

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+# These two are temporary
+btrfly.rb
+coucou.txt

data/.ruby-version

@@ -0,0 +1 @@
+2.6

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in http_fn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Martin Chabot
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,160 @@
+# HttpFn
+
+Functional http client in Ruby.
+
+## Usage
+
+### Basics 
+
+#### The Request Structure
+
+In order to query an HTTP server you will need to build a request hash.
+
+Here's an example of a request:
+
+```ruby
+{:proto=>"HTTP/1.1",
+ :host=>"http://api.github.com",
+ :path=>"/users/martinos/repos",
+ :query=>{},
+ :header=>
+  {"accept"=>"application/json",
+   "Content-Type"=>"application/json",
+   "user-agent"=>"paw/3.0.11 (macintosh; os x/10.11.6) gcdhttprequest"},
+ :method=>"GET",
+ :body=>""}
+```
+
+To build that request you can use builder functions and the function composition operator ([`>>`](https://docs.ruby-lang.org/en/2.6.0/Proc.html#method-i-3E-3E)). Every builder function adds values to the response object.  Example: 
+
+```ruby
+query = verb.("get") >>
+        with_path.("/users/martinos/repos") >>
+        with_host.("https://api.github.com") >>
+        add_headers.(json_headers)
+```
+The `query` variable is a builder function that is created by combining multiple builder functions together.
+
+This `query` function takes a hash as a parameter, and returns a hash decorated by the builders.
+ 
+To demonstrate how it works, we need an initialized request (`empty_req`). Here's the `empty_req`:
+
+```ruby
+pp empty_req
+# => 
+{:proto=>"HTTP/1.1",
+ :host=>"http://example.com",
+ :path=>"/",
+ :query=>{},
+ :header=>{},
+ :method=>"GET",
+ :body=>""}
+```
+
+We apply the `empty_req` to the query that we've built.
+```ruby
+pp query.(empty_req)
+# => 
+{:proto=>"HTTP/1.1",
+ :host=>"https://api.github.com",
+ :path=>"/users/martinos/repos",
+ :query=>{},
+ :header=>
+  {"accept"=>"application/json",
+   "Content-Type"=>"application/json",
+   "user-agent"=>"paw/3.0.11 (macintosh; os x/10.11.6) gcdhttprequest"},
+ :method=>"GET",
+ :body=>""}
+```
+In order to `run` the query, you can combine the query with a "server" function (lambda) that takes a "request", sends it to the server and returns a http "response".
+
+```ruby
+HttpFn::NetHttp.server.(query.(empty_req))
+
+# => 
+{:status=>"200",
+ :header=>
+  {"server"=>["GitHub.com"],
+   "date"=>["Sun, 04 Jun 2017 02:20:05 GMT"],
+   "content-type"=>["application/json; charset=utf-8"],
+   "vary"=>["Accept", "Accept-Encoding"], 
+    ...},
+  }
+ :body => "{...}"
+}
+
+```
+
+```ruby
+(query >> HttpFn::NetHttp.server).(empty_req)
+```
+
+Since a "server" is just a function that takes an HTTP request and returns an HTTP response, instead of using Net::Http interface you can use the `HttpFn::Rack.server` function that takes a rack app as parameter.
+
+```run
+query >> HttpFn::Rack.server.(Rails.application)
+```
+
+## Middlewares
+
+Since we are using composable functions to build our request and to query the web server, it's very easy to create our own "middlewares".
+
+If we want to all the request and the response we can create a simple function such as:
+
+```
+debug_fn = -> print, fn, input {
+  print.("Input: \n")
+  print.(input.to_s)
+  output = fn.(input)
+  print.("Output: \n")
+  print.(output)
+  output
+}.curry
+
+```
+
+the `print` param is a function that prints an object.
+
+```
+printer = -> a { print a; a } 
+query >> debug_fn.(printer).(HttpFn::NetHttp.server)
+```
+
+of course you can change the printer to print to the log file.
+
+```
+printer = -> a { logger.debug(a) ; a }
+```
+
+### Curl, Httpie output
+
+If you want to generate documentation with curl commands you can use a simple function such as:
+
+```
+curl = -> a { puts HttpFn::Curl.req.(a) ; a }.curry
+```
+
+Then you can use it with the query and the server function.
+
+```run
+query >> curl >> HttpFn::NetHttp.server
+```
+
+This will output:
+
+```
+curl -X 'GET' 'https://api.github.com/users/martinos/repos?' \
+    -H 'accept: application/json' \
+    -H 'Content-Type: application/json' \
+    -H 'user-agent: ruby net/http'
+```
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/martinos/http_fn/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test
+

data/http_fn.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_fn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "http_fn"
+  spec.version       = HttpFn::VERSION
+  spec.authors       = ["Martin Chabot"]
+  spec.email         = ["chabotm@gmail.com"]
+  spec.summary       = %q{Http client that levrage the use of fp principle}
+  spec.description   = %q{Http client that levrage the use of fp principle}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "minitest"
+  spec.add_dependency "rake", "~> 10.0"
+  spec.add_dependency "rack"
+  spec.add_dependency "fn_reader"
+end

data/lib/http_fn.rb

@@ -0,0 +1,43 @@
+require "fn_reader"
+require "uri"
+require "base64"
+require "http_fn/version"
+require "http_fn/utils"
+
+module HttpFn
+  include Utils
+
+  fn_reader :verb, :with_host, :with_path, :with_query, :withUri,
+            :with_json, :with_headers, :add_headers, :fetch, :to_curl,
+            :out_curl, :json_resp, :to_uri, :empty_req, :json_headers,
+            :with_basic_auth, :run_
+
+  @@empty_req = { proto: "HTTP/1.1", host: "http://example.com", path: "/", query: {}, header: {}, method: "GET", body: "" }
+  @@empty_resp = { status: nil, header: {}, body: {} }
+
+  @@run_ = -> fn { fn.(@@empty_req) } # underscore because run conflicts with run fn in minitest
+  @@verb = -> verb, req { req.merge({ method: verb.to_s.upcase }) }.curry
+  @@with_host = -> host, req { req[:host] = host; req }.curry
+  @@with_path = -> path, req { req[:path] = path; req }.curry
+  @@with_query = -> params, req { req[:query] = params; req }.curry
+  @@with_json = -> hash, req { req[:body] = hash.to_json; req }.curry
+  @@with_headers = -> header, req { req[:header] = header; req }.curry
+  @@add_headers = -> header, req { req[:header].merge!(header); req }.curry
+  @@with_basic_auth = -> user_name, pwd, req do
+    encoded = Base64.strict_encode64("#{user_name}:#{pwd}")
+    req.then(&add_headers.({ "Authorization" => "Basic #{encoded}" }))
+  end.curry
+
+  @@json_resp = Utils.at.(:body) >> Utils.parse_json
+  @@print = -> a { $stdout.puts a.pretty_inspect; a }
+  @@to_uri = -> req {
+    uri = URI(req.fetch(:host))
+    req[:query] && uri.query = URI.encode_www_form(req[:query])
+    uri.path = req[:path]
+    uri
+  }
+  @@json_headers =
+    { "accept" => "application/json",
+      "Content-Type" => "application/json",
+      "user-agent" => "paw/3.0.11 (macintosh; os x/10.11.6) gcdhttprequest" }
+end

data/lib/http_fn/.ruby-version

@@ -0,0 +1 @@
+2.4

data/lib/http_fn/curl.rb

@@ -0,0 +1,22 @@
+require "net/http"
+require "http_fn"
+
+module HttpFn::Curl
+  include HttpFn
+
+  fn_reader :print_curl, :req
+
+  @@req = -> req {
+    first_part = %{curl -X '#{req[:method]}' '#{HttpFn::to_uri.(req).to_s}' #{req[:header].map(&@@header_to_curl).join(" ")}}
+    if req[:body] && !req[:body].empty?
+      first_part + %{\n\    -d $'#{req[:body].gsub("'", "\'")}'}
+    else
+      first_part
+    end
+  }
+  @@header_to_curl = -> a {
+    "\\\n    -H '#{a[0]}: #{a[1]}'"
+  }
+
+  @@print_curl = -> req { $stdout.puts(to_curl.(req)); req }.curry
+end

data/lib/http_fn/httpie.rb

@@ -0,0 +1,20 @@
+require "net/http"
+require "http_fn"
+
+module HttpFn::Httpie
+  include HttpFn
+
+  fn_reader :print_curl, :req
+
+  @@req = -> req {
+    first_part = %{http #{req[:method]} '#{HttpFn::to_uri.(req).to_s}' #{req[:header].map(&@@header_to_httpie).join(" ")}}
+    if req[:body] && !req[:body].empty?
+      %{echo $'#{req[:body].gsub("'", "\'")}' |\\\n#{first_part}}
+    else
+      first_part
+    end
+  }
+  @@header_to_httpie = -> a {
+    "\\\n    '#{a[0]}: #{a[1]}'"
+  }
+end

data/lib/http_fn/net_http.rb

@@ -0,0 +1,23 @@
+require 'net/http'
+require 'http_fn'
+
+module HttpFn::NetHttp
+  include HttpFn
+  mattr_reader :method_str_to_req, :server, :net_resp
+
+  @@method_str_to_req = {"GET" => Net::HTTP::Get, "POST" => Net::HTTP::Post, "DELETE" => Net::HTTP::Delete, "PUT" => Net::HTTP::Put, "PATCH" => Net::HTTP::Patch}
+
+  @@server = -> req { 
+    uri = to_uri.(req) 
+    req_ = method_str_to_req.fetch(req.fetch(:method)).new(uri)
+    req_.set_body_internal(req[:body]) if req[:body]
+    header = req.fetch(:header)
+    header.each { |key, val| req_[key] = val }
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = uri.scheme == 'https'
+    # http.set_debug_output($stdout)
+    @@net_resp.(http.request(req_))
+  } 
+
+  @@net_resp = -> resp { {status: resp.code, header: resp.to_hash, body: resp.body} }
+end

data/lib/http_fn/operators.rb

@@ -0,0 +1,13 @@
+require "superators19"
+
+class Proc
+  superator ">>~" do |fn|
+    -> a { fn.(self.(a)) }
+  end
+end
+
+class Object
+  superator ">>+" do |fn|
+    fn.(self)
+  end
+end

data/lib/http_fn/rack.rb

@@ -0,0 +1,58 @@
+require "http_fn"
+require "pp"
+#
+# https://www.diffchecker.com/ihCGIKyG
+
+module HttpFn::Rack
+  fn_reader :to_env, :server, :rack_resp_to_resp
+
+  @@server = -> rack { to_env >> rack.method(:call) >> rack_resp_to_resp }
+  @@to_env = -> request {
+    session ||= {}
+    session_options ||= {}
+
+    uri = request.then(&HttpFn.to_uri)
+    header = (request[:header] || {}).dup
+    body = request[:body] || ""
+
+    content_type_key, val = header.detect { |key, val| puts key; key.downcase == "content-type" }
+    env = {
+      # CGI variables specified by Rack
+      "REQUEST_METHOD" => request[:method].to_s.upcase,
+      "CONTENT_TYPE" => header.delete(content_type_key),
+      "CONTENT_LENGTH" => body.bytesize,
+      "PATH_INFO" => uri.path,
+      "QUERY_STRING" => uri.query || "",
+      "SERVER_NAME" => uri.host,
+      "SERVER_PORT" => uri.port,
+      "SCRIPT_NAME" => "",
+    }
+
+    env["HTTP_AUTHORIZATION"] = "Basic " + [uri.userinfo].pack("m").delete("\r\n") if uri.userinfo
+
+    # Rack-specific variables
+    env["rack.input"] = StringIO.new(body)
+    env["rack.errors"] = $stderr
+    env["rack.version"] = ::Rack::VERSION
+    env["rack.url_scheme"] = uri.scheme
+    env["rack.run_once"] = true
+    env["rack.session"] = session
+    env["rack.session.options"] = session_options
+
+    header.each { |k, v| env["HTTP_#{k.tr("-", "_").upcase}"] = v }
+    env
+  }
+
+  @@rack_resp_to_resp = -> resp {
+    { status: resp[0],
+     header: resp[1],
+     body: @@body_from_rack_response.(resp[2]) }
+  }
+
+  @@body_from_rack_response = -> response {
+    body = ""
+    response.each { |line| body << line }
+    response.close if response.respond_to?(:close)
+    body
+  }
+end

data/lib/http_fn/utils.rb

@@ -0,0 +1,62 @@
+require "json"
+require "pp"
+require "yaml"
+
+module Utils
+  fn_reader :parse_json, :debug, :at, :retry_fn,
+    :record, :player, :count_by, :cache, :red, :time,
+    :expired, :apply, :and_then, :default, :map, :get, :try
+
+  @@parse_json = JSON.method(:parse)
+  @@debug = -> print, a, b { print.(a); print.(b.to_s); b }.curry
+  @@at = -> key, hash { hash[key] }.curry
+  @@red = -> a { "\033[31m#{a}\033[0m" }
+  # ( a -> b ) -> a -> b
+  @@try = -> f, a { a.nil? ? nil : f.(a) }.curry
+  @@retry_fn = -> fn, a {
+    begin
+      fn.(a)
+    rescue
+      sleep(1)
+      puts "RETRYING"
+      @@retry_fn.(fn).(a)
+    end
+  }.curry
+  @@record = -> filename, to_save {
+    File.open(filename, "w+") { |a| a << to_save.to_yaml }
+    to_save
+  }.curry
+  @@play = -> filename, _params { YAML.load(File.read(filename)) }.curry
+  # (Float -> String -> Bool) -> String -> (a -> b) -> b
+  @@cache = -> expired, filename, fn, param {
+    if expired.(filename)
+      @@record.(filename).(fn.(param))
+    else
+      puts "reading from cache"
+      @@play.(filename).(nil)
+    end
+  }.curry
+  @@expired = -> sec, a { !File.exist?(a) || (Time.now - File.mtime(a)) > sec }.curry
+  @@count_by = -> fn, a {
+    a.inject({}) do |res, a|
+      by = fn.(a)
+      res[by] ||= 0
+      res[by] += 1
+      res
+    end
+  }.curry
+
+  # (String -> String) -> String -> ( a -> b ) -> a -> b
+  @@time = -> print, msg, fn, a {
+    start_time = Time.now
+    res = fn.(a)
+    print.("Time duration for #{msg} =  #{Time.now - start_time}")
+    res
+  }.curry
+  @@apply = -> method, a { a.send(method) }.curry
+  @@default = -> default, a { a.nil? ? default : a }.curry
+  @@and_then = -> f, a { a.nil? ? nil : f.(a) }.curry
+  @@map = -> f, enum { enum.map(&f) }.curry
+  @@at = -> key, hash { hash; hash[key] }.curry
+  @@get = -> method, obj { obj.send(method) }.curry
+end

data/lib/http_fn/version.rb

@@ -0,0 +1,3 @@
+module HttpFn
+  VERSION = "0.1.0"
+end

data/test/http_fn/curl_test.rb

@@ -0,0 +1,28 @@
+require 'minitest_helper'
+require 'http_fn'
+require 'http_fn/rack'
+require 'http_fn/curl'
+
+class HttpFn::CurlTest < Minitest::Test
+  include HttpFn
+
+  def setup 
+    @curl = verb.("GET") >>~ 
+      with_path.("/coucou") >>~ 
+      with_headers.(json_headers) >>~ 
+      with_host.("https://api.github.com") >>~ 
+      with_json.({user: "martin"}) >>~
+      HttpFn::Curl.req >>+ run_
+  end
+
+  def test_should_return_a_curl_command
+    res = <<EOF
+curl -X 'GET' 'https://api.github.com/coucou?' \\
+    -H 'accept: application/json' \\
+    -H 'Content-Type: application/json' \\
+    -H 'user-agent: paw/3.0.11 (macintosh; os x/10.11.6) gcdhttprequest'
+    -d $'{"user":"martin"}'
+EOF
+    assert_equal res.chomp, @curl
+  end
+end

data/test/http_fn/httpie_test.rb

@@ -0,0 +1,28 @@
+require "minitest_helper"
+require "http_fn"
+require "http_fn/rack"
+require "http_fn/httpie"
+
+class HttpFn::CurlTest < Minitest::Test
+  include HttpFn
+
+  def setup
+    @curl = (verb.("GET") >>
+             with_path.("/coucou") >>
+             with_headers.(json_headers) >>
+             with_host.("https://api.github.com") >>
+             with_json.({ user: "martin" }) >>
+             HttpFn::Httpie.req).(empty_req)
+  end
+
+  def test_should_return_a_curl_command
+    res = <<EOF
+echo $'{"user":"martin"}' |\\
+http GET 'https://api.github.com/coucou?' \\
+    'accept: application/json' \\
+    'Content-Type: application/json' \\
+    'user-agent: paw/3.0.11 (macintosh; os x/10.11.6) gcdhttprequest'
+EOF
+    assert_equal res.chomp, @curl
+  end
+end

data/test/http_fn/rack_test.rb

@@ -0,0 +1,45 @@
+require "minitest_helper"
+require "rack"
+require "http_fn/rack"
+
+# https://github.com/macournoyer/thin/blob/a7d1174f47a4491a15b505407c0501cdc8d8d12c/spec/request/parser_spec.rb
+# rack sample
+# https://gist.github.com/a1869ea2e5db0563d5772b2eff74ff9f
+class HttpFn::RackTest < MiniTest::Test
+  include HttpFn
+
+  def setup
+    @req = HttpFn.empty_req.then(&with_host.("http://localhost:3000"))
+  end
+
+  def test_upcase_headers
+    req = @req.then(&add_headers.("X-invisible" => "tata"))
+    env = Rack.to_env.(req)
+    assert_equal "tata", env["HTTP_X_INVISIBLE"]
+  end
+
+  def test_basic_headers
+    env = empty_req.then(&(verb.("get") >> with_host.("https://localhost:3000") >> with_query.({ "name" => "martin" }) >> with_path.("/users/1") >> Rack.to_env))
+    # assert_equal "HTTP/1.1", env["SERVER_PROTOCOL"]
+    # assert_equal "HTTP/1.1", env["HTTP_VERSION"]
+    # assert_equal "/users/1", env["REQUEST_PATH"]
+    assert_equal "GET", env["REQUEST_METHOD"]
+    assert_equal "https", env["rack.url_scheme"]
+    assert_equal "/users/1", env["PATH_INFO"]
+  end
+
+  def test_host
+    env = empty_req.then(&(verb.("get") >> with_host.("https://localhost:3000") >> with_query.({ "name" => "martin" }) >> with_path.("/users/1") >> Rack.to_env))
+    # assert_equal "localhost:3000", env["HTTP_HOST"]
+    assert_equal "localhost", env["SERVER_NAME"]
+    assert_equal 3000, env["SERVER_PORT"]
+    assert_equal "name=martin", env["QUERY_STRING"]
+    assert_equal "", env["SCRIPT_NAME"]
+  end
+
+  def test_dont_prepend_HTTP_to_content_type_and_content_length
+    env = empty_req.then(&(verb.("get") >> with_host.("https://localhost:3000") >> with_query.({ "name" => "martin" }) >> with_path.("/users/1") >> add_headers.({ "content-type" => "application/json" }) >> Rack.to_env))
+    assert_equal "application/json", env["CONTENT_TYPE"]
+    assert_equal 0, env["CONTENT_LENGTH"]
+  end
+end

data/test/http_fn_test.rb

@@ -0,0 +1,13 @@
+require "minitest_helper"
+require "http_fn"
+
+class HttpFn::HttpFnTest < Minitest::Test
+  include HttpFn
+
+  def test_basic_auth
+    req = with_basic_auth.("martin").("secret").(empty_req)
+    authorization = req[:header]["Authorization"]
+    refute_nil authorization
+    assert_equal "Basic bWFydGluOnNlY3JldA==", authorization
+  end
+end

data/test/minitest_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'http_fn'
+
+require 'minitest/autorun'

data/test/test_http_fn.rb

@@ -0,0 +1,7 @@
+require 'minitest_helper'
+
+class TestHttpFn < MiniTest::Unit::TestCase
+  def test_that_it_has_a_version_number
+    refute_nil ::HttpFn::VERSION
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: http_fn
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Martin Chabot
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fn_reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Http client that levrage the use of fp principle
+email:
+- chabotm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- http_fn.gemspec
+- lib/http_fn.rb
+- lib/http_fn/.ruby-version
+- lib/http_fn/curl.rb
+- lib/http_fn/http_fn.rb
+- lib/http_fn/httpie.rb
+- lib/http_fn/net_http.rb
+- lib/http_fn/operators.rb
+- lib/http_fn/rack.rb
+- lib/http_fn/utils.rb
+- lib/http_fn/version.rb
+- test/http_fn/curl_test.rb
+- test/http_fn/httpie_test.rb
+- test/http_fn/rack_test.rb
+- test/http_fn_test.rb
+- test/minitest_helper.rb
+- test/test_http_fn.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Http client that levrage the use of fp principle
+test_files:
+- test/http_fn/curl_test.rb
+- test/http_fn/httpie_test.rb
+- test/http_fn/rack_test.rb
+- test/http_fn_test.rb
+- test/minitest_helper.rb
+- test/test_http_fn.rb