xenon 0.0.1 → 0.0.2

data/spec/xenon/headers/accept_spec.rb

@@ -0,0 +1,54 @@
+require 'xenon/headers/accept'
+
+describe Xenon::Headers::Accept do
+
+  context '::parse' do
+    it 'can parse a basic accept range' do
+      header = Xenon::Headers::Accept.parse('text/plain; q=0.5')
+      expect(header.media_ranges.size).to eq(1)
+      expect(header.media_ranges[0].to_s).to eq('text/plain; q=0.5')
+    end
+
+    it 'can parse the first example from RFC 7231 § 5.3.2 with the right precedence' do
+      header = Xenon::Headers::Accept.parse('text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c')
+      expect(header.media_ranges.size).to eq(4)
+      expect(header.media_ranges[0].to_s).to eq('text/html')
+      expect(header.media_ranges[1].to_s).to eq('text/x-c')
+      expect(header.media_ranges[2].to_s).to eq('text/x-dvi; q=0.8')
+      expect(header.media_ranges[3].to_s).to eq('text/plain; q=0.5')
+    end
+
+    it 'can parse the second example from RFC 7231 § 5.3.2 with the right precedence' do
+      header = Xenon::Headers::Accept.parse('text/*, text/plain, text/plain;format=flowed, */*')
+      expect(header.media_ranges.size).to eq(4)
+      expect(header.media_ranges[0].to_s).to eq('text/plain; format=flowed')
+      expect(header.media_ranges[1].to_s).to eq('text/plain')
+      expect(header.media_ranges[2].to_s).to eq('text/*')
+      expect(header.media_ranges[3].to_s).to eq('*/*')
+    end
+
+    it 'can parse the third example from RFC 7231 § 5.3.2 with the right precedence' do
+      header = Xenon::Headers::Accept.parse('text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5')
+      expect(header.media_ranges.size).to eq(5)
+      expect(header.media_ranges[0].to_s).to eq('text/html; level=1')
+      expect(header.media_ranges[1].to_s).to eq('text/html; level=2; q=0.4')
+      expect(header.media_ranges[2].to_s).to eq('text/html; q=0.7')
+      expect(header.media_ranges[3].to_s).to eq('text/*; q=0.3')
+      expect(header.media_ranges[4].to_s).to eq('*/*; q=0.5')
+    end
+  end
+
+  context '#merge' do
+    it 'can merge two headers with the right precedence' do
+      h1 = Xenon::Headers::Accept.parse('text/plain; q=0.5, text/html')
+      h2 = Xenon::Headers::Accept.parse('text/x-c, text/x-dvi; q=0.8')
+      header = h1.merge(h2)
+      expect(header.media_ranges.size).to eq(4)
+      expect(header.media_ranges[0].to_s).to eq('text/html')
+      expect(header.media_ranges[1].to_s).to eq('text/x-c')
+      expect(header.media_ranges[2].to_s).to eq('text/x-dvi; q=0.8')
+      expect(header.media_ranges[3].to_s).to eq('text/plain; q=0.5')
+    end
+  end
+
+end

data/spec/xenon/headers/authorization_spec.rb

@@ -0,0 +1,47 @@
+require 'xenon/headers/authorization'
+
+describe Xenon::Headers::Authorization do
+
+  context '::parse' do
+    it 'can parse Basic credentials' do
+      header = Xenon::Headers::Authorization.parse('Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==')
+      expect(header.credentials.class).to eq(Xenon::BasicCredentials)
+      expect(header.credentials.username).to eq('Aladdin')
+      expect(header.credentials.password).to eq('open sesame')
+    end
+
+    it 'can parse Digest credentials' do
+      header = Xenon::Headers::Authorization.parse('Digest username="Mufasa"' +
+        ', realm="testrealm@host.com"' +
+        ', nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093"' +
+        ', uri="/dir/index.html"' +
+        ', qop=auth' +
+        ', nc=00000001' +
+        ', cnonce="0a4f113b"' +
+        ', response="6629fae49393a05397450978507c4ef1"' +
+        ', opaque="5ccc069c403ebaf9f0171e9517f40e41"')
+      expect(header.credentials.class).to eq(Xenon::GenericCredentials)
+      expect(header.credentials.scheme).to eq('Digest')
+      expect(header.credentials.token).to eq(nil)
+      expect(header.credentials.params).to eq(
+        'username' => 'Mufasa',
+        'realm' => 'testrealm@host.com',
+        'nonce' => 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+        'uri' => '/dir/index.html',
+        'qop' => 'auth',
+        'nc' => '00000001',
+        'cnonce' => '0a4f113b',
+        'response' => '6629fae49393a05397450978507c4ef1',
+        'opaque' => '5ccc069c403ebaf9f0171e9517f40e41')
+    end
+
+    it 'can parse Bearer credentials' do
+      header = Xenon::Headers::Authorization.parse('Bearer eyJhbGciOiJub25lIn0.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.')
+      expect(header.credentials.class).to eq(Xenon::GenericCredentials)
+      expect(header.credentials.scheme).to eq('Bearer')
+      expect(header.credentials.token).to eq('eyJhbGciOiJub25lIn0.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.')    
+      expect(header.credentials.params).to eq({})
+    end
+  end
+
+end

data/spec/xenon/headers/cache_control_spec.rb

@@ -0,0 +1,64 @@
+require 'xenon/headers/cache_control'
+
+describe Xenon::Headers::CacheControl do
+
+  context '::parse' do
+    ['max-age', 'max-stale', 'min-fresh', 's-maxage'].each do |dir|
+      it "can parse the #{dir} directive" do
+        header = Xenon::Headers::CacheControl.parse("#{dir}=5")
+        expect(header.directives.size).to eq(1)
+        expect(header.directives[0].to_s).to eq("#{dir}=5")
+      end
+
+      it "can parse the #{dir} directive with a quoted value" do # should not be sent by clients but is permitted
+        header = Xenon::Headers::CacheControl.parse("#{dir}=\"5\"")
+        expect(header.directives.size).to eq(1)
+        expect(header.directives[0].to_s).to eq("#{dir}=5")
+      end
+    end
+
+    ['no-cache', 'no-store', 'no-transform', 'only-if-cached', 'must-revalidate', 'public', 'proxy-revalidate'].each do |dir|
+      it "can parse the #{dir} directive" do
+        header = Xenon::Headers::CacheControl.parse("#{dir}")
+        expect(header.directives.size).to eq(1)
+        expect(header.directives[0].to_s).to eq("#{dir}")
+      end
+    end
+
+    it "can parse the private directive with no field names" do
+      header = Xenon::Headers::CacheControl.parse('private')
+      expect(header.directives.size).to eq(1)
+      expect(header.directives[0].to_s).to eq('private')
+    end
+
+    # TODO: private directive with field names
+
+    it 'can parse extension directives with quoted string values' do
+      header = Xenon::Headers::CacheControl.parse('ext="hello \"world\""')
+      expect(header.directives.size).to eq(1)
+      expect(header.directives[0].name).to eq('ext')
+      expect(header.directives[0].value).to eq("hello \"world\"")
+    end
+
+    it 'can parse more complex directives' do
+      header = Xenon::Headers::CacheControl.parse('public, max-age=3600, must-revalidate')
+      expect(header.directives.size).to eq(3)
+      expect(header.directives[0].to_s).to eq('public')
+      expect(header.directives[1].to_s).to eq('max-age=3600')
+      expect(header.directives[2].to_s).to eq('must-revalidate')
+    end
+  end
+
+  context '#merge' do
+    it 'can merge two headers and maintain directive order' do
+      h1 = Xenon::Headers::CacheControl.parse('public, max-age=3600')
+      h2 = Xenon::Headers::CacheControl.parse('must-revalidate')
+      header = h1.merge(h2)
+      expect(header.directives.size).to eq(3)
+      expect(header.directives[0].to_s).to eq('public')
+      expect(header.directives[1].to_s).to eq('max-age=3600')
+      expect(header.directives[2].to_s).to eq('must-revalidate')
+    end
+  end
+
+end

data/spec/xenon/media_type_spec.rb

@@ -0,0 +1,267 @@
+require 'xenon/media_type'
+
+describe Xenon::MediaType do
+
+  context '::parse' do
+    it 'can parse basic media types' do
+      mt = Xenon::MediaType.parse('application/json')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('json')
+    end
+    it 'can parse media types with a subtype suffix' do
+      mt = Xenon::MediaType.parse('application/rss+xml')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('rss+xml')
+    end
+
+    it 'can parse media types with parameters' do
+      mt = Xenon::MediaType.parse('text/plain; format=flowed; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'strips whitespace around separators' do
+      mt = Xenon::MediaType.parse('text/plain ; format = flowed ; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'raises an error when the media type contains wildcards' do
+      expect { Xenon::MediaType.parse('*/*') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('application/*') }.to raise_error(Xenon::ParseError)
+    end
+
+    it 'raises an error when the media type is invalid' do
+      expect { Xenon::MediaType.parse('application') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('application; foo=bar') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('/json') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('/json; foo=bar') }.to raise_error(Xenon::ParseError)
+    end
+  end
+
+  %w(application audio image message multipart text video).each do |type|
+    context "#{type}?" do
+      it "returns true when the root type is '#{type}'" do
+        mt = Xenon::MediaType.new(type, 'dummy')
+        expect(mt.send("#{type}?")).to eq(true)
+      end
+
+      it "returns false when the root type is not '#{type}'" do
+        mt = Xenon::MediaType.new('dummy', 'dummy')
+        expect(mt.send("#{type}?")).to eq(false)
+      end
+    end
+  end
+
+  { experimental?: 'x', personal?: 'prs', vendor?: 'vnd' }.each do |method, prefix|
+    context method do
+      it "returns true when the subtype starts with '#{prefix}.'" do
+        mt = Xenon::MediaType.new('application', "#{prefix}.dummy")
+        expect(mt.send(method)).to eq(true)
+      end
+
+      it "returns false when the subtype does not start with '#{prefix}.'" do
+        mt = Xenon::MediaType.new('application', "dummy.dummy")
+        expect(mt.send(method)).to eq(false)
+      end
+    end
+  end
+
+  %w(ber der fastinfoset json wbxml xml zip).each do |format|
+    context "#{format}?" do
+      it "returns true when the subtype is '#{format}'" do
+        mt = Xenon::MediaType.new('application', format)
+        expect(mt.send("#{format}?")).to eq(true)
+      end
+
+      it "returns true when the subtype ends with '+#{format}'" do
+        mt = Xenon::MediaType.new('application', "dummy+#{format}")
+        expect(mt.send("#{format}?")).to eq(true)
+      end
+
+      it "returns false when the subtype is not '#{format}' and does not end with '+#{format}'" do
+        mt = Xenon::MediaType.new('dummy', 'dummy+dummy')
+        expect(mt.send("#{format}?")).to eq(false)
+      end
+    end
+  end
+
+  context '#to_s' do
+    it 'returns the string representation of a media type' do
+      mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+      expect(mt.to_s).to eq('text/plain; format=flowed; paged')
+    end
+  end
+  
+end
+
+describe Xenon::MediaRange do
+
+  context '::parse' do
+    it 'can parse basic media ranges' do
+      mt = Xenon::MediaRange.parse('application/json')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('json')
+    end
+
+    it 'can parse media ranges with parameters' do
+      mt = Xenon::MediaRange.parse('text/plain; format=flowed; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'strips whitespace around separators' do
+      mt = Xenon::MediaRange.parse('text/plain ; format = flowed ; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'can parse media ranges with subtype wildcards' do
+      mt = Xenon::MediaRange.parse('application/*')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('*')
+    end
+
+    it 'can parse media ranges with type and subtype wildcards' do
+      mt = Xenon::MediaRange.parse('*/*')
+      expect(mt.type).to eq('*')
+      expect(mt.subtype).to eq('*')
+    end
+
+    it 'extracts q from the parameters' do
+      mt = Xenon::MediaRange.parse('text/plain; q=0.8; format=flowed; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.q).to eq(0.8)
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'uses the default value for q if the value is not numeric' do
+      mt = Xenon::MediaRange.parse('application/json; q=foo')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('json')
+      expect(mt.q).to eq(Xenon::MediaRange::DEFAULT_Q)
+    end
+
+    it 'raises an error when the media range is invalid' do
+      expect { Xenon::MediaRange.parse('application') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('application; foo=bar') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('*/json') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('/json') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('/json; foo=bar') }.to raise_error(Xenon::ParseError)
+    end
+  end
+
+  context '#<=>' do
+    it 'considers a wildcard type less than a regular type' do
+      mr1 = Xenon::MediaRange.new('*', '*')
+      mr2 = Xenon::MediaRange.new('text', '*')
+      expect(mr1 <=> mr2).to eq(-1)
+    end
+
+    it 'considers a wildcard subtype less than a regular subtype' do
+      mr1 = Xenon::MediaRange.new('application', '*')
+      mr2 = Xenon::MediaRange.new('text', 'plain')
+      expect(mr1 <=> mr2).to eq(-1)
+    end
+
+    it 'considers media ranges with type and subtype equal' do
+      mr1 = Xenon::MediaRange.new('application', 'json')
+      mr2 = Xenon::MediaRange.new('text', 'plain')
+      expect(mr1 <=> mr2).to eq(0)
+    end
+
+    it 'considers a media range with parameters greater than one without' do
+      mr1 = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
+      mr2 = Xenon::MediaRange.new('text', 'plain')
+      expect(mr1 <=> mr2).to eq(1)
+    end
+
+    it 'does not consider the quality when one media range is more specific' do
+      mr1 = Xenon::MediaRange.new('application', '*', 'q' => '0.3')
+      mr2 = Xenon::MediaRange.new('*', '*', 'q' => '0.5')
+      expect(mr1 <=> mr2).to eq(1)
+    end
+
+    it 'considers the quality when media ranges are equally specific' do
+      mr1 = Xenon::MediaRange.new('application', 'json', 'q' => '0.8')
+      mr2 = Xenon::MediaRange.new('application', 'xml')
+      expect(mr1 <=> mr2).to eq(-1)
+    end
+  end
+
+  %i(=~ ===).each do |name|
+    context "##{name}" do
+      it 'returns true when the type and subtype are wildcards' do
+        mr = Xenon::MediaRange.new('*', '*')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the type matches and subtype is a wildcard' do
+        mr = Xenon::MediaRange.new('application', '*')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the type and subtype match exactly' do
+        mr = Xenon::MediaRange.new('application', 'json')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the type, subtype and parameters match exactly' do
+        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
+        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the the media type has more specific parameters' do
+        mr = Xenon::MediaRange.new('text', 'plain')
+        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns false when the type is different' do
+        mr = Xenon::MediaRange.new('text', 'json')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+
+      it 'returns false when the type matches but subtype is different' do
+        mr = Xenon::MediaRange.new('application', 'xml')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+
+      it 'returns false when the media range has more specific parameters' do
+        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+        mt = Xenon::MediaType.new('text', 'plain')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+
+      it 'returns false when the media range has a different parameter value' do
+        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
+        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'linear')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+    end
+  end
+
+  context '#to_s' do
+    it 'returns the string representation of a media range' do
+      mt = Xenon::MediaRange.new('text', 'plain', 'q' => 0.8, 'format' => 'flowed', 'paged' => nil)
+      expect(mt.to_s).to eq('text/plain; format=flowed; paged; q=0.8')
+    end
+
+    it 'omits the q parameter when it is 1.0' do
+      mt = Xenon::MediaRange.new('application', 'json', 'q' => 1.0)
+      expect(mt.to_s).to eq('application/json')
+    end
+  end
+
+end

data/xenon.gemspec

@@ -18,7 +18,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_runtime_dependency 'activesupport', '~> 4.0'
+  spec.add_runtime_dependency 'parslet', '~> 1.7'
+
   spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end