ur 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06e6df921036d0111ac6b57e937508d5689d30bbb702ebfc691749a9c31884ed
-  data.tar.gz: d160635a422395081f510059b7916aa9264c3289c3cc1d9170769c32c6d1cbb3
+  metadata.gz: 551019c356f6c251fc9330e21d58be49983302fa74754598d44a5ce02c8b6fec
+  data.tar.gz: 06e531326d20440cf145328ae17f07251053aeb5a4af3ecfbf8d925620b7e89a
 SHA512:
-  metadata.gz: 41b9e773174eb1beaa88b128ebde4e75830e4c9bc9ee907bcbf24e9be7157ba0cff8a980bdc8b18a978a02d990d7933dcd3ae88fdacba81ed59f87046d36a559
-  data.tar.gz: 42dc377e5da9acccb960e35dea7d7d874c5a90b5965b025b0dd2a8c6443b89eae282f1f034bcee450dd8962bb06470d7016cbeaebf24871e3851853db83654ff
+  metadata.gz: d68634fbde7ef1511914392857f6248db0a8bba6f18a044b262da2d10912c5059d4eb08c3953d1cc18d2a4fbd8b27bc6face500211b2fbb8c1eef85083aecd84
+  data.tar.gz: dbf33cc387daf9d82181330f029335a89c179582d614c2d77d07359c806203aebaa2e2c86fe785f568529f0cb2cdb255a74f37e623404f7335fd5da40f4cb175

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.1.0
+- rename processing to metadata
+- Ur::ContentType
+
 # v0.0.4
 - bump JSI v0.2.0
 

data/README.md

@@ -4,13 +4,13 @@ Ur: Unified Request/Response Representation in Ruby
 
 ## Properties
 
-An ur primarily consists of a request, a response, and additional processing information.
+An ur primarily consists of a request, a response, and additional metadata.
 
 The request consists of the request method, uri, headers, and body.
 
 The response consists of the response status, headers, and body.
 
-The processing information consists of the time the request began, the duration of the request, or tag strings. This is optional.
+The metadata consist of the time the request began, the duration of the request, or tag strings. This is optional.
 
 Other attributes may be present, and are ignored by this library.
 

data/lib/ur.rb

@@ -3,43 +3,10 @@ require "ur/version"
 require 'jsi'
 require 'time'
 require 'addressable/uri'
+require 'pathname'
 
-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'}}
-      },
-    },
-  },
-})
+UR_ROOT = Pathname.new(__FILE__).dirname.parent.expand_path
+Ur = JSI.class_for_schema(YAML.load_file(UR_ROOT.join('resources/ur.schema.yml')))
 class Ur
   VERSION = UR_VERSION
 
@@ -52,12 +19,12 @@ class Ur
 
   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'])
+  Metadata = JSI.class_for_schema(self.schema['properties']['metadata'])
   require 'ur/request'
   require 'ur/response'
-  require 'ur/processing'
+  require 'ur/metadata'
 
-  autoload :ContentTypeAttrs, 'ur/content_type_attrs'
+  autoload :ContentType, 'ur/content_type'
 
   class << self
     def from_rack_request(request_env)
@@ -70,7 +37,7 @@ class Ur
       end
 
       new({'bound' => 'inbound'}).tap do |ur|
-        ur.processing.begin!
+        ur.metadata.begin!
 
         ur.request['method'] = rack_request.request_method
 
@@ -103,7 +70,7 @@ class Ur
 
     def from_faraday_request(request_env, logger: nil)
       new({'bound' => 'outbound'}).tap do |ur|
-        ur.processing.begin!
+        ur.metadata.begin!
         ur.request['method'] = request_env[:method].to_s
         ur.request.uri = request_env[:url].normalize.to_s
         ur.request.headers = request_env[:request_headers]
@@ -119,12 +86,12 @@ class Ur
     end
     self.request = {} if self.request.nil?
     self.response = {} if self.response.nil?
-    self.processing = {} if self.processing.nil?
+    self.metadata = {} if self.metadata.nil?
   end
 
   def logger=(logger)
     if logger && logger.formatter.respond_to?(:current_tags)
-      processing.tags = logger.formatter.current_tags.dup
+      metadata.tags = logger.formatter.current_tags.dup
     end
   end
 
@@ -136,7 +103,7 @@ class Ur
     response.body = response_body.to_enum.to_a.join('')
 
     response_body_proxy = ::Rack::BodyProxy.new(response_body) do
-      processing.finish!
+      metadata.finish!
 
       yield
     end
@@ -148,7 +115,7 @@ class Ur
       response.status = response_env[:status]
       response.headers = response_env[:response_headers]
       response.set_body_from_faraday(response_env)
-      processing.finish!
+      metadata.finish!
 
       yield(response_env)
     end

data/lib/ur/content_type.rb

@@ -0,0 +1,243 @@
+require 'ur' unless Object.const_defined?(:Ur)
+
+class Ur
+  # Ur::ContentType represents a Content-Type header field.
+  # it parses the media type and its components, as well as any parameters.
+  #
+  # this class aims to be permissive in what it will parse. it will not raise any
+  # error when given a malformed or syntactically invalid Content-Type string.
+  # fields and parameters parsed from invalid Content-Type strings are undefined,
+  # but this class generally tries to make the most sense of what it's given.
+  #
+  # this class is based on RFCs:
+  # - Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content
+  #   Section 3.1.1.1. Media Type
+  #   https://tools.ietf.org/html/rfc7231#section-3.1.1.1
+  # - Media Type Specifications and Registration Procedures https://tools.ietf.org/html/rfc6838
+  # - Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies.
+  #   Section 5.1. Syntax of the Content-Type Header Field
+  #   https://tools.ietf.org/html/rfc2045#section-5.1
+  # - Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types
+  #   https://tools.ietf.org/html/rfc2046
+  class ContentType < String
+    # the character ranges in this SHOULD be significantly more restrictive,
+    # and the /<subtype> construct should not be optional. however, we'll aim
+    # to match whatever media type we are given.
+    #
+    # example:
+    #     MEDIA_TYPE_REGEXP.match('application/vnd.github+json').named_captures
+    #     =>
+    #     {
+    #       "media_type" => "application/vnd.github+json",
+    #       "type" => "application",
+    #       "subtype" => "vnd.github+json",
+    #       "facet" => "vnd",
+    #       "suffix" => "json",
+    #     }
+    #
+    # example of being more permissive than the spec allows:
+    #     MEDIA_TYPE_REGEXP.match('where the %$*! am I').named_captures
+    #     =>
+    #     {
+    #       "media_type" => "where the %$*! am I",
+    #       "type" => "where the %$*! am I",
+    #       "subtype" => nil,
+    #       "facet" => nil,
+    #       "suffix" => nil
+    #     }
+    MEDIA_TYPE_REGEXP = %r{
+      (?<media_type>       # the media type includes the type and subtype
+        (?<type>[^\/;\"]*) # the type precedes the first slash
+        (?:\/              # slash
+          (?<subtype>      # the subtype includes the facet, the suffix, and bits in between
+            (?:
+              (?<facet>[^.+;\"]*) # the facet name comes before the first . in the subtype
+              \.             # dot
+            )?
+            [^\+;\"]*      # anything between facet and suffix
+            (?:\+          # plus
+              (?<suffix>[^;\"]*) # optional suffix
+            )?
+          )
+        )? # the subtype should not be optional, but we will match a type without subtype anyway
+      )
+    }x
+
+    def initialize(*a)
+      super
+
+      scanner = StringScanner.new(self)
+
+      if scanner.scan(MEDIA_TYPE_REGEXP)
+        @media_type = scanner[:media_type].strip.freeze if scanner[:media_type]
+        @type      = scanner[:type].strip.freeze       if scanner[:type]
+        @subtype  = scanner[:subtype].strip.freeze    if scanner[:subtype]
+        @facet   = scanner[:facet].strip.freeze      if scanner[:facet]
+        @suffix = scanner[:suffix].strip.freeze     if scanner[:suffix]
+      end
+
+      @parameters = Hash.new do |h, k|
+        if k.respond_to?(:downcase) && k != k.downcase
+          h[k.downcase]
+        else
+          nil
+        end
+      end
+
+      while scanner.scan(/(;\s*)+/)
+        key = scanner.scan(/[^;=\"]*/)
+        if key && scanner.scan(/=/)
+          value = String.new
+          until scanner.eos? || scanner.check(/;/)
+            if scanner.scan(/\s+/)
+              ws = scanner[0]
+              # discard trailing whitespace.
+              # other whitespace isn't technically valid but we are permissive so we put it in the value.
+              value << ws unless scanner.eos? || scanner.check(/;/)
+            elsif scanner.scan(/"/)
+              until scanner.eos? || scanner.scan(/"/)
+                if scanner.scan(/\\/)
+                  value << scanner.getch unless scanner.eos?
+                end
+                value << scanner.scan(/[^\"\\]*/)
+              end
+            else
+              value << scanner.scan(/[^\s;\"]*/)
+            end
+          end
+          @parameters[key.downcase.freeze] = value.freeze
+        end
+      end
+
+      @parameters.freeze
+
+      freeze
+    end
+
+    # @return [String, nil] the media type of this content type.
+    #   e.g. "application/vnd.github+json" in content-type: application/vnd.github+json; charset="utf-8"
+    attr_reader :media_type
+
+    # @return [String, nil] the 'type' portion of our media type.
+    #   e.g. "application" in content-type: application/vnd.github+json; charset="utf-8"
+    attr_reader :type
+
+    # @return [String, nil] the 'subtype' portion of our media type.
+    #   e.g. "vnd.github+json" in content-type: application/vnd.github+json; charset="utf-8"
+    attr_reader :subtype
+
+    # @return [String, nil] the 'facet' portion of our media type.
+    #   e.g. "vnd" in content-type: application/vnd.github+json; charset="utf-8"
+    attr_reader :facet
+
+    # @return [String, nil] the 'suffix' portion of our media type.
+    #   e.g. "json" in content-type: application/vnd.github+json; charset="utf-8"
+    attr_reader :suffix
+
+    # @return [Hash<String, String>] parameters of this content type.
+    #   e.g. {"charset" => "utf-8"} in content-type: application/vnd.github+json; charset="utf-8"
+    attr_reader :parameters
+
+    # @param other_type
+    # @return [Boolean] is the 'type' portion of our media type equal (case-insensitive) to the given other_type
+    def type?(other_type)
+      type && type.casecmp?(other_type)
+    end
+
+    # @param other_subtype
+    # @return [Boolean] is the 'subtype' portion of our media type equal (case-insensitive) to the given other_subtype
+    def subtype?(other_subtype)
+      subtype && subtype.casecmp?(other_subtype)
+    end
+
+    # @param other_suffix
+    # @return [Boolean] is the 'suffix' portion of our media type equal (case-insensitive) to the given other_suffix
+    def suffix?(other_suffix)
+      suffix && suffix.casecmp?(other_suffix)
+    end
+
+    SOME_TEXT_SUBTYPES = %w(
+      x-www-form-urlencoded
+      json
+      json-seq
+      jwt
+      jose
+      yaml
+      x-yaml
+      xml
+      html
+      css
+      javascript
+      ecmascript
+    ).map(&:freeze).freeze
+
+    # @param unknown [Boolean] return this value when we have no idea whether
+    #   our media type is binary or text.
+    # @return [Boolean] does this content type appear to be binary?
+    #   this library makes its best guess based on a very incomplete knowledge
+    #   of which media types indicate binary or text.
+    def binary?(unknown: true)
+      return false if type_text?
+
+      SOME_TEXT_SUBTYPES.each do |cmpsubtype|
+        return false if (suffix ? suffix.casecmp?(cmpsubtype) : subtype ? subtype.casecmp?(cmpsubtype) : false)
+      end
+
+      # these are generally binary
+      return true if type_image? || type_audio? || type_video?
+
+      # we're out of ideas
+      return unknown
+    end
+
+    # @return [Boolean] is this a JSON content type?
+    def json?
+      suffix ? suffix.casecmp?('json') : subtype ? subtype.casecmp?('json') : false
+    end
+
+    # @return [Boolean] is this an XML content type?
+    def xml?
+      suffix ? suffix.casecmp?('xml'): subtype ? subtype.casecmp?('xml') : false
+    end
+
+    # @return [Boolean] is this a x-www-form-urlencoded content type?
+    def form_urlencoded?
+      suffix ? suffix.casecmp?('x-www-form-urlencoded'): subtype ? subtype.casecmp?('x-www-form-urlencoded') : false
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'text'
+    def type_text?
+      type && type.casecmp?('text')
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'image'
+    def type_image?
+      type && type.casecmp?('image')
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'audio'
+    def type_audio?
+      type && type.casecmp?('audio')
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'video'
+    def type_video?
+      type && type.casecmp?('video')
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'application'
+    def type_application?
+      type && type.casecmp?('application')
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'message'
+    def type_message?
+      type && type.casecmp?('message')
+    end
+
+    # @return [Boolean] is the 'type' portion of our media type 'multipart'
+    def type_multipart?
+      type && type.casecmp?('multipart')
+    end
+  end
+end

data/lib/ur/{processing.rb → metadata.rb}

@@ -1,7 +1,7 @@
 require 'ur' unless Object.const_defined?(:Ur)
 
 class Ur
-  class Processing
+  class Metadata
     include SubUr
 
     def began_at

data/lib/ur/request_and_response.rb

@@ -20,20 +20,30 @@ class Ur
     end
     include FaradayEntity
 
-    def content_type_attrs
-      return @content_type_attrs if instance_variable_defined?(:@content_type_attrs)
-      @content_type_attrs = ContentTypeAttrs.new(content_type)
-    end
-
     def content_type
       headers.each do |k, v|
-        return v if k =~ /\Acontent[-_]type\z/i
+        return ContentType.new(v) if k =~ /\Acontent[-_]type\z/i
       end
       nil
     end
 
     def media_type
-      content_type_attrs.media_type
+      content_type ? content_type.media_type : nil
+    end
+
+    # @return [Boolean] is our content type JSON?
+    def json?
+      content_type && content_type.json?
+    end
+
+    # @return [Boolean] is our content type XML?
+    def xml?
+      content_type && content_type.json?
+    end
+
+    # @return [Boolean] is our content type x-www-form-urlencoded?
+    def form_urlencoded?
+      content_type && content_type.form_urlencoded?
     end
   end
 end

data/lib/ur/version.rb

@@ -1 +1 @@
-UR_VERSION = "0.0.4".freeze
+UR_VERSION = "0.1.0".freeze

data/resources/ur.schema.yml

@@ -0,0 +1,45 @@
+id: https://schemas.ur.unth.net/ur
+type: object
+properties:
+  bound:
+    type: string
+    description: '[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: '[rfc2616] The Method token indicates the method to be performed on the resource identified by the Request-URI.'
+        example: POST
+      uri:
+        type: string
+        format: uri
+        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
+  metadata:
+    type: object
+    properties:
+      began_at_s:
+        type: string
+      duration:
+        type: number
+      tags:
+        type: array
+        items:
+          type: string

data/test/content_type_test.rb

@@ -0,0 +1,342 @@
+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

@@ -11,9 +11,20 @@ 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

data/test/ur_metadata_test.rb

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

data/test/ur_rack_test.rb

@@ -10,8 +10,8 @@ describe 'Ur rack integration' do
     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_instance_of(Time, ur.metadata.began_at)
+    assert_nil(ur.metadata.duration)
     assert(ur.validate)
   end
   it 'builds from a rack request' do
@@ -22,8 +22,8 @@ describe 'Ur rack integration' do
     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_instance_of(Time, ur.metadata.began_at)
+    assert_nil(ur.metadata.duration)
     assert(ur.validate)
   end
 end

data/test/ur_test.rb

@@ -37,8 +37,8 @@ describe 'Ur' do
         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_instance_of(Time, ur.metadata.began_at)
+        assert_nil(ur.metadata.duration)
         assert(ur.validate)
       end,
       after_response: -> (ur) do
@@ -51,10 +51,10 @@ describe 'Ur' do
         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_instance_of(Time, ur.metadata.began_at)
+        assert_instance_of(Float, ur.metadata.duration)
+        assert_operator(ur.metadata.duration, :>, 0)
+        assert_equal(['ur_test_rack'], ur.metadata.tags.to_a)
         assert(ur.validate)
       end,
     )
@@ -71,8 +71,8 @@ describe 'Ur' do
           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_instance_of(Time, ur.metadata.began_at)
+          assert_nil(ur.metadata.duration)
           assert(ur.validate)
         end,
         after_response: -> (ur) do
@@ -85,10 +85,10 @@ describe 'Ur' do
           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_instance_of(Time, ur.metadata.began_at)
+          assert_instance_of(Float, ur.metadata.duration)
+          assert_operator(ur.metadata.duration, :>, 0)
+          assert_equal(['ur_test_faraday'], ur.metadata.tags.to_a)
           assert(ur.validate)
         end,
       )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ur
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-27 00:00:00.000000000 Z
+date: 2019-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsi
@@ -181,19 +181,21 @@ files:
 - README.md
 - Rakefile.rb
 - lib/ur.rb
-- lib/ur/content_type_attrs.rb
+- lib/ur/content_type.rb
 - lib/ur/faraday.rb
 - lib/ur/faraday/yield_ur.rb
+- lib/ur/metadata.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/sub_ur.rb
 - lib/ur/version.rb
+- resources/ur.schema.yml
+- test/content_type_test.rb
 - test/test_helper.rb
 - test/ur_faraday_test.rb
-- test/ur_processing_test.rb
+- test/ur_metadata_test.rb
 - test/ur_rack_test.rb
 - test/ur_test.rb
 - ur.gemspec
@@ -222,9 +224,10 @@ 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_processing_test.rb
+- test/ur_metadata_test.rb
 - test/ur_rack_test.rb
 - test/ur_test.rb
 - ".simplecov"

data/lib/ur/content_type_attrs.rb

@@ -1,83 +0,0 @@
-require 'ur' unless Object.const_defined?(:Ur)
-
-class Ur
-  # parses attributes out of content type header
-  class ContentTypeAttrs
-    def initialize(content_type)
-      raise(ArgumentError) unless content_type.nil? || content_type.respond_to?(:to_str)
-      content_type = content_type.to_str if content_type
-      @media_type = (content_type.split(/\s*[;]\s*/, 2).first if content_type)
-      @media_type.strip! if @media_type
-      @content_type = content_type
-      @parsed = false
-      @attributes = Hash.new { |h,k| h[k] = [] }
-      catch(:unparseable) do
-        throw(:unparseable) unless content_type
-        uri_parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
-        scanner = StringScanner.new(content_type)
-        scanner.scan(/.*;\s*/) || throw(:unparseable)
-        while scanner.scan(/(\w+)=("?)([^"]*)("?)\s*(,?)\s*/)
-          key = scanner[1]
-          quote1 = scanner[2]
-          value = scanner[3]
-          quote2 = scanner[4]
-          comma_follows = !scanner[5].empty?
-          throw(:unparseable) unless quote1 == quote2
-          throw(:unparseable) if !comma_follows && !scanner.eos?
-          @attributes[uri_parser.unescape(key)] << uri_parser.unescape(value)
-        end
-        throw(:unparseable) unless scanner.eos?
-        @parsed = true
-      end
-    end
-
-    attr_reader :content_type, :media_type
-
-    def parsed?
-      @parsed
-    end
-
-    def [](key)
-      @attributes[key]
-    end
-
-    def text?
-      # ordered hash by priority mapping types to binary or text
-      # regexps will have \A and \z added 
-      types = {
-        %r(image/.*) => :binary,
-        %r(audio/.*) => :binary,
-        %r(video/.*) => :binary,
-        %r(model/.*) => :binary,
-        %r(text/.*) => :text,
-        %r(message/.*) => :text,
-        %r(application/(.+\+)?json) => :text,
-        %r(application/(.+\+)?xml) => :text,
-        %r(model/(.+\+)?xml) => :text,
-        'application/x-www-form-urlencoded' => :text,
-        'application/javascript' => :text,
-        'application/ecmascript' => :text,
-        'application/octet-stream' => :binary,
-        'application/ogg' => :binary,
-        'application/pdf' => :binary,
-        'application/postscript' => :binary,
-        'application/zip' => :binary,
-        'application/gzip' => :binary,
-        'application/vnd.apple.pkpass' => :binary,
-      }
-      types.each do |match, type|
-        matched = match.is_a?(Regexp) ? media_type =~ %r(\A#{match.source}\z) : media_type == match
-        if matched
-          return type == :text
-        end
-      end
-      # fallback (unknown or not given) assume that unknown content types are binary but omitted 
-      # content-type means text
-      if content_type && content_type =~ /\S/
-        return false
-      else
-        return true
-      end
-    end
-  end
-end

data/test/ur_processing_test.rb

@@ -1,11 +0,0 @@
-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