http_fp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 850b1b6981a06a01b80d3bd85977c2e5d53c27d1
+  data.tar.gz: 970d21732d1ac8e56458ec0ab9d7aeddda38b935
+SHA512:
+  metadata.gz: ec15f9f91bac213932505fa2baef913b2fe709e72e8b423f037754e8f25d7313cadc72d8bab16ab0208c004f922e75195424a84773d3362cb958be5237885720
+  data.tar.gz: ff47e1c252f0abe9b85cbfe601ff4e1223e8844d55c4838a7556c1afd1669e784ebc72a07749829fe1931b2e2a6b7db78237d4135ae2a30dc67db10e72f27e4a

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.1.2

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_fp.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,107 @@
+# HttpFp
+
+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://github.com/martinos/http_fp/blob/master/lib/http_fp/operators.rb#L4)). 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=>""}
+```
+
+<<<<<<< HEAD
+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
+HttpFp::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 => "{...}"
+}
+
+```
+
+You can also use the pipe operator ([`>>+`](https://github.com/martinos/http_fp/blob/master/lib/http_fp/operators.rb#L8)) and the run function. The `run_` function takes a function as parameter and applies the `empty_req` to it.
+
+Here is it's definition:
+```ruby
+run_ = -> fn { fn.(empty_req) }
+```
+
+```run
+query >>~ HttpFp::NetHttp.server >>+ run_
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/martinos/http_fp/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_fp.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_fp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "http_fp"
+  spec.version       = HttpFp::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 "activesupport"
+  spec.add_dependency "superators19"
+end

data/lib/http_fp.rb

@@ -0,0 +1,42 @@
+require "active_support"
+require "http_fp/version"
+require 'http_fp/utils'
+require 'uri'
+require 'base64'
+
+module HttpFp
+  include Utils
+
+  mattr_accessor :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 >>+ 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_fp/.ruby-version

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

data/lib/http_fp/curl.rb

@@ -0,0 +1,21 @@
+require 'net/http'
+require 'http_fp'
+
+module HttpFp::Curl
+  include HttpFp
+
+  mattr_accessor :print_curl, :req
+
+  @@req = -> req {
+    first_part = %{curl -X '#{req[:method]}' '#{HttpFp::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_fp/httpie.rb

@@ -0,0 +1,19 @@
+require 'net/http'
+require 'http_fp'
+
+module HttpFp::Httpie
+  include HttpFp
+
+  mattr_accessor :print_curl, :req
+
+  @@req = -> req {
+    first_part = %{http #{req[:method]} '#{HttpFp::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_fp/net_http.rb

@@ -0,0 +1,23 @@
+require 'net/http'
+require 'http_fp'
+
+module HttpFp::NetHttp
+  include HttpFp
+  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_fp/operators.rb

@@ -0,0 +1,15 @@
+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_fp/rack.rb

@@ -0,0 +1,57 @@
+require 'http_fp'
+require 'active_support'
+require 'pp'
+#
+# https://www.diffchecker.com/ihCGIKyG
+
+module HttpFp::Rack
+  mattr_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 >>+ HttpFp.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_fp/utils.rb

@@ -0,0 +1,63 @@
+require 'active_support'
+require 'json'
+require 'pp'
+require 'http_fp/operators'
+require 'yaml'
+
+module Utils
+  mattr_accessor :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_fp/version.rb

@@ -0,0 +1,3 @@
+module HttpFp
+  VERSION = "0.0.1"
+end

data/test/http_fp/curl_test.rb

@@ -0,0 +1,28 @@
+require 'minitest_helper'
+require 'http_fp'
+require 'http_fp/rack'
+require 'http_fp/curl'
+
+class HttpFp::CurlTest < Minitest::Test
+  include HttpFp
+
+  def setup 
+    @curl = verb.("GET") >>~ 
+      with_path.("/coucou") >>~ 
+      with_headers.(json_headers) >>~ 
+      with_host.("https://api.github.com") >>~ 
+      with_json.({user: "martin"}) >>~
+      HttpFp::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_fp/httpie_test.rb

@@ -0,0 +1,28 @@
+require 'minitest_helper'
+require 'http_fp'
+require 'http_fp/rack'
+require 'http_fp/httpie'
+
+class HttpFp::CurlTest < Minitest::Test
+  include HttpFp
+
+  def setup 
+    @curl = verb.("GET") >>~ 
+      with_path.("/coucou") >>~ 
+      with_headers.(json_headers) >>~ 
+      with_host.("https://api.github.com") >>~ 
+      with_json.({user: "martin"}) >>~
+      HttpFp::Httpie.req >>+ run_
+  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_fp/rack_test.rb

@@ -0,0 +1,61 @@
+require 'minitest_helper'
+require 'rack'
+require 'http_fp/rack'
+
+# https://github.com/macournoyer/thin/blob/a7d1174f47a4491a15b505407c0501cdc8d8d12c/spec/request/parser_spec.rb
+# rack sample
+# https://gist.github.com/a1869ea2e5db0563d5772b2eff74ff9f
+class HttpFp::RackTest < MiniTest::Test
+  include HttpFp
+
+  def setup
+    @req = HttpFp.empty_req >>+ with_host.("http://localhost:3000")
+  end
+
+  def test_upcase_headers
+    req = @req >>+ 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 >>+ 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 >>+ 
+      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 >>+ 
+      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_fp_test.rb

@@ -0,0 +1,14 @@
+require 'minitest_helper'
+require 'http_fp'
+
+class HttpFp::HttpFpTest < Minitest::Test
+  include HttpFp
+
+  def test_basic_auth
+    req = empty_req >>+ with_basic_auth.("martin").("secret")
+    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_fp'
+
+require 'minitest/autorun'

data/test/test_http_fp.rb

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

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: http_fp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Martin Chabot
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-09 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: activesupport
+  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: superators19
+  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_fp.gemspec
+- lib/http_fp.rb
+- lib/http_fp/.ruby-version
+- lib/http_fp/curl.rb
+- lib/http_fp/http_fp.rb
+- lib/http_fp/httpie.rb
+- lib/http_fp/net_http.rb
+- lib/http_fp/operators.rb
+- lib/http_fp/rack.rb
+- lib/http_fp/utils.rb
+- lib/http_fp/version.rb
+- test/http_fp/curl_test.rb
+- test/http_fp/httpie_test.rb
+- test/http_fp/rack_test.rb
+- test/http_fp_test.rb
+- test/minitest_helper.rb
+- test/test_http_fp.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: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Http client that levrage the use of fp principle
+test_files:
+- test/http_fp/curl_test.rb
+- test/http_fp/httpie_test.rb
+- test/http_fp/rack_test.rb
+- test/http_fp_test.rb
+- test/minitest_helper.rb
+- test/test_http_fp.rb