ruby-requests 0.0.1.a1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6ed706002d82efed614dedca3e5d708a261247b975640f5e10f7b2dcd7dbe85b
+  data.tar.gz: bd706bdf0120e49d7ca6c59853100e760b61e214a19b06095a7047681ffdf2bd
+SHA512:
+  metadata.gz: ea6171cbf6ac26301ebc4eb17d3bd13edac08dd9da6595fd66c53d68f2369fadcb47590c6018100cfea2253d21f48d52466a3220c44d0f28c20663edca1d877f
+  data.tar.gz: 9030bf43b7fef5c86e736dd1ee75eb9e7d69cb572f94f759ac353c875e100b75c22aa036a376071092166cc7eb915482c3bb1d9db85ef9116303180e25c92ebf

data/.gitignore

@@ -0,0 +1,5 @@
+TODO.org
+Gemfile.lock
+coverage/
+*.gem
+spec/functional/proxies/squid_logs/

data/.gitlab-ci.yml

@@ -0,0 +1,37 @@
+stages:
+  - test
+  - lint
+
+before_script:
+  - gem install -g Gemfile
+
+lint:
+  stage: lint
+  image: ruby
+  allow_failure: true
+  script:
+    - rubocop
+
+test-ruby-2.3.0:
+  stage: test
+  image: ruby:2.3.0
+  script:
+    - rspec
+
+test-ruby-2.4.0:
+  stage: test
+  image: ruby:2.4.0
+  script:
+    - rspec
+
+# This will test with the current Ruby docker image:
+test-in-docker-compose:
+  stage: test
+  image: tmaier/docker-compose
+  services:
+    - docker:dind
+  before_script:
+    - docker info
+    - docker-compose --version
+  script:
+    - docker-compose -f spec/docker-compose.yml up --exit-code-from ruby

data/.rubocop-disables.yml

@@ -0,0 +1,96 @@
+---
+Layout/AlignHash:
+  Enabled: false
+
+Layout/EmptyLines:
+  Enabled: false
+
+Layout/IndentHash:
+  Enabled: false
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/*/*_spec.rb"
+    - "spec/*/*/*_spec.rb"
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Naming:
+  Enabled: false
+
+Performance/RedundantMerge:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/FormatString:
+  Enabled: False
+
+Style/FormatStringToken:
+  Enabled: False
+
+Style/FrozenStringLiteralComment:
+  Enabled: False
+
+Style/GlobalVars:
+  Exclude:
+    - spec/spec_helper.rb
+
+Style/GuardClause:
+  Enabled: False
+
+Style/HashSyntax:
+  Enabled: false
+
+Style/MutableConstant:
+  Enabled: False
+
+Style/NegatedIf:
+  Enabled: False
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false
+
+Style/SelfAssignment:
+  Enabled: False
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: false
+
+Style/WordArray:
+  Enabled: False

data/.rubocop.yml

@@ -0,0 +1,9 @@
+---
+inherit_from:
+  - .rubocop-disables.yml
+
+AllCops:
+  TargetRubyVersion: "2.3.0"
+
+Layout/IndentationWidth:
+  Width: 4

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'http-cookie', '~> 1'
+
+group :development do
+    gem 'rspec', '~> 3.7'
+    gem 'rubocop', '~> 0.54.0'
+    gem 'simplecov', '~> 0.15'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2018] [Daniel Hones]
+
+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/Makefile

@@ -0,0 +1,17 @@
+RUBY_VERSIONS := 2.3.0 2.4.0 2.5.0
+
+.PHONY: test-all-versions
+test-all-versions:
+	@$(foreach version, $(RUBY_VERSIONS), \
+	echo "Running tests in Ruby $(version)"; \
+	rvm $(version) do rspec; \
+	)
+
+.PHONY: setup-rvm-versions
+setup-rvm-versions:
+	@$(foreach version, $(RUBY_VERSIONS), \
+	echo "Setting up $(version)"; \
+	rvm install $(version); \
+	rvm $(version) do gem install -g Gemfile; \
+	echo ""; \
+	)

data/README.md

@@ -0,0 +1,151 @@
+[![pipeline status](https://gitlab.com/danielhones/ruby_requests/badges/master/pipeline.svg)](https://gitlab.com/danielhones/ruby_requests/commits/master)
+[![coverage report](https://gitlab.com/danielhones/ruby_requests/badges/master/coverage.svg)](https://gitlab.com/danielhones/ruby_requests/commits/master)
+
+
+# Ruby Requests
+
+For Python programmers who just can't avoid making HTTP requests in Ruby.
+
+This gem is a Ruby version of Kenneth Reitz's excellent [Requests](https://github.com/requests/requests) library for Python.  The immediate goal for this project is to provide a useful subset of the interface and features supported by the Python library.  It supports MRI Ruby 2.3.0 and up.  A lot of the core functionality has been implemented already but it is still under development.
+
+
+# Things that work now:
+
+The following methods are implemented:
+
+* `Requests.get`
+* `Requests.post`
+* `Requests.put`
+* `Requests.head`
+* `Requests.delete`
+* `Requests.patch`
+* `Requests.options`
+
+Because of Ruby's handling of keyword arguments, optional parameters must be passed by keyword.  For basic usage, here are some examples:
+
+GET request with no query string params, parse the JSON response:
+
+```
+> r = Requests.get('https://httpbin.org/anything')
+ => #<Requests::Response 200 OK>
+> r.status_code
+ => 200
+> r.reason
+ => "OK"
+# .text returns the body of the response as text:
+> puts r.text
+{
+  "args": {},
+  "data": "",
+  "files": {},
+  "form": {},
+  "headers": {
+    "Accept": "*/*",
+    "Accept-Encoding": "gzip, deflate",
+    "Connection": "close",
+    "Host": "httpbin.org",
+    "User-Agent": "ruby-requests/0.0.1.a1"
+  },
+  "json": null,
+  "method": "GET",
+  "url": "https://httpbin.org/anything"
+}
+# the .json method parses the response body as JSON, returning a Ruby object:
+> pp r.json
+{"args"=>{},
+ "data"=>"",
+ "files"=>{},
+ "form"=>{},
+ "headers"=>
+  {"Accept"=>"*/*",
+   "Accept-Encoding"=>"gzip, deflate",
+   "Connection"=>"close",
+   "Host"=>"httpbin.org",
+   "User-Agent"=>"ruby-requests/0.0.1.a1"},
+ "json"=>nil,
+ "method"=>"GET",
+ "url"=>"https://httpbin.org/anything"}
+```
+
+POST request with query string params and text body:
+
+```
+> r = Requests.post('https://httpbin.org/anything',
+*                   params: {'testkey' => 'test value', 'otherkey' => 'other value'},
+*                   data: "sample POST body")
+> r.url
+ => "https://httpbin.org/anything?testkey=test+value&otherkey=other+value"
+> r.json['args']
+ => {"otherkey"=>"other value", "testkey"=>"test value"}
+> r.json['data']
+ => "sample POST body"
+```
+
+Add headers to a request;
+
+```
+> r = Requests.get('https://httpbin.org/headers', headers: {'Test-Header' => 'Example'})
+ => #<Requests::Response 200 OK> 
+> puts r.text
+{
+  "headers": {
+    "Accept": "*/*", 
+    "Accept-Encoding": "gzip, deflate", 
+    "Connection": "close", 
+    "Host": "httpbin.org", 
+    "Test-Header": "Example", 
+    "User-Agent": "ruby-requests/0.0.1.a1"
+  }
+}
+```
+
+
+Skip verification of SSL certificate (don't do this):
+
+```
+# Error by default on a self-signed cert:
+> r = Requests.get('https://self-signed.badssl.com')
+Traceback (most recent call last):
+   ...
+OpenSSL::SSL::SSLError (SSL_connect returned=1 errno=0 state=error: certificate verify failed (self signed certificate))
+
+# Pass verify: false to prevent verification:
+> r = Requests.get('https://self-signed.badssl.com', verify: false)
+ => #<Requests::Response 200 OK>
+```
+
+Use Basic Authentication (currently the only supported auth type):
+
+```
+> r = Requests.get('https://httpbin.org/basic-auth/user/password',
+*                  auth: ['user', 'password'])
+ => #<Requests::Response 200 OK>
+```
+
+Run through a proxy:
+
+```
+> r = Requests.get('http://example.com', proxies: {'http' => 'http://172.20.9.13:3128'})
+ => #<Requests::Response 200 OK>
+```
+
+
+# Sessions
+
+Sessions are partially supported in the same way that they work in the Python version.  Here's a list of things that work:
+
+* Cookie persistence across requests.  `Session#cookies` returns a `Requests::CookieJar` object which is a subclass of [HTTP::Cookie](https://github.com/sparklemotion/http-cookie).  See documentation for that gem for its main functionality.
+* Optional authentication sent with each request
+* Session headers sent with each request (per-request headers take precedence if used)
+* Proxies used for each request in a session
+
+And some things that don't work yet:
+
+* Respecting environment variables such as `http_proxy`
+* Following redirects
+
+
+# Features that haven't been added yet
+
+* **Redirects:** Following redirects is one of the next things to be implemented but they currently are not followed.  There is an `allow_redirects` keyword argument on the request methods that defaults to true, but at the moment it is just ignored.
+* **Hooks:** There is currently no implementation of hooks or block passing to the request methods

data/lib/requests.rb

@@ -0,0 +1,95 @@
+dir = File.expand_path(__dir__)
+
+require File.join(dir, 'requests/version')
+require File.join(dir, 'requests/exceptions')
+require File.join(dir, 'requests/logger')
+require File.join(dir, 'requests/utils')
+require File.join(dir, 'requests/cookies')
+require File.join(dir, 'requests/http_methods')
+require File.join(dir, 'requests/request')
+require File.join(dir, 'requests/response')
+require File.join(dir, 'requests/adapters')
+require File.join(dir, 'requests/session')
+
+
+module Requests
+    ##
+    # Constructs and sends a :class:`Request <Request>`.
+    #
+    # :param method: method for the new :class:`Request` object.
+    # :param url: URL for the new :class:`Request` object.
+    # :param params: (optional) Hash be sent in the query string
+    # :param data: (optional) Hash, list of tuples ``[[key, value]]`, string,
+    #     or file-like object to send in the body.
+    # :param json: (optional) json data to send in the body. Using this param
+    #     will ignore any +data+ keyword param
+    # :param headers: (optional) Hash of HTTP Headers to send
+    # :param cookies: (optional) Hash or HTTP::CookieJar object to send
+    # :param auth: (optional) Auth tuple to enable basic auth or
+    # :param timeout: (optional) How many seconds to wait for the server to send
+    #     data before giving up.  Float or , or an array of Floats indicating
+    #     (connect timeout, read timeout)
+    # :param allow_redirects: (optional) Boolean. Enable/disable redirection.
+    #     Defaults to +true+.
+    #
+    # :return: :class:`Response <Response>` object
+    # :rtype: Requests::Response
+    #
+    # Not implemented yet:
+    # :param verify: (optional) Either a boolean, in which case it controls
+    #     whether we verify the server's TLS certificate, or a string, in which
+    #     case it must be a path to a CA bundle to use. Defaults to +true+
+    # :param files: (optional) Hash of +'name': file-like-objects+
+    # :param proxies: (optional) Dictionary mapping protocol to the URL of the
+    #     proxy.
+    # :param stream: (optional) if ``False``, the response content will be
+    #     immediately downloaded.
+    # :param cert: (optional) if String, path to ssl client cert file (.pem).
+    #     If Tuple, ('cert', 'key') pair.
+
+    extend HttpMethods
+
+    def self.request(method, url, **kwargs)
+        session = Session.new
+        session.request(method, url, **kwargs)
+    end
+
+    ##
+    # Logging related stuff:
+
+    DEFAULT_LOG_DEV = $stdout
+    DEFAULT_LOGGING_ENABLED = false
+
+    def self.default_logger
+        # :nocov:
+        Requests::Logger.new(DEFAULT_LOG_DEV, level: 'info',
+                             enabled: DEFAULT_LOGGING_ENABLED)
+        # :nocov:
+    end
+
+    def self.logger
+        @logger ||= default_logger
+    end
+
+    def self.logger=(new_logger)
+        @logger = new_logger
+    end
+
+    def self.enable_logging
+        logger.enabled = true if logger.respond_to?(:'enabled=')
+    end
+
+    def self.disable_logging
+        logger.enabled = false if logger.respond_to?(:enabled)
+    end
+
+    ##
+    # Shortcut to enable debug logging for development
+
+    def self.enable_dev_mode
+        # :nocov:
+        enable_logging
+        logger.level = 'debug'
+        # :nocov:
+    end
+end