ur 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '09cd35887d4f337c01a55526c85dec4d0473ed24532d920960890cccc44f3f52'
+  data.tar.gz: e6cb70fe2d62dd42864c6fd6b2b6cf7c9ebf3f0c73744e0fa8a952618e1d8b1e
+SHA512:
+  metadata.gz: 3e1b5884244f923e22e6570d3e87ce7b3d70771987845bff06da886bb86ed9d29623cbdbf6c55ed943b53529e1506d53f5b995704de177a279c566e8770986f0
+  data.tar.gz: 040554fff56b914de9343fb4abd7e5175557224c34632385efaa5794125587f1ea4ae31f5cf8c9b761d20d8b881a320abcee4ebd49cd2614f25680dcce534d09

data/.simplecov

@@ -0,0 +1 @@
+SimpleCov.start

data/.yardopts

@@ -0,0 +1 @@
+--main README.md --markup=markdown {lib}/**/*.rb

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# v0.0.1
+
+- Ur, Ur::Request, Ur::Response, Ur::Processing
+- Rack and Faraday integration
+- Ur::Middleware, FaradayMiddleware, RackMiddleware

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Ethan
+
+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,52 @@
+# Ur ᚒ
+
+Ur: Unified Request/Response Representation in Ruby
+
+## Usage with middleware
+
+Rack middleware:
+
+```ruby
+class MyRackMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    # do things before the request
+
+    ur = Ur.from_rack_request(env)
+
+    # set additional properties of the ur, for example:
+    ur.logger = my_logger
+
+    rack_response = ur.with_rack_response(@app, env) do
+      # do things after the response
+    end
+    rack_response
+  end
+end
+```
+
+Faraday middleware:
+
+```ruby
+class MyFaradayMiddleware < ::Faraday::Middleware
+  def call(request_env)
+    # do things before the request
+
+    ur = Ur.from_faraday_request(request_env)
+
+    # set additional properties of the ur, for example:
+    ur.logger = my_logger
+
+    ur.faraday_on_complete(@app, request_env) do |response_env|
+      # do things after the response
+    end
+  end
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile.rb

@@ -0,0 +1,10 @@
+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/lib/ur.rb

@@ -0,0 +1,150 @@
+require "ur/version"
+
+require 'jsi'
+require 'time'
+require 'addressable/uri'
+
+Ur = JSI.class_for_schema({
+  id: 'https://schemas.ur.unth.net/ur',
+  type: 'object',
+  properties: {
+    bound: {
+      type: 'string',
+      description: %q([rfc2616] Inbound and outbound refer to the request and response paths for messages: "inbound" means "traveling toward the origin server", and "outbound" means "traveling toward the user agent"),
+      enum: ['inbound', 'outbound'],
+    },
+    request: {
+      type: 'object',
+      properties: {
+        method: {type: 'string', description: 'HTTP ', example: 'POST'},
+        uri: {type: 'string', example: 'https://example.com/foo?bar=baz'},
+        headers: {type: 'object'},
+        body: {type: 'string'},
+      },
+    },
+    response: {
+      type: 'object',
+      properties: {
+        status: {type: 'integer', example: 200},
+        headers: {type: 'object'},
+        body: {type: 'string'},
+      },
+    },
+    processing: {
+      type: 'object',
+      properties: {
+        began_at_s: {type: 'string'},
+        duration: {type: 'number'},
+        tags: {type: 'array', items: {type: 'string'}}
+      },
+    },
+  },
+})
+class Ur
+  VERSION = UR_VERSION
+
+  autoload :RequestAndResponse, 'ur/request_and_response'
+  autoload :Middleware, 'ur/middleware'
+  autoload :FaradayMiddleware, 'ur/middleware'
+  autoload :RackMiddleware, 'ur/middleware'
+
+  Request = JSI.class_for_schema(self.schema['properties']['request'])
+  Response = JSI.class_for_schema(self.schema['properties']['response'])
+  Processing = JSI.class_for_schema(self.schema['properties']['processing'])
+  require 'ur/request'
+  require 'ur/response'
+  require 'ur/processing'
+
+  class << self
+    def from_rack_request(request_env)
+      if request_env.is_a?(Rack::Request)
+        rack_request = request_env
+        env = request_env.env
+      else
+        rack_request = Rack::Request.new(request_env)
+        env = request_env
+      end
+
+      Ur.new({}).tap do |ur|
+        ur.processing.begin!
+        ur.bound = 'inbound'
+        ur.request['method'] = rack_request.request_method
+        ur.request.headers = env.map do |(key, value)|
+          http_match = key.match(/\AHTTP_/)
+          if http_match
+            name = http_match.post_match.downcase
+            {name => value}
+          else
+            name = %w(content_type content_length).detect { |sname| sname.downcase == key.downcase }
+            if name
+              {name => value}
+            end
+          end
+        end.compact.inject({}, &:update)
+        ur.request.addressable_uri = Addressable::URI.new(
+          :scheme => rack_request.scheme,
+          :host => rack_request.host,
+          :port => rack_request.port,
+          :path => rack_request.path,
+          :query => (rack_request.query_string unless rack_request.query_string.empty?)
+        )
+        env["rack.input"].rewind
+        ur.request.body = env["rack.input"].read
+        env["rack.input"].rewind
+      end
+    end
+
+    def from_faraday_request(request_env, logger: nil)
+      Ur.new({}).tap do |ur|
+        ur.processing.begin!
+        ur.bound = 'outbound'
+        ur.request['method'] = request_env[:method].to_s
+        ur.request.headers = request_env[:request_headers]
+        ur.request.uri = request_env[:url].normalize.to_s
+        ur.request.set_body_from_faraday(request_env)
+      end
+    end
+  end
+
+  def initialize(ur = {}, *a, &b)
+    super(ur, *a, &b)
+    unless instance.respond_to?(:to_hash)
+      raise(TypeError, "expected hash argument. got: #{ur.pretty_inspect.chomp}")
+    end
+    self.request = {} if self.request.nil?
+    self.response = {} if self.response.nil?
+    self.processing = {} if self.processing.nil?
+  end
+
+  def logger=(logger)
+    if logger && logger.formatter.respond_to?(:current_tags)
+      processing.tags = logger.formatter.current_tags.dup
+    end
+  end
+
+  def with_rack_response(app, env)
+    status, response_headers, response_body = app.call(env)
+
+    response.status = status
+    response.headers = response_headers
+    response.body = response_body.to_enum.to_a.join('')
+
+    response_body_proxy = ::Rack::BodyProxy.new(response_body) do
+      processing.finish!
+
+      yield
+    end
+    [status, response_headers, response_body_proxy]
+  end
+
+  def faraday_on_complete(app, request_env, &block)
+    app.call(request_env).on_complete do |response_env|
+      response.status = response_env[:status]
+      response.headers = response_env[:response_headers]
+      response.set_body_from_faraday(response_env)
+      processing.finish!
+
+      yield(response_env)
+    end
+  end
+end

data/lib/ur/middleware.rb

@@ -0,0 +1,42 @@
+require 'ur' unless Object.const_defined?(:Ur)
+
+class Ur
+  module Middleware
+    def initialize(app, options = {})
+      @app = app
+      @options = options
+    end
+    attr_reader :app
+    attr_reader :options
+
+    def invoke_callback(name, *a, &b)
+      if @options[name]
+        @options[name].call(*a, &b)
+      end
+    end
+  end
+
+  class FaradayMiddleware < ::Faraday::Middleware
+    include Ur::Middleware
+    def call(request_env)
+      ur = Ur.from_faraday_request(request_env)
+      invoke_callback(:before_request, ur)
+      ur.logger = options[:logger] if options[:logger]
+      ur.faraday_on_complete(@app, request_env) do |response_env|
+        invoke_callback(:after_response, ur)
+      end
+    end
+  end
+
+  class RackMiddleware
+    include Ur::Middleware
+    def call(env)
+      ur = Ur.from_rack_request(env)
+      invoke_callback(:before_request, ur)
+      ur.logger = options[:logger] if options[:logger]
+      ur.with_rack_response(@app, env) do
+        invoke_callback(:after_response, ur)
+      end
+    end
+  end
+end

data/lib/ur/processing.rb

@@ -0,0 +1,29 @@
+require 'ur' unless Object.const_defined?(:Ur)
+
+class Ur
+  class Processing
+    def began_at
+      began_at_s ? Time.parse(began_at_s) : nil
+    end
+    def began_at=(time)
+      self.began_at_s = time ? time.utc.iso8601(6) : nil
+    end
+
+    attr_accessor :began_at_ns
+
+    def begin!
+      self.began_at ||= Time.now
+      self.began_at_ns ||= Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+    end
+    def finish!
+      return if duration
+      if began_at_ns
+        now_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        self.duration = (now_ns - began_at_ns) * 1e-9
+      elsif began_at
+        now = Time.now
+        self.duration = (now.to_f - began_at.to_f)
+      end
+    end
+  end
+end

data/lib/ur/request.rb

@@ -0,0 +1,14 @@
+require 'ur' unless Object.const_defined?(:Ur)
+
+class Ur
+  class Request
+    include RequestAndResponse
+
+    def addressable_uri
+      uri ? Addressable::URI.parse(uri) : nil
+    end
+    def addressable_uri=(auri)
+      self.uri = auri ? auri.normalize.to_s : nil
+    end
+  end
+end

data/lib/ur/request_and_response.rb

@@ -0,0 +1,23 @@
+require 'ur' unless Object.const_defined?(:Ur)
+
+class Ur
+  module RequestAndResponse
+    module FaradayEntity
+      def set_body_from_faraday(env)
+        if env[:raw_body].respond_to?(:to_str)
+          self.body = env[:raw_body].to_str.dup
+        elsif env[:body].respond_to?(:to_str)
+          self.body = env[:body].to_str.dup
+        elsif env[:body].respond_to?(:read) && env[:body].respond_to?(:rewind)
+          env[:body].rewind
+          self.body = env[:body].read
+          env[:body].rewind
+        elsif env[:body]
+          # TODO not good
+          self['body_parsed'] = env[:body]
+        end
+      end
+    end
+    include FaradayEntity
+  end
+end

data/lib/ur/response.rb

@@ -0,0 +1,7 @@
+require 'ur' unless Object.const_defined?(:Ur)
+
+class Ur
+  class Response
+    include RequestAndResponse
+  end
+end

data/lib/ur/version.rb

@@ -0,0 +1 @@
+UR_VERSION = "0.0.1"

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'simplecov'
+require 'byebug'
+
+# NO EXPECTATIONS
+ENV["MT_NO_EXPECTATIONS"] = ''
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+class UrSpec < Minitest::Spec
+  def assert_json_equal(exp, act, *a)
+    assert_equal(JSI::Typelike.as_json(exp), JSI::Typelike.as_json(act), *a)
+  end
+end
+
+# register this to be the base class for specs instead of Minitest::Spec
+Minitest::Spec.register_spec_type(//, UrSpec)
+
+require 'ur'

data/test/ur_faraday_test.rb

@@ -0,0 +1,79 @@
+require_relative 'test_helper'
+require 'faraday'
+require 'faraday_middleware'
+
+describe 'Ur faraday integration' do
+  it 'integrates, basic usage' do
+    ur = nil
+    faraday_conn = ::Faraday.new('https://ur.unth.net/') do |builder|
+      builder.use(Ur::FaradayMiddleware,
+        after_response: -> (ur_) { ur = ur_ },
+      )
+      builder.use(Faraday::Adapter::Rack, -> (env) { [200, {'Content-Type' => 'text/plain'}, ['ᚒ']] })
+    end
+    res = faraday_conn.get('/')
+    assert_equal('ᚒ', res.body)
+    assert_instance_of(Ur, ur)
+    assert_equal('get', ur.request['method'])
+    assert_equal('text/plain', ur.response.headers['Content-Type'])
+    assert_equal('ᚒ', ur.response.body)
+    assert(ur.validate)
+  end
+  it 'integrates, IO body' do
+    ur = nil
+    faraday_conn = ::Faraday.new('https://ur.unth.net/') do |builder|
+      builder.use(Ur::FaradayMiddleware,
+        after_response: -> (ur_) { ur = ur_ },
+      )
+      builder.use(Faraday::Adapter::Rack, -> (env) { [200, {'Content-Type' => 'text/plain'}, ['☺']] })
+    end
+    res = faraday_conn.post('/', StringIO.new('hello!'))
+    assert_equal('☺', res.body)
+    assert_instance_of(Ur, ur)
+    assert_equal('post', ur.request['method'])
+    assert_equal('hello!', ur.request.body)
+    assert_equal('text/plain', ur.response.headers['Content-Type'])
+    assert_equal('☺', ur.response.body)
+    assert(ur.validate)
+  end
+  it 'integrates, faraday middleware munges the json bodies but uses preserve_raw' do
+    ur = nil
+    faraday_conn = ::Faraday.new('https://ur.unth.net/') do |builder|
+      builder.request :json
+      builder.use(Ur::FaradayMiddleware,
+        after_response: -> (ur_) { ur = ur_ },
+      )
+      builder.response :json, preserve_raw: true
+      builder.use(Faraday::Adapter::Rack, -> (env) { [200, {'Content-Type' => 'application/json'}, ['{}']] })
+    end
+    res = faraday_conn.post('/', {'a' => 'b'})
+    assert_equal({}, res.body)
+    assert_instance_of(Ur, ur)
+    assert_equal('post', ur.request['method'])
+    assert_equal('{"a":"b"}', ur.request.body)
+    assert_equal('application/json', ur.response.headers['Content-Type'])
+    assert_equal('{}', ur.response.body)
+    assert(ur.validate)
+  end
+  it 'integrates, faraday middleware munges the json bodies and does not preserve_raw' do
+    ur = nil
+    faraday_conn = ::Faraday.new('https://ur.unth.net/') do |builder|
+      builder.use(Ur::FaradayMiddleware,
+        after_response: -> (ur_) { ur = ur_ },
+      )
+      builder.request :json
+      builder.response :json
+      builder.use(Faraday::Adapter::Rack, -> (env) { [200, {'Content-Type' => 'application/json'}, ['{}']] })
+    end
+    res = faraday_conn.post('/', {'a' => 'b'})
+    assert_equal({}, res.body)
+    assert_instance_of(Ur, ur)
+    assert_equal('post', ur.request['method'])
+    assert_nil(ur.request.body) # no good
+    assert_json_equal({"a" => "b"}, ur.request['body_parsed']) # best we get here
+    assert_equal('application/json', ur.response.headers['Content-Type'])
+    assert_nil(ur.response.body) # no good
+    assert_json_equal({}, ur.response['body_parsed']) # best we get here
+    assert(ur.validate)
+  end
+end

data/test/ur_processing_test.rb

@@ -0,0 +1,11 @@
+require_relative 'test_helper'
+
+describe 'Ur processing' do
+  it 'sets duration from began_at' do
+    ur = Ur.new
+    ur.processing.began_at = Time.now
+    ur.processing.finish!
+    assert_instance_of(Float, ur.processing.duration)
+    assert_operator(ur.processing.duration, :>, 0)
+  end
+end

data/test/ur_rack_test.rb

@@ -0,0 +1,29 @@
+require_relative 'test_helper'
+require 'rack'
+
+describe 'Ur rack integration' do
+  it 'builds from a rack env' do
+    env = Rack::MockRequest.env_for('https://ur.unth.net/', {'HTTP_FOO' => 'bar'})
+    ur = Ur.from_rack_request(env)
+    assert_equal('inbound', ur.bound)
+    assert_equal('GET', ur.request['method'])
+    assert_equal('bar', ur.request.headers['foo'])
+    assert_equal('https://ur.unth.net/', ur.request.uri)
+    assert(ur.response.empty?)
+    assert_instance_of(Time, ur.processing.began_at)
+    assert_nil(ur.processing.duration)
+    assert(ur.validate)
+  end
+  it 'builds from a rack request' do
+    env = Rack::Request.new(Rack::MockRequest.env_for('https://ur.unth.net/', {'HTTP_FOO' => 'bar'}))
+    ur = Ur.from_rack_request(env)
+    assert_equal('inbound', ur.bound)
+    assert_equal('GET', ur.request['method'])
+    assert_equal('bar', ur.request.headers['foo'])
+    assert_equal('https://ur.unth.net/', ur.request.uri)
+    assert(ur.response.empty?)
+    assert_instance_of(Time, ur.processing.began_at)
+    assert_nil(ur.processing.duration)
+    assert(ur.validate)
+  end
+end

data/test/ur_test.rb

@@ -0,0 +1,105 @@
+require_relative 'test_helper'
+require 'faraday'
+require 'active_support/tagged_logging'
+
+describe 'Ur' do
+  it 'has a valid schema' do
+    Ur.schema.validate_schema!
+  end
+
+  it 'initializes' do
+    Ur.new({})
+  end
+
+  it 'would prefer not to initialize' do
+    assert_raises(TypeError) { Ur.new("hello!") }
+  end
+
+  it 'integrates with rack and faraday middlewares' do
+    rack_app = proc do |env|
+      [200, {'Content-Type' => 'text/plain'}, ['ᚒ']]
+    end
+    client_logger = ActiveSupport::TaggedLogging.new(Logger.new(StringIO.new))
+    server_logger = ActiveSupport::TaggedLogging.new(Logger.new(StringIO.new))
+    called_rack_before_request = false
+    called_rack_after_response = false
+    called_faraday_before_request = false
+    called_faraday_after_response = false
+    rack_app = Ur::RackMiddleware.new(rack_app, logger: server_logger,
+      before_request: -> (ur) do
+        called_rack_before_request = true
+
+        server_logger.push_tags 'ur_test_rack'
+
+        assert_equal('inbound', ur.bound)
+        assert_equal('GET', ur.request['method'])
+        assert_equal('ur.unth.net', ur.request.headers['host'])
+        assert_equal('bar', ur.request.headers['foo'])
+        assert_equal('https://ur.unth.net/', ur.request.uri)
+        assert(ur.response.empty?)
+        assert_instance_of(Time, ur.processing.began_at)
+        assert_nil(ur.processing.duration)
+        assert(ur.validate)
+      end,
+      after_response: -> (ur) do
+        called_rack_after_response = true
+
+        server_logger.pop_tags
+
+        assert_equal('inbound', ur.bound)
+        assert_equal('GET', ur.request['method'])
+        assert_equal(200, ur.response.status)
+        assert_equal('text/plain', ur.response.headers['Content-Type'])
+        assert_equal('ᚒ', ur.response.body)
+        assert_instance_of(Time, ur.processing.began_at)
+        assert_instance_of(Float, ur.processing.duration)
+        assert_operator(ur.processing.duration, :>, 0)
+        assert_equal(['ur_test_rack'], ur.processing.tags.to_a)
+        assert(ur.validate)
+      end,
+    )
+    faraday_conn = ::Faraday.new('https://ur.unth.net/') do |builder|
+      builder.use(Ur::FaradayMiddleware, logger: client_logger,
+        before_request: -> (ur) do
+          called_faraday_before_request = true
+
+          client_logger.push_tags 'ur_test_faraday'
+
+          assert_equal('outbound', ur.bound)
+          assert_equal('get', ur.request['method'])
+          assert_equal('bar', ur.request.headers['foo'])
+          assert_equal('https://ur.unth.net/', ur.request.uri)
+          assert_equal(Addressable::URI.parse('https://ur.unth.net/'), ur.request.addressable_uri)
+          assert(ur.response.empty?)
+          assert_instance_of(Time, ur.processing.began_at)
+          assert_nil(ur.processing.duration)
+          assert(ur.validate)
+        end,
+        after_response: -> (ur) do
+          called_faraday_after_response = true
+
+          client_logger.pop_tags
+
+          assert_equal('outbound', ur.bound)
+          assert_equal('get', ur.request['method'])
+          assert_equal(200, ur.response.status)
+          assert_equal('text/plain', ur.response.headers['Content-Type'])
+          assert_equal('ᚒ', ur.response.body)
+          assert_instance_of(Time, ur.processing.began_at)
+          assert_instance_of(Float, ur.processing.duration)
+          assert_operator(ur.processing.duration, :>, 0)
+          assert_equal(['ur_test_faraday'], ur.processing.tags.to_a)
+          assert(ur.validate)
+        end,
+      )
+      builder.use(Faraday::Adapter::Rack, rack_app)
+    end
+    res = faraday_conn.get('/', nil, {'Foo' => 'bar'})
+    assert(called_rack_before_request)
+    assert(called_rack_after_response)
+    assert(called_faraday_before_request)
+    assert(called_faraday_after_response)
+    assert_equal(200, res.status)
+    assert_equal('ᚒ', res.body)
+  end
+end

data/ur.gemspec

@@ -0,0 +1,43 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ur/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ur"
+  spec.version       = UR_VERSION
+  spec.authors       = ["Ethan"]
+  spec.email         = ["ethan@unth"]
+
+  spec.summary       = 'ur: unified request representation'
+  spec.description   = 'ur provides a unified representation of a request and response. it can be interpreted from rack, faraday, or potentially other sources, and provides a consistent interface to access the attributes inherent to the request and additional useful parsers and computation from the request.'
+  spec.homepage      = "https://github.com/notEthan/ur"
+  spec.license       = "MIT"
+
+  ignore_files = %w(.gitignore .travis.yml Gemfile test)
+  ignore_files_re = %r{\A(#{ignore_files.map { |f| Regexp.escape(f) }.join('|')})(/|\z)}
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  Dir.chdir(File.expand_path('..', __FILE__)) do
+    spec.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(ignore_files_re) }
+    spec.test_files  = `git ls-files -z test`.split("\x0") + [
+      '.simplecov',
+    ]
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "jsi", "~> 0.0.2"
+  spec.add_dependency "addressable", "~> 2.0"
+  spec.add_development_dependency "rack"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "faraday"
+  spec.add_development_dependency "faraday_middleware"
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: ur
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ethan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jsi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: rack-test
+  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: faraday
+  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: faraday_middleware
+  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: activesupport
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  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: simplecov
+  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'
+description: ur provides a unified representation of a request and response. it can
+  be interpreted from rack, faraday, or potentially other sources, and provides a
+  consistent interface to access the attributes inherent to the request and additional
+  useful parsers and computation from the request.
+email:
+- ethan@unth
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".simplecov"
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile.rb
+- lib/ur.rb
+- lib/ur/middleware.rb
+- lib/ur/processing.rb
+- lib/ur/request.rb
+- lib/ur/request_and_response.rb
+- lib/ur/response.rb
+- lib/ur/version.rb
+- test/test_helper.rb
+- test/ur_faraday_test.rb
+- test/ur_processing_test.rb
+- test/ur_rack_test.rb
+- test/ur_test.rb
+- ur.gemspec
+homepage: https://github.com/notEthan/ur
+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.7.7
+signing_key: 
+specification_version: 4
+summary: 'ur: unified request representation'
+test_files:
+- test/test_helper.rb
+- test/ur_faraday_test.rb
+- test/ur_processing_test.rb
+- test/ur_rack_test.rb
+- test/ur_test.rb
+- ".simplecov"