ur 0.2.0 → 0.2.2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ur
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Ethan
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-06 00:00:00.000000000 Z
+date: 2023-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsi
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -38,148 +38,20 @@ dependencies:
     - - "~>"
       - !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: rake
-  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: 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: 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
+- ethan.ur@unth.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".simplecov"
 - ".yardopts"
 - CHANGELOG.md
 - LICENSE.md
 - README.md
-- Rakefile.rb
 - lib/ur.rb
 - lib/ur/content_type.rb
 - lib/ur/faraday.rb
@@ -191,20 +63,14 @@ files:
 - lib/ur/response.rb
 - lib/ur/sub_ur.rb
 - lib/ur/version.rb
-- resources/icons/LGPL-3.0.png
+- lib/ur/weblink.rb
 - resources/ur.schema.yml
-- test/content_type_test.rb
-- test/test_helper.rb
-- test/ur_faraday_test.rb
-- test/ur_metadata_test.rb
-- test/ur_rack_test.rb
-- test/ur_test.rb
 - ur.gemspec
 homepage: https://github.com/notEthan/ur
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -219,15 +85,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: 'ur: unified request representation'
-test_files:
-- test/content_type_test.rb
-- test/test_helper.rb
-- test/ur_faraday_test.rb
-- test/ur_metadata_test.rb
-- test/ur_rack_test.rb
-- test/ur_test.rb
-- ".simplecov"
+test_files: []

data/.simplecov

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

data/Rakefile.rb

@@ -1,9 +0,0 @@
-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/test/content_type_test.rb

@@ -1,342 +0,0 @@
-require_relative 'test_helper'
-
-describe 'Ur::ContentType' do
-  let(:content_type) { Ur::ContentType.new(content_type_str) }
-  describe 'application/vnd.github+json; charset="utf-8"' do
-    let(:content_type_str) { 'application/vnd.github+json; charset="utf-8"' }
-    it 'parses' do
-      assert_equal(content_type, content_type_str)
-
-      assert_equal('application/vnd.github+json', content_type.media_type)
-
-      assert_equal('application', content_type.type)
-      assert(content_type.type?('Application'))
-      assert(content_type.type_application?)
-
-      assert_equal('vnd.github+json', content_type.subtype)
-      assert_equal('vnd', content_type.facet)
-      assert_equal('json', content_type.suffix)
-
-      assert_equal({'charset' => 'utf-8'}, content_type.parameters)
-      assert_equal('utf-8', content_type.parameters['CharSet'])
-    end
-  end
-  describe 'no subtype' do
-    let(:content_type_str) { 'application; charset="utf-8"' }
-    it 'will allow it' do
-      assert_equal(content_type, content_type_str)
-
-      assert_equal('application', content_type.media_type)
-
-      assert_equal('application', content_type.type)
-      assert(content_type.type?('Application'))
-
-      assert_equal(nil, content_type.subtype)
-      assert_equal(nil, content_type.facet)
-      assert_equal(nil, content_type.suffix)
-
-      assert_equal({'charset' => 'utf-8'}, content_type.parameters)
-      assert_equal('utf-8', content_type.parameters['CharSet'])
-    end
-  end
-  describe 'no facet' do
-    let(:content_type_str) { 'application/github+json; charset="utf-8"' }
-    it 'parses' do
-      assert_equal(content_type, content_type_str)
-
-      assert_equal('application/github+json', content_type.media_type)
-
-      assert_equal('application', content_type.type)
-      assert(content_type.type?('Application'))
-
-      assert_equal('github+json', content_type.subtype)
-      assert_equal(nil, content_type.facet)
-      assert_equal('json', content_type.suffix)
-
-      assert_equal({'charset' => 'utf-8'}, content_type.parameters)
-      assert_equal('utf-8', content_type.parameters['CharSet'])
-    end
-  end
-  describe 'no suffix' do
-    let(:content_type_str) { 'application/vnd.github.json; charset="utf-8"' }
-    it 'parses' do
-      assert_equal(content_type, content_type_str)
-
-      assert_equal('application/vnd.github.json', content_type.media_type)
-
-      assert_equal('application', content_type.type)
-      assert(content_type.type?('Application'))
-
-      assert_equal('vnd.github.json', content_type.subtype)
-      assert_equal('vnd', content_type.facet)
-      assert_equal(nil, content_type.suffix)
-
-      assert_equal({'charset' => 'utf-8'}, content_type.parameters)
-      assert_equal('utf-8', content_type.parameters['CharSet'])
-    end
-    describe('[invalid] quote in type') do
-      let(:content_type_str) { 'applic"ation/foo; foo=bar' }
-      it('gives up') do
-        assert_equal('applic', content_type.type)
-        assert_equal(nil, content_type.subtype)
-      end
-    end
-    describe('[invalid] backslash in type') do
-      let(:content_type_str) { 'applicati\on/foo; foo=bar' }
-      it('parses') do
-        assert_equal('applicati\\on', content_type.type)
-        assert_equal('foo', content_type.subtype)
-      end
-    end
-    describe('[invalid] quote in subtype') do
-      let(:content_type_str) { 'application/f"oo; foo=bar' }
-      it('gives up') do
-        assert_equal('application', content_type.type)
-        assert_equal('f', content_type.subtype)
-      end
-    end
-    describe('[invalid] backslash in subtype') do
-      let(:content_type_str) { 'application/fo\\o; foo=bar' }
-      it('parses') do
-        assert_equal('application', content_type.type)
-        assert_equal('fo\\o', content_type.subtype)
-      end
-    end
-  end
-  describe 'parameters' do
-    describe 'basic usage' do
-      let(:content_type_str) { 'application/foo; charset="utf-8"; foo=bar' }
-      it('parses') do
-        assert_equal({'charset' => 'utf-8', 'foo' => 'bar'}, content_type.parameters)
-      end
-    end
-    describe 'params with capitalization' do
-      let(:content_type_str) { 'application/foo; Charset="utf-8"; FOO=bar' }
-      it('parses') do
-        assert_equal({'charset' => 'utf-8', 'foo' => 'bar'}, content_type.parameters)
-        assert_equal('utf-8', content_type.parameters['CharSet'])
-        assert_equal('utf-8', content_type.parameters['Charset'])
-        assert_equal('bar', content_type.parameters['foo'])
-        assert_equal('bar', content_type.parameters['FOO'])
-      end
-    end
-    describe 'repeated params' do
-      let(:content_type_str) { 'application/foo; foo="first"; foo=second' }
-      it('will just overwrite') do
-        assert_equal({'foo' => 'second'}, content_type.parameters)
-      end
-    end
-    describe 'repeated params, different capitalization' do
-      let(:content_type_str) { 'application/foo; FOO=first; Foo=second' }
-      it('will just overwrite') do
-        assert_equal({'foo' => 'second'}, content_type.parameters)
-      end
-    end
-    describe 'empty strings' do
-      let(:content_type_str) { 'application/foo; empty1=; empty2=""' }
-      it('parses') do
-        assert_equal({'empty1' => '', 'empty2' => ''}, content_type.parameters)
-      end
-    end
-    describe 'empty strings with whitespace' do
-      let(:content_type_str) { 'application/foo; empty1=  ; empty2=""   ' }
-      it('parses') do
-        assert_equal({'empty1' => '', 'empty2' => ''}, content_type.parameters)
-      end
-    end
-    describe('[invalid] opening quote only') do
-      let(:content_type_str) { 'application/foo; foo=1; bar="' }
-      it('parses') do
-        assert_equal({'foo' => '1', 'bar' => ''}, content_type.parameters)
-      end
-    end
-    describe('[invalid] backlash with no character') do
-      let(:content_type_str) { 'application/foo; foo=1; bar="\\' }
-      it('parses') do
-        assert_equal({'foo' => '1', 'bar' => ''}, content_type.parameters)
-      end
-    end
-    describe('[invalid] extra following quoted string') do
-      let(:content_type_str) { 'application/foo; foo="1" 2; bar=3' }
-      it('sorta parses') do
-        assert_equal({'foo' => '1 2', 'bar' => '3'}, content_type.parameters)
-      end
-    end
-    describe('[invalid] quotes silliness') do
-      let(:content_type_str) { 'application/foo; foo="1" 2 "3 4" "5 "  ; bar=3' }
-      it('sorta parses') do
-        assert_equal({'foo' => '1 2 3 4 5 ', 'bar' => '3'}, content_type.parameters)
-      end
-    end
-    describe('[invalid] backlash quote') do
-      let(:content_type_str) { 'application/foo; foo=1; bar="\\"' }
-      it('parses') do
-        assert_equal({'foo' => '1', 'bar' => '"'}, content_type.parameters)
-      end
-    end
-    describe('[invalid] trailing ;') do
-      let(:content_type_str) { 'application/foo; foo=bar;' }
-      it('parses') do
-        assert_equal({'foo' => 'bar'}, content_type.parameters)
-      end
-    end
-    describe('[invalid] extra ; inline') do
-      let(:content_type_str) { 'application/foo; ; ; foo=bar' }
-      it('parses') do
-        assert_equal({'foo' => 'bar'}, content_type.parameters)
-      end
-    end
-    describe('[invalid] whitespace around the =') do
-      let(:content_type_str) { 'application/foo; foo = bar; baz = qux' }
-      it('parses') do
-        assert_equal({'foo ' => ' bar', 'baz ' => ' qux'}, content_type.parameters)
-      end
-    end
-    describe('whitespace before the ;') do
-      let(:content_type_str) { 'application/foo; foo=bar ; baz=qux' }
-      it('parses') do
-        assert_equal({'foo' => 'bar', 'baz' => 'qux'}, content_type.parameters)
-      end
-    end
-    describe('no media_type') do
-      let(:content_type_str) { '; foo=bar' }
-      it('parses') do
-        assert_equal({'foo' => 'bar'}, content_type.parameters)
-      end
-    end
-    describe('[invalid] quote in parameter name') do
-      let(:content_type_str) { 'application/foo; fo"o=bar' }
-      it('gives up') do
-        assert_equal({}, content_type.parameters)
-      end
-    end
-    describe('[invalid] backslash in parameter name') do
-      let(:content_type_str) { 'application/foo; fo\\o=bar' }
-      it('parses') do
-        assert_equal({'fo\\o' => 'bar'}, content_type.parameters)
-      end
-    end
-  end
-  describe 'binary?' do
-    binary_content_type_strs = [
-      'audio/ogg',
-      'Audio/OGG; foo=bar',
-      'VIDEO/foo+bar',
-    ]
-    binary_content_type_strs.each do |binary_content_type_str|
-      describe(binary_content_type_str) do
-        let(:content_type_str) { binary_content_type_str }
-        it 'is binary' do
-          assert(content_type.binary?(unknown: false))
-        end
-      end
-    end
-    not_binary_content_type_strs = [
-      'text/anything',
-      'TEXT/plain; charset=foo',
-      'application/JSON',
-      'media/foo+Json; foo="bar"',
-    ]
-    not_binary_content_type_strs.each do |not_binary_content_type_str|
-      describe(not_binary_content_type_str) do
-        let(:content_type_str) { not_binary_content_type_str }
-        it 'is not binary' do
-          assert(!content_type.binary?(unknown: true))
-        end
-      end
-    end
-    unknown_content_type_strs = [
-      'foo',
-      'foo/bar; note="not application/json"',
-      'application/jsonisnotthis',
-      'application/octet-stream',
-    ]
-    unknown_content_type_strs.each do |unknown_content_type_str|
-      describe(unknown_content_type_str) do
-        let(:content_type_str) { unknown_content_type_str }
-        it 'is unknown' do
-          assert(content_type.binary?(unknown: true))
-          assert(!content_type.binary?(unknown: false))
-        end
-      end
-    end
-  end
-  describe 'json?' do
-    json_content_type_strs = [
-      'application/json',
-      'Application/Json; charset=EBCDIC',
-      'Text/json',
-      'MEDIA/JSON',
-      'media/foo.bar+json',
-      'media/foo.bar+json; foo=',
-    ]
-    json_content_type_strs.each do |json_content_type_str|
-      describe(json_content_type_str) do
-        let(:content_type_str) { json_content_type_str }
-        it 'is json' do
-          assert(content_type.json?)
-        end
-      end
-    end
-    not_json_content_type_strs = [
-      'json',
-      'foo/bar; note="not application/json"',
-      'application/jsonisnotthis',
-      'text/json+xml', # I don't even know what I'm trying for here
-    ]
-    not_json_content_type_strs.each do |not_json_content_type_str|
-      describe(not_json_content_type_str) do
-        let(:content_type_str) { not_json_content_type_str }
-        it 'is not json' do
-          assert(!content_type.json?)
-        end
-      end
-    end
-  end
-  describe 'xml?' do
-    xml_content_type_strs = [
-      'application/xml',
-      'Application/Xml; charset=EBCDIC',
-      'Text/xml',
-      'MEDIA/XML',
-      'media/foo.bar+xml',
-      'media/foo.bar+xml; foo=',
-    ]
-    xml_content_type_strs.each do |xml_content_type_str|
-      describe(xml_content_type_str) do
-        let(:content_type_str) { xml_content_type_str }
-        it 'is xml' do
-          assert(content_type.xml?)
-        end
-      end
-    end
-    not_xml_content_type_strs = [
-      'xml',
-      'foo/bar; note="not application/xml"',
-      'application/xmlisnotthis',
-      'text/xml+json', # I don't even know what I'm trying for here
-    ]
-    not_xml_content_type_strs.each do |not_xml_content_type_str|
-      describe(not_xml_content_type_str) do
-        let(:content_type_str) { not_xml_content_type_str }
-        it 'is not xml' do
-          assert(!content_type.xml?)
-        end
-      end
-    end
-  end
-  describe 'form_urlencoded?' do
-    describe('application/x-www-form-urlencoded') do
-      let(:content_type_str) { 'application/x-www-form-urlencoded' }
-      it 'is form_urlencoded' do
-        assert(content_type.form_urlencoded?)
-      end
-    end
-    describe('application/foo') do
-      let(:content_type_str) { 'application/foo' }
-      it 'is not form_urlencoded' do
-        assert(!content_type.form_urlencoded?)
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,33 +0,0 @@
-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
-  if ENV['UR_TEST_ALPHA']
-    # :nocov:
-    define_singleton_method(:test_order) { :alpha }
-    # :nocov:
-  end
-
-  def assert_json_equal(exp, act, *a)
-    assert_equal(JSI::Typelike.as_json(exp), JSI::Typelike.as_json(act), *a)
-  end
-
-  def assert_equal exp, act, msg = nil
-    msg = message(msg, E) { diff exp, act }
-    assert exp == act, msg
-  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

@@ -1,79 +0,0 @@
-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.adapter(:rack, -> (env) { [200, {'Content-Type' => 'text/plain'}, ['ᚒ']] })
-    end
-    res = faraday_conn.get('/')
-    assert_equal('ᚒ', res.body)
-    assert_kind_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.adapter(:rack, -> (env) { [200, {'Content-Type' => 'text/plain'}, ['☺']] })
-    end
-    res = faraday_conn.post('/', StringIO.new('hello!'))
-    assert_equal('☺', res.body)
-    assert_kind_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.adapter(:rack, -> (env) { [200, {'Content-Type' => 'application/json'}, ['{}']] })
-    end
-    res = faraday_conn.post('/', {'a' => 'b'})
-    assert_equal({}, res.body)
-    assert_kind_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.adapter(:rack, -> (env) { [200, {'Content-Type' => 'application/json'}, ['{}']] })
-    end
-    res = faraday_conn.post('/', {'a' => 'b'})
-    assert_equal({}, res.body)
-    assert_kind_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