optic14n 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: faf613071e1b6009e6a97058aa8ccc17e537b88e
-  data.tar.gz: 87274484cb0115cae18914eb1ee8edeb070b1ca5
+SHA256:
+  metadata.gz: c6082fa0cb69d729e1329bb5fd04ffd5f40e9632bfa91008bd323e6c2f3c9222
+  data.tar.gz: 46da722d37cc308d168b935df6c0458437a5cbb993e30a8e603cdd58dbfbc75a
 SHA512:
-  metadata.gz: cde69422152d68439c35298f616876c82d6ed32ec8ae4efb92926326873a8c639f7fed718a7782c2a60b62b2e38f5b7b5585314988fb4863730b41bd41490b6b
-  data.tar.gz: aa2d3e22503736c3e0c86ebc243ddff0d85adf00d381a40fc7639fb9bb9a56dec0e43235c9cec2297479ae4e1d28ee01811ba6228e8ce6766d6e8c7e78d4e357
+  metadata.gz: 8578848462e54c7f940cbb6fe939059150f36ae28026faa1f7a7b2803ec21d44d2f8af8c624be5ccea539b6cb4b7c3646e5092f24ec9e5a7eb4952a9fcd79d4d
+  data.tar.gz: 94ba871eaf0864f8d4dde07428ccae007aee0e895b1ac9fa7a5876b05388b678697ce38159aac44177b4863c4a3279c8089e6cf652fcc32f89c578ec8ccf44f3

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  rubocop-govuk:
+    - config/default.yml

data/.ruby-version

@@ -1,2 +1 @@
-2.3.0
-
+2.6.5

data/Gemfile

@@ -1,8 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in optic14n.gemspec
 gemspec
-
-group :test do
-  gem 'rspec', '2.14.1'
-end

data/Jenkinsfile

@@ -0,0 +1,9 @@
+#!/usr/bin/env groovy
+
+library("govuk")
+
+node {
+  govuk.buildProject(
+    rubyLintDiff: false
+  )
+}

data/Rakefile

@@ -1,19 +1,15 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'optic14n'
-Dir.glob('lib/tasks/*.rake').each { |r| import r }
-
-
-require 'gem_publisher'
-desc 'Publish gem to Rubygems'
-task :publish_gem do
-  gem = GemPublisher.publish_if_updated('optic14n.gemspec', :rubygems)
-  puts "Published #{gem}" if gem
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+  puts "Running in production mode"
 end
 
-RSpec::Core::RakeTask.new(:spec)
+require "bundler/gem_tasks"
+require "optic14n"
+Dir.glob("lib/tasks/*.rake").each { |r| import r }
 
 task default: :spec
 task test: :spec

data/lib/optic14n.rb

@@ -1,10 +1,10 @@
-require 'optic14n/version'
+require "optic14n/version"
 
-require 'uri'
-require 'addressable/uri'
-require 'cgi'
-require 'forwardable'
-require 'uri/query_hash'
-require 'uri/bluri'
+require "uri"
+require "addressable/uri"
+require "cgi"
+require "forwardable"
+require "uri/query_hash"
+require "uri/bluri"
 
-require 'optic14n/canonicalized_urls'
+require "optic14n/canonicalized_urls"

data/lib/optic14n/canonicalized_urls.rb

@@ -1,3 +1,5 @@
+require "set"
+
 module Optic14n
   ##
   # Canonicalizes a set of URLs
@@ -21,7 +23,7 @@ module Optic14n
       @urls.each do |url|
         begin
           @output_set.add(BLURI(url).canonicalize!(@options))
-        rescue Exception => e
+        rescue StandardError => e
           failures[url] = e
         end
         @seen += 1
@@ -29,7 +31,7 @@ module Optic14n
     end
 
     def write(filename)
-      File.open(filename, 'w') do |file|
+      File.open(filename, "w") do |file|
         @output_set.each do |url|
           file.puts url
         end
@@ -39,7 +41,7 @@ module Optic14n
     ##
     # Canonicalize given urls. +options+ will be passed to +BLURI.parse+
     def self.from_urls(urls, options = {})
-      CanonicalizedUrls.new(urls, options).tap { |c| c.canonicalize! }
+      CanonicalizedUrls.new(urls, options).tap(&:canonicalize!)
     end
   end
-end
+end

data/lib/optic14n/version.rb

@@ -1,3 +1,3 @@
 module Optic14n
-  VERSION = '2.0.1'
+  VERSION = "2.1.0".freeze
 end

data/lib/tasks/measure_reduction.rake

@@ -1,7 +1,7 @@
-require 'set'
+require "set"
 
 namespace :opt do
-  desc 'Measure reduction from canonicalisation'
+  desc "Measure reduction from canonicalisation"
   task :measure, [:filename, :output_file] do |_, args|
     filename = args[:filename]
     output_file = args[:output_file]
@@ -12,4 +12,4 @@ namespace :opt do
       puts "#{urls.seen} urls seen, #{urls.size} after canonicalisation"
     end
   end
-end
+end

data/lib/uri/bluri.rb

@@ -6,20 +6,20 @@ module URI
   #
   class BLURI < URI::HTTP
     PATH_ESCAPE_MAPPINGS = {
-      '[' => '%5b',
-      ']' => '%5d',
-      ',' => '%2c',
-      '"' => '%22',
-      "'" => '%27',
-      '|' => '%7c',
-      '!' => '%21',
-      '£' => '%c2%a3'
-    }
+      "[" => "%5b",
+      "]" => "%5d",
+      "," => "%2c",
+      '"' => "%22",
+      "'" => "%27",
+      "|" => "%7c",
+      "!" => "%21",
+      "£" => "%c2%a3",
+    }.freeze
 
     PATH_UNESCAPE_MAPPINGS = {
-      '%7e' => '~',
-      '%21' => '!'
-    }
+      "%7e" => "~",
+      "%21" => "!",
+    }.freeze
 
     REQUIRE_REGEX_ESCAPE = %w<. | ( ) [ ] { } + \ ^ $ * ?> & PATH_ESCAPE_MAPPINGS.keys
 
@@ -29,11 +29,18 @@ module URI
 
     def initialize(uri_str)
       @uri = ::Addressable::URI.parse(uri_str)
-      raise URI::InvalidURIError, "'#{uri_str}' not a valid URI" unless @uri
+
+      raise URI::InvalidURIError, "'#{uri_str}' not a valid URI" unless valid_uri?
+    end
+
+    def valid_uri?
+      return unless @uri
+
+      %w[http https mailto].include?(@uri.scheme)
     end
 
     def query_hash
-      @query_hash ||= CGI::parse(self.query || '').tap do |query_hash|
+      @query_hash ||= CGI::parse(self.query || "").tap do |query_hash|
         # By default, CGI::parse produces lots of arrays. Usually they have a single element
         # in them. That's correct but not terribly usable. Fix it here.
         query_hash.each_pair { |k, v| query_hash[k] = v[0] if v.length == 1 }
@@ -43,19 +50,19 @@ module URI
 
     def query_hash=(value)
       @query_hash = value
-      @uri.query = @query_hash.to_s == '' ? nil : @query_hash.to_s
+      @uri.query = @query_hash.to_s == "" ? nil : @query_hash.to_s
     end
 
     def query=(query_str)
       @query_hash = nil
-      @uri.query = query_str == '' ? nil : query_str
+      @uri.query = query_str == "" ? nil : query_str
     end
 
     def self.parse(uri_str)
       # Deal with known URI spec breaks - leading/trailing spaces and unencoded entities
       if uri_str.is_a? String
-        uri_str = uri_str.strip.downcase.gsub(' ', '%20')
-        uri_str.gsub!('&', '%26') if uri_str =~ /^mailto:.*&.*/
+        uri_str = uri_str.strip.downcase.gsub(" ", "%20")
+        uri_str.gsub!("&", "%26") if uri_str =~ /^mailto:.*&.*/
       end
       BLURI.new(uri_str)
     end
@@ -65,9 +72,9 @@ module URI
     end
 
     def canonicalize!(options = {})
-      @uri.scheme = 'http' if @uri.scheme == 'https'
+      @uri.scheme = "http" if @uri.scheme == "https"
 
-      @uri.path = @uri.path.sub(/\/*$/, '') if @uri.path =~ /^*\/$/
+      @uri.path = @uri.path.sub(/\/*$/, "") if @uri.path =~ /^*\/$/
       @uri.path.gsub!(BLURI.path_escape_char_regex,   PATH_ESCAPE_MAPPINGS)
       @uri.path.gsub!(BLURI.path_unescape_code_regex, PATH_UNESCAPE_MAPPINGS)
 
@@ -82,7 +89,7 @@ module URI
       allowed_keys = [options[:allow_query]].flatten.compact.map(&:to_s) unless allow_all
 
       query_hash.keep_if do |k, _|
-        allow_all || (allowed_keys.include?(k.to_s))
+        allow_all || allowed_keys.include?(k.to_s)
       end
 
       self.query_hash = QueryHash[query_hash.sort_by { |k, _| k }]
@@ -91,26 +98,33 @@ module URI
     ##
     # Generate a regex which matches all characters in PATH_ESCAPE_MAPPINGS
     def self.path_escape_char_regex
-      @path_escape_char_regex ||=
-          Regexp.new('[' + PATH_ESCAPE_MAPPINGS.keys.map do |char|
-            REQUIRE_REGEX_ESCAPE.include?(char) ? "\\#{char}" : char
-          end.join + ']')
+      @path_escape_char_regex ||= begin
+        escaped_characters_for_regex = PATH_ESCAPE_MAPPINGS.keys.map do |char|
+          REQUIRE_REGEX_ESCAPE.include?(char) ? "\\#{char}" : char
+        end
+
+        Regexp.new("[" + escaped_characters_for_regex.join + "]")
+      end
     end
 
     ##
     # Generate a regex which matches all escape sequences in PATH_UNESCAPE_MAPPINGS
     def self.path_unescape_code_regex
       @path_unescape_code_regex ||= Regexp.new(
-        PATH_UNESCAPE_MAPPINGS.keys.map { |code| "(?:#{code})" }.join('|')
+        PATH_UNESCAPE_MAPPINGS.keys.map { |code| "(?:#{code})" }.join("|"),
       )
     end
   end
 end
 
 module Kernel
+  # rubocop:disable Naming/MethodName
   def BLURI(uri_str)
     ::URI::BLURI.parse(uri_str)
   end
+  # rubocop:enable Naming/MethodName
 
+  # rubocop:disable Style/AccessModifierDeclarations
   module_function :BLURI
+  # rubocop:enable Style/AccessModifierDeclarations
 end

data/lib/uri/query_hash.rb

@@ -4,12 +4,12 @@ module URI
   module QueryHash
     def [](key)
       item = super key
-      item = super(key.to_s) if item.nil? || item.length == 0
-      item.class == Array && item.length == 0 ? nil : item
+      item = super(key.to_s) if item.nil? || item.empty?
+      item.class == Array && item.empty? ? nil : item
     end
 
     def to_s
-      keys.map { |key| render_value(key, self[key]) }.join('&')
+      keys.map { |key| render_value(key, self[key]) }.join("&")
     end
 
     ##
@@ -20,13 +20,13 @@ module URI
       end
     end
 
-    private
+  private
 
     def render_value(key, value)
       case value
-        when nil   then key
-        when Array then value.map { |el| render_value(key, el) }.join('&')
-        else            URI.encode_www_form_component(key) << '=' << URI.encode_www_form_component(value)
+      when nil   then key
+      when Array then value.map { |el| render_value(key, el) }.join("&")
+      else URI.encode_www_form_component(key) << "=" << URI.encode_www_form_component(value)
       end
     end
   end

data/optic14n.gemspec

@@ -1,25 +1,27 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'optic14n/version'
+require "optic14n/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'optic14n'
+  spec.name          = "optic14n"
   spec.version       = Optic14n::VERSION
-  spec.authors       = ['Russell Garner']
-  spec.email         = %w(rgarner@zephyros-systems.co.uk)
-  spec.description   = %q{Canonicalises URLs.}
-  spec.summary       = %q{Specifically, HTTP URLs, for a limited purpose}
-  spec.homepage      = ''
-  spec.license       = 'MIT'
+  spec.authors       = ["GOV.UK Dev"]
+  spec.email         = ["govuk-dev@digital.cabinet-office.gov.uk"]
+  spec.description   = "Canonicalises URLs."
+  spec.summary       = "Specifically, HTTP URLs, for a limited purpose"
+  spec.homepage      = "https://github.com/alphagov/optic14n"
+  spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w(lib)
 
-  spec.add_dependency 'addressable', '~> 2.3'
+  spec.add_dependency "addressable", "~> 2.7"
 
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'gem_publisher', '~> 1.3.0'
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rubocop-govuk", "~> 1.0.0"
 end

data/spec/bluri_spec.rb

@@ -1,88 +1,88 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe URI::BLURI do
-  it 'should be an HTTP URI' do
-    bluri = BLURI('http://some.where.com')
-    bluri.should be_a URI::HTTP
+  it "should be an HTTP URI" do
+    bluri = BLURI("http://some.where.com")
+    expect(bluri).to be_a URI::HTTP
   end
 
-  it 'should not allow other schemes' do
-    lambda { BLURI('ftp://foo').should raise_error(ArgumentError) }
+  it "should not allow other schemes" do
+    expect { BLURI("ftp://foo") }.to raise_error(URI::InvalidURIError)
   end
 
-  it 'should not allow nil' do
-    lambda { BLURI(nil) }.should raise_error(URI::InvalidURIError)
+  it "should not allow nil" do
+    expect { BLURI(nil) }.to raise_error(URI::InvalidURIError)
   end
 
-  it 'supports scheme' do
-    BLURI('http://foo').scheme.should == 'http'
+  it "supports scheme" do
+    expect(BLURI("http://foo").scheme).to eq("http")
   end
-  it 'supports host' do
-    BLURI('http://foo').host.should == 'foo'
+  it "supports host" do
+    expect(BLURI("http://foo").host).to eq("foo")
   end
-  it 'supports path' do
-    BLURI('http://foo/a/path').path.should == '/a/path'
+  it "supports path" do
+    expect(BLURI("http://foo/a/path").path).to eq("/a/path")
   end
-  it 'supports query' do
-    BLURI('http://foo?to=you&you=foo').query.should == 'to=you&you=foo'
+  it "supports query" do
+    expect(BLURI("http://foo?to=you&you=foo").query).to eq("to=you&you=foo")
   end
-  it 'supports fragment' do
-    BLURI('http://foo#fragment').fragment.should == 'fragment'
+  it "supports fragment" do
+    expect(BLURI("http://foo#fragment").fragment).to eq("fragment")
   end
-  it 'supports mailto:someone@somewhere' do
-    BLURI('mailto:me@there.com').to_s.should == 'mailto:me@there.com'
+  it "supports mailto:someone@somewhere" do
+    expect(BLURI("mailto:me@there.com").to_s).to eq("mailto:me@there.com")
   end
-  it 'corrects unencoded ampersands ins mailto' do # http://www.faqs.org/rfcs/rfc2368.html
-    BLURI('mailto:fruit&veg.newcastle@rpa.gsi.gov.uk').to_s.should == 'mailto:fruit%26veg.newcastle@rpa.gsi.gov.uk'
+  it "corrects unencoded ampersands ins mailto" do # http://www.faqs.org/rfcs/rfc2368.html
+    expect(BLURI("mailto:fruit&veg.newcastle@rpa.gsi.gov.uk").to_s).to eq("mailto:fruit%26veg.newcastle@rpa.gsi.gov.uk")
   end
-  it 'corrects trailing spaces' do
-    BLURI('http://www.newspapersoc.org.uk ').to_s.should == 'http://www.newspapersoc.org.uk'
+  it "corrects trailing spaces" do
+    expect(BLURI("http://www.newspapersoc.org.uk ").to_s).to eq("http://www.newspapersoc.org.uk")
   end
-  it 'corrects leading spaces' do
-    BLURI('  http://www.newspapersoc.org.uk').to_s.should == 'http://www.newspapersoc.org.uk'
+  it "corrects leading spaces" do
+    expect(BLURI("  http://www.newspapersoc.org.uk").to_s).to eq("http://www.newspapersoc.org.uk")
   end
 
-  describe 'Query string parsing' do
-    context 'the query string is of HTML-encoded form k=v&q=p' do
+  describe "Query string parsing" do
+    context "the query string is of HTML-encoded form k=v&q=p" do
       before do
-        @bluri = BLURI('http://some.com/a/path?itemid=1&type=RESOURCE')
+        @bluri = BLURI("http://some.com/a/path?itemid=1&type=RESOURCE")
       end
 
-      it 'indexes the query string' do
-        @bluri.query_hash['itemid'].should == '1'
+      it "indexes the query string" do
+        expect(@bluri.query_hash["itemid"]).to eq("1")
       end
 
-      it 'allows indexing by symbol' do
-        @bluri.query_hash[:itemid].should == '1'
+      it "allows indexing by symbol" do
+        expect(@bluri.query_hash[:itemid]).to eq("1")
       end
 
-      it 'shows nil for absent items' do
-        @bluri.query_hash[:eerie_flash].should == nil
+      it "shows nil for absent items" do
+        expect(@bluri.query_hash[:eerie_flash]).to eq(nil)
       end
 
-      it 'indexes the second query string item' do
-        @bluri.query_hash['type'].should == 'resource'
+      it "indexes the second query string item" do
+        expect(@bluri.query_hash["type"]).to eq("resource")
       end
 
-      it 'allows setting of the query' do
-        @bluri.query = 'furry=really'
-        @bluri.to_s.should == 'http://some.com/a/path?furry=really'
+      it "allows setting of the query" do
+        @bluri.query = "furry=really"
+        expect(@bluri.to_s).to eq("http://some.com/a/path?furry=really")
       end
     end
 
-    context 'the querystring is not an HTML-encoded thing' do
+    context "the querystring is not an HTML-encoded thing" do
       before do
-        @bluri = BLURI('http://some.com/a/path?foo&bar')
+        @bluri = BLURI("http://some.com/a/path?foo&bar")
       end
 
-      it 'retains the query string' do
-        @bluri.query.should == 'foo&bar'
+      it "retains the query string" do
+        expect(@bluri.query).to eq("foo&bar")
       end
 
-      it 'has a query hash with empty elements' do
-        @bluri.query_hash['foo'].should == nil
-        @bluri.query_hash['foo'].should == nil
+      it "has a query hash with empty elements" do
+        expect(@bluri.query_hash["foo"]).to eq(nil)
+        expect(@bluri.query_hash["foo"]).to eq(nil)
       end
     end
   end
-end
+end

data/spec/c14n_spec.rb

@@ -1,195 +1,209 @@
 # 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').
+    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.should eql('http://example.com/path?view=%ED')
+            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').
+        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.should eql('http://example.com/path?%ED=view')
+            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) }
 
-        its(:path) { should eql('/stuff') }
-        its(:query) { should eql('query=thing') }
+        describe "#path" do
+          subject { super().path }
+          it { is_expected.to eql("/stuff") }
+        end
+
+        describe "#query" do
+          subject { super().query }
+          it { is_expected.to eql("query=thing") }
+        end
       end
     end
   end

data/spec/canonicalized_urls_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Optic14n::CanonicalizedUrls do
-  describe 'c14nize' do
+  describe "c14nize" do
     let(:test_urls) do
       %w(
         http://www.qhm.mod.uk/portsmouth/leisure/fuel
@@ -13,45 +13,54 @@ describe Optic14n::CanonicalizedUrls do
       )
     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: 2.1.0
 platform: ruby
 authors:
-- Russell Garner
+- GOV.UK Dev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-27 00:00:00.000000000 Z
+date: 2021-02-15 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,48 @@ 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: '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: 1.3.0
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.0.0
 description: Canonicalises URLs.
 email:
-- rgarner@zephyros-systems.co.uk
+- govuk-dev@digital.cabinet-office.gov.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
+- Jenkinsfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- jenkins.sh
 - lib/optic14n.rb
 - lib/optic14n/canonicalized_urls.rb
 - lib/optic14n/version.rb
@@ -80,7 +95,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: {}
@@ -99,8 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.1.4
 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