optic14n 2.0.1 → 3.0.0

data/spec/c14n_spec.rb

@@ -1,195 +1,207 @@
-# encoding: utf-8
-
-require 'spec_helper'
+require "spec_helper"
 
 describe "Paul's tests, translated from Perl" do
-  it 'lowercases URLs' do
-    BLURI('http://www.EXAMPLE.COM/Foo/Bar/BAZ').canonicalize!.to_s.should == 'http://www.example.com/foo/bar/baz'
+  it "lowercases URLs" do
+    expect(BLURI("http://www.EXAMPLE.COM/Foo/Bar/BAZ").canonicalize!.to_s).to eq("http://www.example.com/foo/bar/baz")
   end
 
-  describe 'protocol' do
-    it 'translates protocol to http', reason: 'Reduces our input space, everything public anyway' do
-      BLURI('https://www.example.com').canonicalize!.to_s.should == 'http://www.example.com'
+  describe "protocol" do
+    it "translates protocol to http", reason: "Reduces our input space, everything public anyway" do
+      expect(BLURI("https://www.example.com").canonicalize!.to_s).to eq("http://www.example.com")
     end
   end
 
-  describe 'slashes' do
-    it 'drops single trailing slashes' do
-      BLURI('http://www.example.com/').canonicalize!.to_s.should == 'http://www.example.com'
+  describe "slashes" do
+    it "drops single trailing slashes" do
+      expect(BLURI("http://www.example.com/").canonicalize!.to_s).to eq("http://www.example.com")
     end
 
-    it 'drops multiple trailing slashes' do
-      BLURI('http://www.example.com////').canonicalize!.to_s.should == 'http://www.example.com'
+    it "drops multiple trailing slashes" do
+      expect(BLURI("http://www.example.com////").canonicalize!.to_s).to eq("http://www.example.com")
     end
 
-    it 'drops multiple trailing slashes on the path' do
-      BLURI('http://www.example.com/foo///').canonicalize!.to_s.should == 'http://www.example.com/foo'
+    it "drops multiple trailing slashes on the path" do
+      expect(BLURI("http://www.example.com/foo///").canonicalize!.to_s).to eq("http://www.example.com/foo")
     end
   end
 
-  describe 'fragments' do
-    it 'drops fragment identifier', reason: 'They won''t be mapped, so are redundant' do
-      BLURI('http://www.example.com#foo').canonicalize!.to_s.should == 'http://www.example.com'
+  describe "fragments" do
+    it "drops fragment identifier", reason: "They won't be mapped, so are redundant" do
+      expect(BLURI("http://www.example.com#foo").canonicalize!.to_s).to eq("http://www.example.com")
     end
-    it 'drops fragment identifier and slashes' do
-      BLURI('http://www.example.com/#foo').canonicalize!.to_s.should == 'http://www.example.com'
+    it "drops fragment identifier and slashes" do
+      expect(BLURI("http://www.example.com/#foo").canonicalize!.to_s).to eq("http://www.example.com")
     end
   end
 
-  describe 'Things to keep verbatim or encode', reason: 'http://tools.ietf.org/html/rfc3986' do
-    it 'retains colons' do
-      BLURI('http://www.example.com/:colon:').canonicalize!.to_s.should == 'http://www.example.com/:colon:'
+  describe "Things to keep verbatim or encode", reason: "http://tools.ietf.org/html/rfc3986" do
+    it "retains colons" do
+      expect(BLURI("http://www.example.com/:colon:").canonicalize!.to_s).to eq("http://www.example.com/:colon:")
     end
-    it 'retains tilde' do
-      BLURI('http://www.example.com/~tilde').canonicalize!.to_s.should == 'http://www.example.com/~tilde'
+    it "retains tilde" do
+      expect(BLURI("http://www.example.com/~tilde").canonicalize!.to_s).to eq("http://www.example.com/~tilde")
     end
-    it 'retains underscores' do
-      BLURI('http://www.example.com/_underscore_').canonicalize!.to_s.should == 'http://www.example.com/_underscore_'
+    it "retains underscores" do
+      expect(BLURI("http://www.example.com/_underscore_").canonicalize!.to_s).to eq("http://www.example.com/_underscore_")
     end
-    it 'retains asterisks' do
-      BLURI('http://www.example.com/*asterisk*').canonicalize!.to_s.should == 'http://www.example.com/*asterisk*'
+    it "retains asterisks" do
+      expect(BLURI("http://www.example.com/*asterisk*").canonicalize!.to_s).to eq("http://www.example.com/*asterisk*")
     end
-    it 'retains parens' do
-      BLURI('http://www.example.com/(parens)').canonicalize!.to_s.should == 'http://www.example.com/(parens)'
+    it "retains parens" do
+      expect(BLURI("http://www.example.com/(parens)").canonicalize!.to_s).to eq("http://www.example.com/(parens)")
     end
-    it 'escapes square brackets' do
-      BLURI('http://www.example.com/[square-brackets]').canonicalize!.to_s.should == 'http://www.example.com/%5bsquare-brackets%5d'
+    it "escapes square brackets" do
+      expect(BLURI("http://www.example.com/[square-brackets]").canonicalize!.to_s).to eq("http://www.example.com/%5bsquare-brackets%5d")
     end
-    it 'encodes commas and quotes', reason: 'They make csv harder to awk' do
-      BLURI("http://www.example.com/commas,and-\"quotes\"-make-CSV-harder-to-'awk'").canonicalize!.to_s.should ==
-          'http://www.example.com/commas%2cand-%22quotes%22-make-csv-harder-to-%27awk%27'
+    it "encodes commas and quotes", reason: "They make csv harder to awk" do
+      expect(BLURI("http://www.example.com/commas,and-\"quotes\"-make-CSV-harder-to-'awk'").canonicalize!.to_s).to eq(
+        "http://www.example.com/commas%2cand-%22quotes%22-make-csv-harder-to-%27awk%27",
+      )
     end
-    it 'encodes square brackets and pipes', reason: "It's problematic in curl and regexes" do
-      BLURI('http://www.example.com/problematic-in-curl[]||[and-regexes]').canonicalize!.to_s.should ==
-          'http://www.example.com/problematic-in-curl%5b%5d%7c%7c%5band-regexes%5d'
+    it "encodes square brackets and pipes", reason: "It's problematic in curl and regexes" do
+      expect(BLURI("http://www.example.com/problematic-in-curl[]||[and-regexes]").canonicalize!.to_s).to eq(
+        "http://www.example.com/problematic-in-curl%5b%5d%7c%7c%5band-regexes%5d",
+      )
     end
-    it 'decodes non-reserved characters (! and ~)' do
+    it "decodes non-reserved characters (! and ~)" do
       # My god, it's full of stars
-      BLURI('http://www.example.com/%7eyes%20I%20have%20now%20read%20%5brfc%203986%5d%2C%20%26%20I%27m%20a%20%3Dlot%3D%20more%20reassured%21%21').
-          canonicalize!.to_s.should == 'http://www.example.com/~yes%20i%20have%20now%20read%20%5brfc%203986%5d%2c%20%26%20i%27m%20a%20%3dlot%3d%20more%20reassured!!'
+      expect(BLURI("http://www.example.com/%7eyes%20I%20have%20now%20read%20%5brfc%203986%5d%2C%20%26%20I%27m%20a%20%3Dlot%3D%20more%20reassured%21%21")
+          .canonicalize!.to_s).to eq("http://www.example.com/~yes%20i%20have%20now%20read%20%5brfc%203986%5d%2c%20%26%20i%27m%20a%20%3dlot%3d%20more%20reassured!!")
     end
-    it 'encodes pound signs' do
-      BLURI('https://www.example.com/pound-sign-£').canonicalize!.to_s.should == 'http://www.example.com/pound-sign-%c2%a3'
+    it "encodes pound signs" do
+      expect(BLURI("https://www.example.com/pound-sign-£").canonicalize!.to_s).to eq("http://www.example.com/pound-sign-%c2%a3")
     end
   end
 
-  describe 'query strings' do
-    it 'disallows all query string params by default' do
-      BLURI('http://www.example.com?q=foo').canonicalize!.to_s.should == 'http://www.example.com'
+  describe "query strings" do
+    it "disallows all query string params by default" do
+      expect(BLURI("http://www.example.com?q=foo").canonicalize!.to_s).to eq("http://www.example.com")
     end
-    it 'disallows all params when there''s a slash' do
-      BLURI('http://www.example.com/?q=foo').canonicalize!.to_s.should == 'http://www.example.com'
+    it "disallows all params when there's a slash" do
+      expect(BLURI("http://www.example.com/?q=foo").canonicalize!.to_s).to eq("http://www.example.com")
     end
-    it 'disallows all params after a slash with fragid' do
-      BLURI('http://www.example.com/?q=foo#bar').canonicalize!.to_s.should == 'http://www.example.com'
+    it "disallows all params after a slash with fragid" do
+      expect(BLURI("http://www.example.com/?q=foo#bar").canonicalize!.to_s).to eq("http://www.example.com")
     end
 
-    describe 'allowing some or all query string values' do
-      it 'allows named query_string parameters' do
-        BLURI('http://www.example.com/?q=foo&r=bar').canonicalize!(allow_query: 'q').to_s.should ==
-            'http://www.example.com?q=foo'
+    describe "allowing some or all query string values" do
+      it "allows named query_string parameters" do
+        expect(BLURI("http://www.example.com/?q=foo&r=bar").canonicalize!(allow_query: "q").to_s).to eq(
+          "http://www.example.com?q=foo",
+        )
       end
-      it 'sorts query string values' do
-        BLURI('http://www.example.com?c=23&d=1&b=909&e=33&a=1').
-          canonicalize!(allow_query: [:b,:e,:c,:d,:a]).to_s.should == 'http://www.example.com?a=1&b=909&c=23&d=1&e=33'
+      it "sorts query string values" do
+        expect(BLURI("http://www.example.com?c=23&d=1&b=909&e=33&a=1")
+          .canonicalize!(allow_query: %i[b e c d a]).to_s).to eq("http://www.example.com?a=1&b=909&c=23&d=1&e=33")
       end
-      it 'encodes querystring values' do
-        BLURI("http://www.example.com?a=you're_dangerous").canonicalize!(allow_query: :all).to_s.should ==
-          'http://www.example.com?a=you%27re_dangerous'
+      it "encodes querystring values" do
+        expect(BLURI("http://www.example.com?a=you're_dangerous").canonicalize!(allow_query: :all).to_s).to eq(
+          "http://www.example.com?a=you%27re_dangerous",
+        )
       end
-      it 'whitelists and sorts query strings' do
-        BLURI('http://www.example.com?a=1&c=3&b=2').canonicalize!(allow_query: :all).to_s.should ==
-          'http://www.example.com?a=1&b=2&c=3'
+      it "whitelists and sorts query strings" do
+        expect(BLURI("http://www.example.com?a=1&c=3&b=2").canonicalize!(allow_query: :all).to_s).to eq(
+          "http://www.example.com?a=1&b=2&c=3",
+        )
       end
-      it 'converts matrix URI to query_string' do
-        BLURI('http://www.example.com?c=23;d=1;b=909;e=33;a=1').
-          canonicalize!(allow_query: [:b,:e,:c,:d,:a]).to_s.should == 'http://www.example.com?a=1&b=909&c=23&d=1&e=33'
+      it "converts matrix URI to query_string" do
+        expect(BLURI("http://www.example.com?c=23;d=1;b=909;e=33;a=1")
+          .canonicalize!(allow_query: %i[b e c d a]).to_s).to eq("http://www.example.com?a=1&b=909&c=23&d=1&e=33")
       end
-      it 'sorts cherry-picked query string arguments' do
-        BLURI('http://www.example.com?a=2322sdfsf&topic=334499&q=909&item=23444').
-          canonicalize!(allow_query: [:topic, :item]).to_s.should == 'http://www.example.com?item=23444&topic=334499'
+      it "sorts cherry-picked query string arguments" do
+        expect(BLURI("http://www.example.com?a=2322sdfsf&topic=334499&q=909&item=23444")
+          .canonicalize!(allow_query: %i[topic item]).to_s).to eq("http://www.example.com?item=23444&topic=334499")
       end
-      it 'ignores empty querystring values' do
-        BLURI('http://www.example.com?a=2322sdfsf&topic=334499&q=909&item=23444').
-          canonicalize!(allow_query: %w(foo bar baz)).to_s.should == 'http://www.example.com'
+      it "ignores empty querystring values" do
+        expect(BLURI("http://www.example.com?a=2322sdfsf&topic=334499&q=909&item=23444")
+          .canonicalize!(allow_query: %w[foo bar baz]).to_s).to eq("http://www.example.com")
       end
 
-      describe 'querystrings that are not an HTML-encoded thing' do
+      describe "querystrings that are not an HTML-encoded thing" do
         before do
-          @bluri = BLURI('http://some.com/a/path?foo&bar').canonicalize!(allow_query: :all)
+          @bluri = BLURI("http://some.com/a/path?foo&bar").canonicalize!(allow_query: :all)
         end
 
-        it 'retains the query string' do
-          @bluri.query.should == 'bar&foo'
+        it "retains the query string" do
+          expect(@bluri.query).to eq("bar&foo")
         end
 
-        it 'has a query hash with empty elements' do
-          @bluri.query_hash['foo'].should == nil
-          @bluri.query_hash['bar'].should == nil
+        it "has a query hash with empty elements" do
+          expect(@bluri.query_hash["foo"]).to eq(nil)
+          expect(@bluri.query_hash["bar"]).to eq(nil)
         end
 
-        it 'renders the string properly' do
-          @bluri.query_hash.to_s.should == 'bar&foo'
+        it "renders the string properly" do
+          expect(@bluri.query_hash.to_s).to eq("bar&foo")
         end
       end
 
-      describe 'casing of allowed query params' do
-        context 'when the query param contains upper-case letters' do
-          it 'does not preserve the query string, even when it appeared identically in the URL' do
-            BLURI('http://www.example.com/?Foo=bar').canonicalize!(allow_query: 'Foo').to_s.should ==
-                'http://www.example.com'
+      describe "casing of allowed query params" do
+        context "when the query param contains upper-case letters" do
+          it "does not preserve the query string, even when it appeared identically in the URL" do
+            expect(BLURI("http://www.example.com/?Foo=bar").canonicalize!(allow_query: "Foo").to_s).to eq(
+              "http://www.example.com",
+            )
           end
         end
 
-        context 'when the query param is lower-cased' do
-          it 'preserves the query string and lower-cases it' do
-            BLURI('http://www.example.com/?Foo=bar').canonicalize!(allow_query: 'foo').to_s.should ==
-                'http://www.example.com?foo=bar'
+        context "when the query param is lower-cased" do
+          it "preserves the query string and lower-cases it" do
+            expect(BLURI("http://www.example.com/?Foo=bar").canonicalize!(allow_query: "foo").to_s).to eq(
+              "http://www.example.com?foo=bar",
+            )
           end
         end
       end
 
-      describe 'indifferent specfication of allowed query params' do
-        context 'specifying the allowed query param using either a symbol or a string' do
-          it 'should behave the same' do
-            url = 'http://example.com/some?significant=1&query_params=2'
+      describe "indifferent specfication of allowed query params" do
+        context "specifying the allowed query param using either a symbol or a string" do
+          it "should behave the same" do
+            url = "http://example.com/some?significant=1&query_params=2"
 
             using_symbol = BLURI(url).canonicalize!(allow_query: :significant)
-            using_string = BLURI(url).canonicalize!(allow_query: 'significant')
+            using_string = BLURI(url).canonicalize!(allow_query: "significant")
 
-            using_symbol.should == using_string
+            expect(using_symbol).to eq(using_string)
           end
         end
       end
     end
 
-    describe 'degenerate cases' do
-      describe 'the treatment of query strings when there are query string octets that unescape to '\
-               'invalid UTF-8 sequences (we no longer treat these as failures)' do
-        it 'no longer raises exceptions when there are bad things in query values' do
-          BLURI('http://example.com/path?view=%ED').
-            canonicalize!(allow_query: :all).
-            to_s.should eql('http://example.com/path?view=%ED')
+    describe "degenerate cases" do
+      describe "the treatment of query strings when there are query string octets that unescape to "\
+               "invalid UTF-8 sequences (we no longer treat these as failures)" do
+        it "no longer raises exceptions when there are bad things in query values" do
+          expect(BLURI("http://example.com/path?view=%ED")
+            .canonicalize!(allow_query: :all)
+            .to_s).to eql("http://example.com/path?view=%ED")
         end
 
-        it 're-encodes correctly when there are bad things in query keys' do
-          BLURI('http://example.com/path?%ED=view').
-            canonicalize!(allow_query: :all).
-            to_s.should eql('http://example.com/path?%ED=view')
+        it "re-encodes correctly when there are bad things in query keys" do
+          expect(BLURI("http://example.com/path?%ED=view")
+            .canonicalize!(allow_query: :all)
+            .to_s).to eql("http://example.com/path?%ED=view")
         end
 
-        it 'does not error when there are bad things in query keys when allow_query isn\'t :all' do
-          expect { BLURI('http://some.com/a/path?%E2').canonicalize! }.not_to raise_error
+        it "does not error when there are bad things in query keys when allow_query isn't :all" do
+          expect { BLURI("http://some.com/a/path?%E2").canonicalize! }.not_to raise_error
         end
       end
 
-      describe 'failure to canonicalize paths correctly' do
+      describe "failure to canonicalize paths correctly" do
         # see https://www.pivotaltracker.com/s/projects/860575/stories/54502932
 
-        subject { BLURI('http://www.voa.gov.uk/stuff/?query=thing').canonicalize!(allow_query: :all) }
+        subject { BLURI("http://www.voa.gov.uk/stuff/?query=thing").canonicalize!(allow_query: :all) }
+
+        describe "#path" do
+          subject { super().path }
+          it { is_expected.to eql("/stuff") }
+        end
 
-        its(:path) { should eql('/stuff') }
-        its(:query) { should eql('query=thing') }
+        describe "#query" do
+          subject { super().query }
+          it { is_expected.to eql("query=thing") }
+        end
       end
     end
   end

data/spec/canonicalized_urls_spec.rb

@@ -1,57 +1,66 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Optic14n::CanonicalizedUrls do
-  describe 'c14nize' do
+  describe "c14nize" do
     let(:test_urls) do
-      %w(
+      %w[
         http://www.qhm.mod.uk/portsmouth/leisure/fuel
         http://www.qhm.mod.uk/portsmouth/leisure/lntm?
         http://www.qhm.mod.uk/portsmouth/leisure/lntm?action=view
         http://www.qhm.mod.uk/portsmouth/leisure/lntm?action=view&id=199
         http://unistats.direct.gov.uk/searchResults.do?pname=institutesearchresults&level3Subjects=L3.90%AC10007761%ACFIRSTDEGREE%ACFulltime%AC430%ACNo%AC60%ACYes%AC83%ACNo%ACYes
         1234://123
-      )
+      ]
     end
 
-    context 'options[:allow_query] is false' do
+    context "options[:allow_query] is false" do
       subject(:c14nizer) { Optic14n::CanonicalizedUrls.from_urls(test_urls, allow_query: false) }
 
-      it { should be_a(Optic14n::CanonicalizedUrls) }
+      it { is_expected.to be_a(Optic14n::CanonicalizedUrls) }
 
-      its(:seen) { should eql(6) }
+      describe "#seen" do
+        subject { super().seen }
+        it { is_expected.to eql(6) }
+      end
 
-      describe 'the output set' do
+      describe "the output set" do
         subject(:output_set) { c14nizer.output_set }
 
-        its(:size) { should eql(3) }
+        describe "#size" do
+          subject { super().size }
+          it { is_expected.to eql(3) }
+        end
 
-        describe 'the items' do
+        describe "the items" do
           subject { output_set.map(&:to_s) }
 
-          it { should include('http://www.qhm.mod.uk/portsmouth/leisure/fuel') }
-          it { should include('http://www.qhm.mod.uk/portsmouth/leisure/lntm') }
-          it { should include('http://unistats.direct.gov.uk/searchresults.do') }
+          it { is_expected.to include("http://www.qhm.mod.uk/portsmouth/leisure/fuel") }
+          it { is_expected.to include("http://www.qhm.mod.uk/portsmouth/leisure/lntm") }
+          it { is_expected.to include("http://unistats.direct.gov.uk/searchresults.do") }
         end
       end
     end
 
-    context 'options[:allow_query] is :all' do
+    context "options[:allow_query] is :all" do
       subject(:c14nizer) { Optic14n::CanonicalizedUrls.from_urls(test_urls, allow_query: :all) }
 
-      describe 'the output set' do
+      describe "the output set" do
         subject(:output_set) { c14nizer.output_set }
 
-        its(:size) { should eql(5) }
+        describe "#size" do
+          subject { super().size }
+          it { is_expected.to eql(5) }
+        end
       end
 
-      describe 'failures' do
+      describe "failures" do
         subject(:failures) { c14nizer.failures }
 
-        it { should be_a(Hash) }
+        it { is_expected.to be_a(Hash) }
 
-        it 'has our last URL and an error' do
+        it "has our last URL and an error" do
           e = failures[test_urls.last]
-          e.should be_an(Addressable::URI::InvalidURIError)
+          expect(e).to be_an(Addressable::URI::InvalidURIError)
         end
       end
     end

data/spec/query_hash_spec.rb

@@ -1,15 +1,29 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe URI::QueryHash do
   subject(:hash) { {}.extend URI::QueryHash }
 
-  its(:to_s) { should eql('') }
+  describe "#to_s" do
+    subject { super().to_s }
+    it { is_expected.to eql("") }
+  end
+
+  describe "setting a value by symbol" do
+    before { hash["x"] = "1" }
+
+    describe "[:x]" do
+      subject { super()[:x] }
+      it { is_expected.to eql("1") }
+    end
 
-  describe 'setting a value by symbol' do
-    before { hash['x'] = '1' }
+    describe "['x']" do
+      subject { super()["x"] }
+      it { is_expected.to eql("1") }
+    end
 
-    its([:x])    { should eql('1') }
-    its(['x'])   { should eql('1') }
-    its(:to_s)   { should eql('x=1') }
+    describe "#to_s" do
+      subject { super().to_s }
+      it { is_expected.to eql("x=1") }
+    end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1 +1 @@
-require 'optic14n'
+require "optic14n"

data/spec/uri/query_hash_spec.rb

@@ -1,11 +1,22 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe URI::QueryHash do
-  describe 'non-HTML encoded query strings' do
-    subject { { 'foo' => nil, 'bar' => nil }.extend URI::QueryHash }
+  describe "non-HTML encoded query strings" do
+    subject { { "foo" => nil, "bar" => nil }.extend URI::QueryHash }
 
-    its(['foo']) { should be_nil }
-    its(['bar']) { should be_nil }
-    its(:to_s)   { should eql('foo&bar') }
+    describe "['foo']" do
+      subject { super()["foo"] }
+      it { is_expected.to be_nil }
+    end
+
+    describe "['bar']" do
+      subject { super()["bar"] }
+      it { is_expected.to be_nil }
+    end
+
+    describe "#to_s" do
+      subject { super().to_s }
+      it { is_expected.to eql("foo&bar") }
+    end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optic14n
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
-- Russell Garner
+- GOV.UK Dev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-27 00:00:00.000000000 Z
+date: 2024-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -39,33 +39,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: gem_publisher
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-govuk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 5.0.2
 description: Canonicalises URLs.
 email:
-- rgarner@zephyros-systems.co.uk
+- govuk-dev@digital.cabinet-office.gov.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/pull_request_template.md"
+- ".github/workflows/autorelease.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
+- ".govuk_dependabot_merger.yml"
+- ".rubocop.yml"
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
-- LICENSE.txt
+- LICENCE
 - README.md
 - Rakefile
-- jenkins.sh
 - lib/optic14n.rb
 - lib/optic14n/canonicalized_urls.rb
 - lib/optic14n/version.rb
@@ -80,7 +100,7 @@ files:
 - spec/query_hash_spec.rb
 - spec/spec_helper.rb
 - spec/uri/query_hash_spec.rb
-homepage: ''
+homepage: https://github.com/alphagov/optic14n
 licenses:
 - MIT
 metadata: {}
@@ -92,15 +112,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.5.21
 signing_key: 
 specification_version: 4
 summary: Specifically, HTTP URLs, for a limited purpose

data/jenkins.sh

@@ -1,10 +0,0 @@
-#!/bin/bash -x
-export RAILS_ENV=test
-export DISPLAY=":99"
-
-set -e
-rm -f Gemfile.lock
-bundle install --path "${HOME}/bundles/${JOB_NAME}"
-export GOVUK_APP_DOMAIN=dev.gov.uk
-bundle exec rake
-bundle exec rake publish_gem