ur 0.0.2 → 0.2.0

data/lib/ur/faraday.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
-class Ur
+module Ur
   module Faraday
     autoload :YieldUr, 'ur/faraday/yield_ur'
   end

data/lib/ur/faraday/yield_ur.rb

@@ -1,18 +1,12 @@
-class Ur
-  module Faraday
-    class YieldUr < ::Faraday::Middleware
-      def initialize(app, options = {}, &block)
-        @app = app
-        @options = options
-        @yield_to = block
-      end
+# frozen_string_literal: true
 
-      def call(request_env)
-        ur = Scorpio::Ur.from_faraday_request(request_env)
-        ur.logger = @options[:logger]
-        ur.faraday_on_complete(@app, request_env) do |response_env|
-          @yield_to.call(ur)
-        end
+module Ur
+  module Faraday
+    # Faraday middleware which yields an Ur to the given block
+    class YieldUr < ::Ur::FaradayMiddleware
+      def initialize(app, **options, &block)
+        raise(ArgumentError, "no block given to yield ur") unless block
+        super(app, options.merge(after_response: block))
       end
     end
   end

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'ur' unless Object.const_defined?(:Ur)
 
-class Ur
-  class Processing
+module Ur
+  module Metadata
     include SubUr
 
     def began_at
@@ -13,10 +15,13 @@ class Ur
 
     attr_accessor :began_at_ns
 
+    # sets began_at from the current time
     def begin!
-      self.began_at ||= Time.now
-      self.began_at_ns ||= Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+      self.began_at = Time.now
+      self.began_at_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
     end
+
+    # sets the duration from the current time and began_at
     def finish!
       return if duration
       if began_at_ns

data/lib/ur/middleware.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'ur' unless Object.const_defined?(:Ur)
 
-class Ur
+module Ur
   module Middleware
     def initialize(app, options = {})
       @app = app
@@ -9,6 +11,15 @@ class Ur
     attr_reader :app
     attr_reader :options
 
+    def begin_request(ur)
+      ur.metadata.begin!
+    end
+
+    def finish_request(ur)
+      ur.logger_tags(@options[:logger])
+      ur.metadata.finish!
+    end
+
     def invoke_callback(name, *a, &b)
       if @options[name]
         @options[name].call(*a, &b)
@@ -19,10 +30,11 @@ class Ur
   class FaradayMiddleware < ::Faraday::Middleware
     include Ur::Middleware
     def call(request_env)
-      ur = Ur.from_faraday_request(request_env)
+      ur = Ur.from_faraday_request(request_env, @options.select { |k, _| [:schemas].include?(k) })
       invoke_callback(:before_request, ur)
-      ur.logger = options[:logger] if options[:logger]
+      begin_request(ur)
       ur.faraday_on_complete(@app, request_env) do |response_env|
+        finish_request(ur)
         invoke_callback(:after_response, ur)
       end
     end
@@ -31,10 +43,11 @@ class Ur
   class RackMiddleware
     include Ur::Middleware
     def call(env)
-      ur = Ur.from_rack_request(env)
+      ur = Ur.from_rack_request(env, @options.select { |k, _| [:schemas].include?(k) })
       invoke_callback(:before_request, ur)
-      ur.logger = options[:logger] if options[:logger]
+      begin_request(ur)
       ur.with_rack_response(@app, env) do
+        finish_request(ur)
         invoke_callback(:after_response, ur)
       end
     end

data/lib/ur/request.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'ur' unless Object.const_defined?(:Ur)
 
-class Ur
-  class Request
+module Ur
+  module Request
     include RequestAndResponse
     include SubUr
 

data/lib/ur/request_and_response.rb

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 require 'ur' unless Object.const_defined?(:Ur)
 
-class Ur
+module Ur
+  # functionality common to Request and Response
   module RequestAndResponse
+    # functionality for handling request/response entities from Faraday
     module FaradayEntity
+      # @param env [Faraday::Env] faraday env passed to middleware #call
       def set_body_from_faraday(env)
         if env[:raw_body].respond_to?(:to_str)
           self.body = env[:raw_body].to_str.dup
@@ -20,20 +25,34 @@ 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
-
+    # @return [Ur::ContentType] the string value of the content type header. returns an
+    # {Ur::ContentType}, a subclass of String which additionally parses the Content-Type
+    # according to relevant RFCs.
     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
 
+    # the media type of the content type
     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.xml?
+    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/response.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'ur' unless Object.const_defined?(:Ur)
 
-class Ur
-  class Response
+module Ur
+  module Response
     include RequestAndResponse
     include SubUr
 

data/lib/ur/sub_ur.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'ur' unless Object.const_defined?(:Ur)
 
-class Ur
+module Ur
   module SubUr
     def ur
-      parents.detect { |p| p.is_a?(::Ur) }
+      parent_jsis.detect { |p| p.is_a?(::Ur) }
     end
   end
 end

data/lib/ur/version.rb

@@ -1 +1 @@
-UR_VERSION = "0.0.2"
+UR_VERSION = "0.2.0".freeze

data/resources/ur.schema.yml

@@ -0,0 +1,50 @@
+$id: https://schemas.ur.unth.net/ur
+type: object
+properties:
+  bound:
+    type: string
+    description: '[RFC7230] The terms "inbound" and "outbound" are used to describe directional requirements in relation to the request route: "inbound" means toward the origin server and "outbound" means toward the user agent.'
+    enum:
+    - inbound
+    - outbound
+  request:
+    type: object
+    properties:
+      method:
+        type: string
+        description: '[RFC7230] The method token indicates the request method to be performed on the target resource.'
+        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
+        description: >
+          The status-code element is a 3-digit integer code describing the
+          result of the server's attempt to understand and satisfy the client's
+          corresponding request.
+        example: 200
+      headers:
+        type: object
+      body:
+        type: string
+  metadata:
+    type: object
+    properties:
+      began_at_s:
+        type: string
+        format: date-time
+      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