ur 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85e941c9b4dad6807b7635acc90b762e4f096f38f8f981511be120e42effc7f9
-  data.tar.gz: cbca689430e05b3865b8572dacbc114201c4af217b0e893fade40ae2a74f3b12
+  metadata.gz: '08e517b90ad97d890764bc228d8836e7e48d7f8250ed7c3a4878368b77b2deb2'
+  data.tar.gz: e87aedb3a622a5606bff0370cc1a06f43d98be53488389c1902e989226760cd1
 SHA512:
-  metadata.gz: e45319855396792763e515a96d21ad3e56475461c9b8733b4d0dfb97dee9a2e3efac7107b0f58a510003ab70a17e64c367dde594ea8d0e3acd5a771be6a47044
-  data.tar.gz: b7d0f97850df360137870edefe21f321b9f919f84d1ec9be65c45e30461297b6e725d949e9051de6c7f87bd3d9bef25be1cb7479fc20356f8dfb2fd7cf79d58f
+  metadata.gz: '069f50e6768b41beb13830308fd3a3d18845c32fc38f6e95755b8f929ba88e20efcfce8f84abf50ed393a93f9c2971bb7b280e5793d43098c06dc034f136487c'
+  data.tar.gz: 42c005bf4853f4bb946a2bd143696c84fa84c6f933b71a6425505722aab150f290ab21265ac2b6e9fdaa313e0207becb46f5a14ff20a7cd2c18e4daa53d12084

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# v0.2.0
+
+- Ur uses JSI schema modules instead of classes
+
+# v0.1.1
+- minor fixes
+
+# v0.1.0
+- rename processing to metadata
+- Ur::ContentType
+
+# v0.0.4
+- bump JSI v0.2.0
+
+# v0.0.3
+- bump JSI v0.1.0
+
 # v0.0.2
 
 - module SubUr common to Ur::Request, Response, Processing

data/LICENSE.md

@@ -0,0 +1,169 @@
+Copright © [Ethan](https://github.com/notEthan/)
+
+[<img align="right" src="https://github.com/notEthan/ur/raw/master/resources/icons/LGPL-3.0.png">](https://www.gnu.org/licenses/lgpl-3.0.html)
+
+Ur is Open Source Software licensed under the terms of the [GNU Affero General Public License version 3](https://www.gnu.org/licenses/lgpl-3.0.html).
+
+GNU Lesser General Public License
+=================================
+
+_Version 3, 29 June 2007_  
+_Copyright © 2007 Free Software Foundation, Inc. &lt;<https://fsf.org/>&gt;_
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+
+This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+### 0. Additional Definitions
+
+As used herein, “this License” refers to version 3 of the GNU Lesser
+General Public License, and the “GNU GPL” refers to version 3 of the GNU
+General Public License.
+
+“The Library” refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+An “Application” is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A “Combined Work” is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the “Linked
+Version”.
+
+The “Minimal Corresponding Source” for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The “Corresponding Application Code” for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+### 1. Exception to Section 3 of the GNU GPL
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+### 2. Conveying Modified Versions
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+* **a)** under this License, provided that you make a good faith effort to
+ensure that, in the event an Application does not supply the
+function or data, the facility still operates, and performs
+whatever part of its purpose remains meaningful, or
+
+* **b)** under the GNU GPL, with none of the additional permissions of
+this License applicable to that copy.
+
+### 3. Object Code Incorporating Material from Library Header Files
+
+The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+* **a)** Give prominent notice with each copy of the object code that the
+Library is used in it and that the Library and its use are
+covered by this License.
+* **b)** Accompany the object code with a copy of the GNU GPL and this license
+document.
+
+### 4. Combined Works
+
+You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+* **a)** Give prominent notice with each copy of the Combined Work that
+the Library is used in it and that the Library and its use are
+covered by this License.
+
+* **b)** Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+* **c)** For a Combined Work that displays copyright notices during
+execution, include the copyright notice for the Library among
+these notices, as well as a reference directing the user to the
+copies of the GNU GPL and this license document.
+
+* **d)** Do one of the following:
+    - **0)** Convey the Minimal Corresponding Source under the terms of this
+License, and the Corresponding Application Code in a form
+suitable for, and under terms that permit, the user to
+recombine or relink the Application with a modified version of
+the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying
+Corresponding Source.
+    - **1)** Use a suitable shared library mechanism for linking with the
+Library.  A suitable mechanism is one that **(a)** uses at run time
+a copy of the Library already present on the user's computer
+system, and **(b)** will operate properly with a modified version
+of the Library that is interface-compatible with the Linked
+Version.
+
+* **e)** Provide Installation Information, but only if you would otherwise
+be required to provide such information under section 6 of the
+GNU GPL, and only to the extent that such information is
+necessary to install and execute a modified version of the
+Combined Work produced by recombining or relinking the
+Application with a modified version of the Linked Version. (If
+you use option **4d0**, the Installation Information must accompany
+the Minimal Corresponding Source and Corresponding Application
+Code. If you use option **4d1**, you must provide the Installation
+Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+### 5. Combined Libraries
+
+You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+* **a)** Accompany the combined library with a copy of the same work based
+on the Library, uncombined with any other library facilities,
+conveyed under the terms of this License.
+* **b)** Give prominent notice with the combined library that part of it
+is a work based on the Library, and explaining where to find the
+accompanying uncombined form of the same work.
+
+### 6. Revised Versions of the GNU Lesser General Public License
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License “or any later version”
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -2,6 +2,18 @@
 
 Ur: Unified Request/Response Representation in Ruby
 
+## Properties
+
+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 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.
+
 ## Usage with middleware
 
 Rack middleware:
@@ -18,7 +30,7 @@ class MyRackMiddleware
     ur = Ur.from_rack_request(env)
 
     # set additional properties of the ur, for example:
-    ur.logger = my_logger
+    ur.logger_tags(my_logger)
 
     rack_response = ur.with_rack_response(@app, env) do
       # do things after the response
@@ -38,7 +50,7 @@ class MyFaradayMiddleware < ::Faraday::Middleware
     ur = Ur.from_faraday_request(request_env)
 
     # set additional properties of the ur, for example:
-    ur.logger = my_logger
+    ur.logger_tags(my_logger)
 
     ur.faraday_on_complete(@app, request_env) do |response_env|
       # do things after the response
@@ -49,4 +61,6 @@ end
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+[<img align="right" src="https://github.com/notEthan/ur/raw/master/resources/icons/LGPL-3.0.png">](https://www.gnu.org/licenses/lgpl-3.0.html)
+
+Ur is Open Source Software licensed under the terms of the [GNU Lesser General Public License version 3](https://www.gnu.org/licenses/lgpl-3.0.html).

data/Rakefile.rb

@@ -1,4 +1,3 @@
-require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|

data/lib/ur.rb

@@ -1,46 +1,15 @@
+# frozen_string_literal: true
+
 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'}}
-      },
-    },
-  },
-})
-class Ur
+UR_ROOT = Pathname.new(__FILE__).dirname.parent.expand_path
+Ur = JSI::Schema.new(YAML.load_file(UR_ROOT.join('resources/ur.schema.yml'))).jsi_schema_module
+module Ur
   VERSION = UR_VERSION
 
   autoload :SubUr, 'ur/sub_ur'
@@ -50,17 +19,30 @@ class Ur
   autoload :RackMiddleware, 'ur/middleware'
   autoload :Faraday, 'ur/faraday'
 
-  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'])
+  Request = self.schema.properties['request'].jsi_schema_module
+  Response = self.schema.properties['response'].jsi_schema_module
+  Metadata = self.schema.properties['metadata'].jsi_schema_module
   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)
+    def new(instance = {}, schemas: Set[], **options)
+      unless instance.respond_to?(:to_hash)
+        raise(TypeError, "expected hash for ur instance. got: #{instance.pretty_inspect.chomp}")
+      end
+
+      ur_class = JSI.class_for_schemas(Set[schema] + schemas)
+      ur_class.new(instance, options).tap do |ur|
+        ur.request = {} if ur.request.nil?
+        ur.response = {} if ur.response.nil?
+        ur.metadata = {} if ur.metadata.nil?
+      end
+    end
+
+    def from_rack_request(request_env, **options)
       if request_env.is_a?(Rack::Request)
         rack_request = request_env
         env = request_env.env
@@ -69,9 +51,17 @@ class Ur
         env = request_env
       end
 
-      new({'bound' => 'inbound'}).tap do |ur|
-        ur.processing.begin!
+      new({'bound' => 'inbound'}, options).tap do |ur|
         ur.request['method'] = rack_request.request_method
+
+        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?)
+        )
+
         ur.request.headers = env.map do |(key, value)|
           http_match = key.match(/\AHTTP_/)
           if http_match
@@ -84,44 +74,30 @@ class Ur
             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)
-      new({'bound' => 'outbound'}).tap do |ur|
-        ur.processing.begin!
+    def from_faraday_request(request_env, **options)
+      new({'bound' => 'outbound'}, options).tap do |ur|
         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.headers = request_env[:request_headers]
         ur.request.set_body_from_faraday(request_env)
       end
     end
   end
 
-  def initialize(ur = {}, **opt, &b)
-    ur = JSI::JSON::Node.new_doc(ur) unless ur.is_a?(JSI::JSON::Node)
-    super(ur, **opt, &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)
+  # Ur#logger_tags applies tags from a tagged logger to this ur's metadata.
+  # note: ur does not log anything and this logger is not stored.
+  # @param [logger] a tagged logger
+  # @return [void]
+  def logger_tags(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
 
@@ -133,8 +109,6 @@ class Ur
     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]
@@ -145,7 +119,6 @@ class Ur
       response.status = response_env[:status]
       response.headers = response_env[:response_headers]
       response.set_body_from_faraday(response_env)
-      processing.finish!
 
       yield(response_env)
     end
@@ -158,6 +131,7 @@ class Ur
   schema['properties'].each do |property_name, property_schema|
     if property_schema['type'] == 'object' && property_schema['properties']
       property_schema['properties'].each_key do |property_property_name|
+        # ur.request_method => ur['request']['method']
         define_method("#{property_name}_#{property_property_name}") do
           self[property_name][property_property_name]
         end

data/lib/ur/content_type.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'ur' unless Object.const_defined?(:Ur)
+
+module 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