intranet-core 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cb2eacb573a839642af1a0919d07ed5c43b66ebd
-  data.tar.gz: ef44c9521483faa96b12b2b518433b2066bb816a
+SHA256:
+  metadata.gz: a6860141eca0145a6d51787a137641ead4978b69d2f7b2d28ce5dcf1a5193f42
+  data.tar.gz: 6f43415cdf7334c81466b1205a838b92762c15dff3fb8ca3e096ccb71ebecfa2
 SHA512:
-  metadata.gz: 0b6c6c410f1715508866b01ad75336a2e1e18a41c5c4ba6b42a8aa7fc0786a7e0609ff6da04649a9aa9cac3f0bad3f8236ce2a2f3ebb8d67a8242acf269fc087
-  data.tar.gz: 45ed729192de045ca4860f1197e0569c2e807011841539ab222855942e827a107e5dc9ddf15ffdb02f1b0a25249264d6a81513d8b79bd9fe3ed692d106bfba82
+  metadata.gz: 84eeb50385f879656140e5b385a98a50c3149fa7b6cb8d31fd49b97ce73d5f69eda2e3e33789876196c0eaccaa47721b089e7870a0b90880392f03aedb279600
+  data.tar.gz: 07e5122a4279dc99efe881651637e932ec36601b3007529e545b13b7ccaef2297ca05b7f6184f02a6693d61ad1147b162961c508992ce57ce09ce56a0a8de32e

data/lib/core_extensions.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'core_extensions/hash'
 require_relative 'core_extensions/string'
 require_relative 'core_extensions/tree'
 require_relative 'core_extensions/webrick/httpresponse'
 
+Hash.include CoreExtensions::Hash
 String.include CoreExtensions::String
 WEBrick::HTTPResponse.include CoreExtensions::WEBrick::HTTPResponse
 

data/lib/core_extensions/hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CoreExtensions
+  # Extension of Ruby's standard library +Hash+ class.
+  module Hash
+    # Returns a copy of a hash with +keys+ excluded. Original hash is not
+    # modified.
+    # @return [Hash]
+    def except(*keys)
+      h = dup
+      keys.each { |key| h.delete(key) }
+      h
+    end
+  end
+end

data/lib/core_extensions/string.rb

@@ -3,7 +3,6 @@
 require 'titleize'
 
 module CoreExtensions
-  # @!visibility protected
   # Extension of Ruby's standard library +String+ class.
   module String
     # Replaces all accented characters in a string with their non-accented version.

data/lib/intranet/abstract_responder.rb

@@ -22,6 +22,15 @@ module Intranet
       true
     end
 
+    # Specifies the absolute path to the resources directory for that module. This directory should
+    # contain three subdirectories: +haml/+, +locales/+ and +www/+.
+    # This method should be redefined to overwrite this default value with the actual resources
+    # directory path.
+    # @return [String] The absolute path to the resources directory for the module.
+    def resources_dir
+      File.join(__dir__, 'resources')
+    end
+
     # Destroys the responder instance.
     # This method gets called when server is shut down.
     def finalize

data/lib/intranet/core.rb

@@ -52,7 +52,7 @@ module Intranet
     #                               mounted under +<path>/design+ on the web server.
     # @raise [ArgumentError] If the +path+ is not valid.
     # @raise [Errno::EALREADY] If the server is already running.
-    def register_module(responder, path, resources_dir)
+    def register_module(responder, path, resources_dir = responder.resources_dir)
       raise Errno::EALREADY if @server.status != :Stop
 
       @builder.register(responder, path)
@@ -80,6 +80,8 @@ module Intranet
     def stop
       @logger.info('Intranet::Runner: requesting system shutdown...')
       @server.shutdown
+      while @server.status != :Stop
+      end
       @builder.finalize
       @logger.close
     end

data/lib/intranet/core/builder.rb

@@ -57,12 +57,12 @@ module Intranet
 
         # Generate header and footer when partial content is returned by the responder
         if status == 206 && mime_type == 'text/html'
-          body = to_markup('skeleton', body: body, css: responder.css_dependencies,
-                                       js: responder.js_dependencies, current_path: parsed_path)
+          body = add_header_and_footer(body, responder, parsed_path)
           status = 200
         end
         [status, mime_type, body]
-      rescue KeyError, NoMethodError
+      rescue KeyError, NoMethodError => e
+        @logger.debug(e)
         [404, '', '']
       end
 
@@ -111,6 +111,16 @@ module Intranet
         [current_treenode.value, '/' + parsed_path.join('/'), '/' + unparsed_path.join('/')]
       end
 
+      # Encapsulate the given body in the default page skeleton, effectively
+      # adding page header and footer.
+      # @param body [String] The body of the page
+      # @param responder [Intranet::AbstractResponder] The responder that produced the body
+      # @param path [String] The path to the responder
+      def add_header_and_footer(body, responder, path)
+        to_markup('skeleton', body: body, css: responder.css_dependencies,
+                              js: responder.js_dependencies, current_path: path)
+      end
+
       # Check whether a path is valid.
       # @param path [Array] The path to test.
       # @return [Boolean] True if the path is valid, False otherwise.

data/lib/intranet/core/servlet.rb

@@ -26,12 +26,12 @@ module Intranet
         # We could use request.request_uri (which is a URI object) but its path is not normalized
         # (it may contain '../' or event start with '..'). Hence we use request.path which has been
         # normalized with HTTPUtils::normalize_path, and request.query for the URL parameters.
-        path = request.path
+        path = request.path.force_encoding('UTF-8')
         path += 'index.html' if path.end_with?('/')
 
         handle_redirections(request, path, response, '/index.html' => @builder.home_url)
 
-        status, content_type, body = @builder.do_get(path, request.query)
+        status, content_type, body = @builder.do_get(path, encode_query(request.query))
 
         raise WEBrick::HTTPStatus[status] if WEBrick::HTTPStatus.error?(status)
 
@@ -48,9 +48,16 @@ module Intranet
         target = redirects.fetch(path)
         location = URI.join(request.request_uri, target).to_s
         response.set_redirect(WEBrick::HTTPStatus[307], location) if path != target
-      rescue KeyError # rubocop:disable Lint/HandleExceptions
+      rescue KeyError
         # nothing to do
       end
+
+      # Reencodes the +query+ in UTF-8 strings for compatibility.
+      def encode_query(query)
+        query.map do |k, v|
+          { k.dup.force_encoding('UTF-8') => v.force_encoding('UTF-8') }
+        end.reduce({}, :merge)
+      end
     end
   end
 end

data/lib/intranet/core/version.rb

@@ -6,7 +6,7 @@ module Intranet
     NAME = 'intranet-core'
 
     # The version of the gem, according to semantic versionning.
-    VERSION = '2.0.0'
+    VERSION = '2.2.0'
 
     # The URL of the gem homepage.
     HOMEPAGE_URL = 'https://rubygems.org/gems/intranet-core'

data/lib/intranet/resources/www/nav.js

@@ -10,7 +10,8 @@ function openNavMenu() {
 }
 
 function closeNavMenu() {
-  document.querySelectorAll('header nav')[0].style.width = '0';
+  /* Remove value property set in openNavMenu() */
+  document.querySelectorAll('header nav')[0].style.width = '';
 }
 
 function openModal() {

data/lib/intranet/resources/www/style.css

@@ -45,7 +45,6 @@ header {
     top: 0px;
     width: 100%;
     margin: auto;
-    height: 57px;
     background-color: #1e262b;
     color: white;
     z-index: 2;

data/spec/core_extensions/hash_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'core_extensions/hash'
+
+RSpec.describe CoreExtensions::Hash do
+  before do
+    Hash.include described_class
+  end
+
+  describe '#except' do
+    it 'should return a copy of the original hash with the given keys removed' do
+      tested_hash = { a: true, b: false, c: nil }
+      expect(tested_hash.except(:c)).to eql({ a: true, b: false })
+      expect(tested_hash).to eql({ a: true, b: false, c: nil })
+
+      tested_hash = { a: 100, b: 200, c: 300 }
+      expect(tested_hash.except(:a)).to eql({ b: 200, c: 300 })
+      expect(tested_hash.except(:a, :c)).to eql({ b: 200 })
+      expect(tested_hash).to eql({ a: 100, b: 200, c: 300 })
+    end
+  end
+end

data/spec/intranet/core_spec.rb

@@ -15,71 +15,67 @@ RSpec.describe Intranet::Core do
 
   describe '#start' do
     it 'should start an HTTP server on an available port' do
-      begin
-        # make sure port 80 & 8080 are not available
-        @intranet8080 = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-        thread = Thread.new do
-          @intranet8080.start
-        end
-        # Wait for the server on port 8080 to be running
-        while @intranet8080.instance_variable_get(:@server).status != :Running
-        end
+      # make sure port 80 & 8080 are not available
+      @intranet8080 = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+      thread8080 = Thread.new { @intranet8080.start }
+      while @intranet8080.instance_variable_get(:@server).status != :Running
+      end
+      expect(@intranet8080.port).to be >= 8080
 
-        intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-        expect(intranet.port).to eql(
-          intranet.instance_variable_get(:@server).instance_variable_get(:@config)[:Port]
-        )
-        expect(intranet.port).not_to eql(8080)
-      ensure
-        intranet.stop if intranet.respond_to?(:stop)
-        Thread.kill(thread)
-        thread.join
+      @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+      thread = Thread.new { @intranet.start }
+      while @intranet.instance_variable_get(:@server).status != :Running
       end
+      expect(@intranet.port).to be > 8080
+
+      @intranet.stop
+      thread&.join
+      @intranet8080.stop
+      thread8080&.join
     end
 
     it 'should start searching for an available port at the given +preferred_port+' do
-      intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL), 9090)
-      expect(intranet.port).to be >= 9090
+      @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL), 9090)
+      thread = Thread.new { @intranet.start }
+      while @intranet.instance_variable_get(:@server).status != :Running
+      end
+
+      expect(@intranet.port).to be >= 9090
+
+      @intranet.stop
+      thread&.join
     end
 
     it 'should serve the /design directory' do
-      begin
+      @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+      thread = Thread.new { @intranet.start }
+      while @intranet.instance_variable_get(:@server).status != :Running
+      end
+
+      socket = TCPSocket.new('localhost', @intranet.port)
+      socket.puts("GET /design/favicon.ico HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
+      expect(socket.gets).to include('HTTP/1.1 200 OK')
+      socket.close
+
+      @intranet.stop
+      thread&.join
+    end
+
+    context 'when no module is registered' do
+      it 'should return HTTP error 404 when requested for /index.html' do
         @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-        thread = Thread.new do
-          @intranet.start
-        end
+        thread = Thread.new { @intranet.start }
         while @intranet.instance_variable_get(:@server).status != :Running
         end
 
         socket = TCPSocket.new('localhost', @intranet.port)
-        socket.puts("GET /design/favicon.ico HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
-        expect(socket.gets).to include('HTTP/1.1 200 OK')
-      ensure
+        socket.puts("GET /index.html HTTP/1.1\r\n" \
+                    "Host: localhost:#{@intranet.port}\r\n\r\n")
+        expect(socket.gets).to include('HTTP/1.1 404 Not Found')
         socket.close
-        Thread.kill(thread)
-        thread.join
-      end
-    end
 
-    context 'when no module is registered' do
-      it 'should return HTTP error 404 when requested for /index.html' do
-        begin
-          @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-          thread = Thread.new do
-            @intranet.start
-          end
-          while @intranet.instance_variable_get(:@server).status != :Running
-          end
-
-          socket = TCPSocket.new('localhost', @intranet.port)
-          socket.puts("GET /index.html HTTP/1.1\r\n" \
-                      "Host: localhost:#{@intranet.port}\r\n\r\n")
-          expect(socket.gets).to include('HTTP/1.1 404 Not Found')
-        ensure
-          socket.close
-          Thread.kill(thread)
-          thread.join
-        end
+        @intranet.stop
+        thread&.join
       end
     end
   end
@@ -87,58 +83,71 @@ RSpec.describe Intranet::Core do
   describe '#register_module' do
     context 'registering a module when the server is running' do
       it 'should fail' do
-        begin
-          @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-          r = Intranet::TestResponder.new('/index.html' => [200, 'text/html', ''])
-          thread = Thread.new do
-            @intranet.start
-          end
-          while @intranet.instance_variable_get(:@server).status != :Running
-          end
-
-          expect { @intranet.register_module(r, ['path'], '') }.to raise_error Errno::EALREADY
-        ensure
-          Thread.kill(thread)
-          thread.join
+        @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
         end
+
+        r = Intranet::TestResponder.new('/index.html' => [200, 'text/html', ''])
+        expect { @intranet.register_module(r, ['path'], '') }.to raise_error Errno::EALREADY
+
+        @intranet.stop
+        thread&.join
       end
     end
 
     context 'registering a module with an invalid path' do
       it 'should fail' do
         @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
         r = Intranet::TestResponder.new('/index.html' => [200, 'text/html', ''])
         expect { @intranet.register_module(r, [], '') }.to raise_error ArgumentError
         expect { @intranet.register_module(r, %w[1 2 3], '') }.to raise_error ArgumentError
         expect { @intranet.register_module(r, ['', 'valid'], '') }.to raise_error ArgumentError
         expect { @intranet.register_module(r, ['Invalid'], '') }.to raise_error ArgumentError
         expect { @intranet.register_module(r, 'fo', '') }.to raise_error ArgumentError
+
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
+        end
+
+        @intranet.stop
+        thread&.join
       end
     end
 
     context 'registering an invalid module' do
       it 'should fail' do
         @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
         expect { @intranet.register_module(nil, ['path'], '') }.to raise_error ArgumentError
+
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
+        end
+
+        @intranet.stop
+        thread&.join
       end
     end
 
     context 'when a valid module is registered' do
       before(:each) do
         @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
         responder = Intranet::TestResponder.new('/index.html' => [200, 'text/html', ''])
+        # Third argument of register_module() is optional, so we test both cases.
         @intranet.register_module(responder, %w[responder], responder.resources_dir)
-        @intranet.register_module(responder, %w[resp onder], responder.resources_dir)
-        @thread = Thread.new do
-          @intranet.start
-        end
+        @intranet.register_module(responder, %w[resp onder])
+
+        @thread = Thread.new { @intranet.start }
         while @intranet.instance_variable_get(:@server).status != :Running
         end
       end
 
       after(:each) do
-        Thread.kill(@thread)
-        @thread.join
+        @intranet.stop
+        @thread&.join
       end
 
       it 'should be used to serve URI relative to the module root' do
@@ -177,157 +186,143 @@ RSpec.describe Intranet::Core do
     end
 
     context 'given a valid and registered module' do
-      it 'should be called with the URL path and query' do
-        begin
-          @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-          responder = Intranet::TestResponder.new('/index.html' => [200, 'text/html', ''])
-          @intranet.register_module(responder, ['responder'], responder.resources_dir)
-          thread = Thread.new do
-            @intranet.start
-          end
-          while @intranet.instance_variable_get(:@server).status != :Running
-          end
-
-          socket = TCPSocket.new('localhost', @intranet.port)
-          socket.puts("GET /responder/query?var1=value1&var2=value2 HTTP/1.1\r\n" \
-                      "Host: localhost:#{@intranet.port}\r\n\r\n")
-          expect(socket.gets).to include('HTTP/1.1 200 OK')
-          while (line = socket.gets.chomp) # consume HTTP response headers
-            break if line.empty?
-          end
-          line = socket.gets.chomp
-          expect(line).to eql({ 'var1' => 'value1', 'var2' => 'value2' }.to_s)
-          socket.close
-
-          socket = TCPSocket.new('localhost', @intranet.port)
-          socket.puts("GET /responder/query?foo=bar&baz=boz HTTP/1.1\r\n" \
-                      "Host: localhost:#{@intranet.port}\r\n\r\n")
-          expect(socket.gets).to include('HTTP/1.1 200 OK')
-          while (line = socket.gets.chomp) # consume HTTP response headers
-            break if line.empty?
-          end
-          line = socket.gets.chomp
-          expect(line).to eql({ 'foo' => 'bar', 'baz' => 'boz' }.to_s)
-        ensure
-          socket.close
-          Thread.kill(thread)
-          thread.join
+      it 'should be called with the decoded URL path and query in UTF-8 encoding' do
+        @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
+        responder = Intranet::TestResponder.new('/index.html' => [200, 'text/html', ''])
+        @intranet.register_module(responder, ['responder'], responder.resources_dir)
+
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
+        end
+
+        socket = TCPSocket.new('localhost', @intranet.port)
+        socket.puts("GET /responder/query%20t?var1=value1&var2=value2 HTTP/1.1\r\n" \
+                    "Host: localhost:#{@intranet.port}\r\n\r\n")
+        expect(socket.gets).to include('HTTP/1.1 200 OK')
+        while (line = socket.gets.chomp) # consume HTTP response headers
+          break if line.empty?
         end
+        line = socket.gets.chomp
+        expect(line).to eql(
+          'PATH=/query t (UTF-8), ' \
+          'QUERY={var1 (UTF-8) => value1 (UTF-8),var2 (UTF-8) => value2 (UTF-8)}'
+        )
+        socket.close
+
+        @intranet.stop
+        thread&.join
       end
     end
 
     context 'given a module returning partial HTML content' do
       it 'should be called to retrieve the body of the page' do
-        begin
-          @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-          responder = Intranet::TestResponder.new(
-            {
-              '/index.html' => [206, 'text/html', { content: 'PARTIAL_CONTENT', title: 'MyTitle' }]
-            },
-            ['/responder.css', 'nav.css'],
-            ['module.js', '/js/interactive.js']
-          )
-          @intranet.register_module(responder, ['r'], responder.resources_dir)
-          thread = Thread.new do
-            @intranet.start
-          end
-          while @intranet.instance_variable_get(:@server).status != :Running
-          end
-
-          socket = TCPSocket.new('localhost', @intranet.port)
-          socket.puts("GET /r/index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
-
-          # Return code: HTTP error 200
-          expect(socket.gets).to include('HTTP/1.1 200 OK')
-
-          while (line = socket.gets.chomp) # consume HTTP response headers
-            break if line.empty?
-          end
-          html = socket.readpartial(4096) # read rest of data
-
-          # Returned HTML document: includes the partial content and the title
-          expect(html).to match(%r{<main>.*PARTIAL_CONTENT.*</main>}m)
-          expect(html).to match(%r{<head>.*<title>.*MyTitle.*</title>.*</head>}m)
-
-          # Returned HTML document: includes the hostname in title, h1-title and footer
-          hostname = Socket.gethostname
-          expect(html).to match(%r{<head>.*<title>.*#{hostname.capitalize}.*</title>.*</head>}m)
-          expect(html).to match(%r{<body>.*<h1>.*#{hostname.capitalize}.*</h1>.*</body>}m)
-          expect(html).to match(%r{<footer>.*#{hostname}.*</footer>}m)
-
-          # Returned HTML document: includes all CSS dependencies, relative or absolute path
-          expect(html).to match(%r{<link href='/responder.css' rel='stylesheet' type='text/css'})
-          expect(html).to match(%r{<link href='/r/nav.css' rel='stylesheet' type='text/css'})
-
-          # Returned HTML document: includes all JS dependencies
-          expect(html).to match(%r{<script defer='defer' src='/r/module.js'></script>})
-          expect(html).to match(%r{<script defer='defer' src='/js/interactive.js'></script>})
-
-          # Returned HTML document: includes Intranet Core name, version and URL
-          expect(html).to match(
-            %r{<footer>.*<a href='#{Intranet::Core::HOMEPAGE_URL}'.*>#{Intranet::Core::NAME}</a>.*#{Intranet::Core::VERSION}.*</footer>}m # rubocop:disable Metrics/LineLength
-          )
-
-          # Returned HTML document: includes all registered modules version name, version and URL
-          expect(html).to match(
-            %r{<footer>.*<a href='http://nil/'.*>test-responder</a>.*0.0.0.*</footer>}m
-          )
-        ensure
-          socket.close
-          Thread.kill(thread)
-          thread.join
+        @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
+        responder = Intranet::TestResponder.new(
+          {
+            '/index.html' => [206, 'text/html', { content: 'PARTIAL_CONTENT', title: 'MyTitle' }]
+          },
+          ['/responder.css', 'nav.css'],
+          ['module.js', '/js/interactive.js']
+        )
+        @intranet.register_module(responder, ['r'], responder.resources_dir)
+
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
         end
+
+        socket = TCPSocket.new('localhost', @intranet.port)
+        socket.puts("GET /r/index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
+
+        # Return code: HTTP error 200
+        expect(socket.gets).to include('HTTP/1.1 200 OK')
+
+        while (line = socket.gets.chomp) # consume HTTP response headers
+          break if line.empty?
+        end
+        html = socket.readpartial(4096) # read rest of data
+        socket.close
+
+        # Returned HTML document: includes the partial content and the title
+        expect(html).to match(%r{<main>.*PARTIAL_CONTENT.*</main>}m)
+        expect(html).to match(%r{<head>.*<title>.*MyTitle.*</title>.*</head>}m)
+
+        # Returned HTML document: includes the hostname in title, h1-title and footer
+        hostname = Socket.gethostname
+        expect(html).to match(%r{<head>.*<title>.*#{hostname.capitalize}.*</title>.*</head>}m)
+        expect(html).to match(%r{<body>.*<h1>.*#{hostname.capitalize}.*</h1>.*</body>}m)
+        expect(html).to match(%r{<footer>.*#{hostname}.*</footer>}m)
+
+        # Returned HTML document: includes all CSS dependencies, relative or absolute path
+        expect(html).to match(%r{<link href='/responder.css' rel='stylesheet' type='text/css'})
+        expect(html).to match(%r{<link href='/r/nav.css' rel='stylesheet' type='text/css'})
+
+        # Returned HTML document: includes all JS dependencies
+        expect(html).to match(%r{<script defer='defer' src='/r/module.js'></script>})
+        expect(html).to match(%r{<script defer='defer' src='/js/interactive.js'></script>})
+
+        # Returned HTML document: includes Intranet Core name, version and URL
+        expect(html).to match(
+          %r{<footer>.*<a href='#{Intranet::Core::HOMEPAGE_URL}'.*>#{Intranet::Core::NAME}</a>.*#{Intranet::Core::VERSION}.*</footer>}m # rubocop:disable Layout/LineLength
+        )
+
+        # Returned HTML document: includes all registered modules version name, version and URL
+        expect(html).to match(
+          %r{<footer>.*<a href='http://nil/'.*>test-responder</a>.*0.0.0.*</footer>}m
+        )
+
+        @intranet.stop
+        thread&.join
       end
       it 'should be called to update the main navigation menu' do
-        begin
-          @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-          responder = Intranet::TestResponder.new(
-            '/index.html' => [206, 'text/html', { content: 'PARTIAL_CONTENT', title: 'MyTitle' }]
-          )
-          other_responder = Intranet::TestResponder.new({}, [], [], true)
-          @intranet.register_module(responder, %w[r], responder.resources_dir)
-          @intranet.register_module(responder, %w[dep_th1], responder.resources_dir)
-          @intranet.register_module(responder, %w[depth2 res_p1], responder.resources_dir)
-          @intranet.register_module(responder, %w[depth2 resp2], responder.resources_dir)
-          @intranet.register_module(other_responder, %w[depth2 resp], other_responder.resources_dir)
-          @intranet.register_module(other_responder, %w[other1], other_responder.resources_dir)
-          @intranet.register_module(other_responder, %w[other2 res1], other_responder.resources_dir)
-          @intranet.register_module(other_responder, %w[other2 res2], other_responder.resources_dir)
-          thread = Thread.new do
-            @intranet.start
-          end
-          while @intranet.instance_variable_get(:@server).status != :Running
-          end
-
-          socket = TCPSocket.new('localhost', @intranet.port)
-          socket.puts("GET /r/index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
-
-          # Return code: HTTP error 200
-          expect(socket.gets).to include('HTTP/1.1 200 OK')
-
-          while (line = socket.gets.chomp)
-            break if line.empty?
-          end
-          html = socket.readpartial(4096) # read rest of data
-
-          # Returned HTML document main menu
-          expect(html).to     match(%r{<a href='/dep_th1/index.html'>.*Dep Th1.*</a>})
-          expect(html).not_to match(%r{<a href='/other1/index.html'>})
-          expect(html).to match(
-            %r{<a>.*Depth2.*</a>.*<ul>.*<a href='/depth2/res_p1/index.html'>.*Res P1.*</a>.*</ul>}m
-          )
-          expect(html).to match(
-            %r{<a>.*Depth2.*</a>.*<ul>.*<a href='/depth2/resp2/index.html'>.*Resp2.*</a>.*</ul>}m
-          )
-          expect(html).not_to match(%r{<a href='/depth2/resp/index.html'>})
-          expect(html).not_to match(%r{<a>.*Other2.*</a>}m)
-          expect(html).not_to match(%r{<a href='/other2/res1/index.html'>})
-          expect(html).not_to match(%r{<a href='/other2/res2/index.html'>})
-        ensure
-          socket.close
-          Thread.kill(thread)
-          thread.join
+        @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
+        responder = Intranet::TestResponder.new(
+          '/index.html' => [206, 'text/html', { content: 'PARTIAL_CONTENT', title: 'MyTitle' }]
+        )
+        other_responder = Intranet::TestResponder.new({}, [], [], true)
+        @intranet.register_module(responder, %w[r], responder.resources_dir)
+        @intranet.register_module(responder, %w[dep_th1], responder.resources_dir)
+        @intranet.register_module(responder, %w[depth2 res_p1], responder.resources_dir)
+        @intranet.register_module(responder, %w[depth2 resp2], responder.resources_dir)
+        @intranet.register_module(other_responder, %w[depth2 resp], other_responder.resources_dir)
+        @intranet.register_module(other_responder, %w[other1], other_responder.resources_dir)
+        @intranet.register_module(other_responder, %w[other2 res1], other_responder.resources_dir)
+        @intranet.register_module(other_responder, %w[other2 res2], other_responder.resources_dir)
+
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
         end
+
+        socket = TCPSocket.new('localhost', @intranet.port)
+        socket.puts("GET /r/index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
+
+        # Return code: HTTP error 200
+        expect(socket.gets).to include('HTTP/1.1 200 OK')
+
+        while (line = socket.gets.chomp)
+          break if line.empty?
+        end
+        html = socket.readpartial(4096) # read rest of data
+        socket.close
+
+        # Returned HTML document main menu
+        expect(html).to     match(%r{<a href='/dep_th1/index.html'>.*Dep Th1.*</a>})
+        expect(html).not_to match(%r{<a href='/other1/index.html'>})
+        expect(html).to match(
+          %r{<a>.*Depth2.*</a>.*<ul>.*<a href='/depth2/res_p1/index.html'>.*Res P1.*</a>.*</ul>}m
+        )
+        expect(html).to match(
+          %r{<a>.*Depth2.*</a>.*<ul>.*<a href='/depth2/resp2/index.html'>.*Resp2.*</a>.*</ul>}m
+        )
+        expect(html).not_to match(%r{<a href='/depth2/resp/index.html'>})
+        expect(html).not_to match(%r{<a>.*Other2.*</a>}m)
+        expect(html).not_to match(%r{<a href='/other2/res1/index.html'>})
+        expect(html).not_to match(%r{<a href='/other2/res2/index.html'>})
+
+        @intranet.stop
+        thread&.join
       end
     end
   end
@@ -336,66 +331,61 @@ RSpec.describe Intranet::Core do
     context 'given a relative URL' do
       it 'should fail' do
         @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+
         expect { @intranet.home_url = 'foo/index.html' }.to raise_error ArgumentError
-      end
-    end
 
-    context 'given an absolute URL' do
-      it 'should set up a redirection from /index.html to the provided URL' do
-        begin
-          @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-          @intranet.home_url = '/responder/index.html'
-          thread = Thread.new do
-            @intranet.start
-          end
-          while @intranet.instance_variable_get(:@server).status != :Running
-          end
-
-          socket = TCPSocket.new('localhost', @intranet.port)
-          socket.puts("GET /index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
-          expect(socket.gets).to include('HTTP/1.1 307 Temporary Redirect')
-          while (line = socket.gets.chomp) # search the HTTP response for the 'Location' header
-            break if line.start_with?('Location:')
-          end
-          expect(line).to include("http://localhost:#{@intranet.port}/responder/index.html")
-        ensure
-          socket.close
-          Thread.kill(thread)
-          thread.join
+        thread = Thread.new { @intranet.start }
+        while @intranet.instance_variable_get(:@server).status != :Running
         end
+
+        @intranet.stop
+        thread&.join
       end
     end
-  end
 
-  describe '#stop' do
-    it 'should stop the web server and finalize all registered responders' do
-      begin
+    context 'given an absolute URL' do
+      it 'should set up a redirection from /index.html to the provided URL' do
         @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
-        responder = Intranet::TestResponder.new('/index.html' => [200, 'text/html', 'CONTENT'])
-        @intranet.register_module(responder, %w[r], responder.resources_dir)
-        thread = Thread.new do
-          @intranet.start
-        end
+        @intranet.home_url = '/responder/index.html'
+        thread = Thread.new { @intranet.start }
         while @intranet.instance_variable_get(:@server).status != :Running
         end
 
         socket = TCPSocket.new('localhost', @intranet.port)
-        socket.puts("GET /r/index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
-        expect(socket.gets).to include('HTTP/1.1 200 OK')
-        expect(responder.finalized).to be false
+        socket.puts("GET /index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
+        expect(socket.gets).to include('HTTP/1.1 307 Temporary Redirect')
+        while (line = socket.gets.chomp) # search the HTTP response for the 'Location' header
+          break if line.start_with?('Location:')
+        end
+        expect(line).to include("http://localhost:#{@intranet.port}/responder/index.html")
         socket.close
 
         @intranet.stop
-        while @intranet.instance_variable_get(:@server).status != :Stop
-        end
+        thread&.join
+      end
+    end
+  end
 
-        expect { TCPSocket.new('localhost', @intranet.port) }.to raise_error(Errno::ECONNREFUSED)
-        expect(responder.finalized).to be true
-      ensure
-        socket.close
-        Thread.kill(thread)
-        thread.join
+  describe '#stop' do
+    it 'should stop the web server and finalize all registered responders' do
+      @intranet = described_class.new(Intranet::Logger.new(Intranet::Logger::FATAL))
+      responder = Intranet::TestResponder.new('/index.html' => [200, 'text/html', 'CONTENT'])
+      @intranet.register_module(responder, %w[r], responder.resources_dir)
+      thread = Thread.new { @intranet.start }
+      while @intranet.instance_variable_get(:@server).status != :Running
       end
+
+      socket = TCPSocket.new('localhost', @intranet.port)
+      socket.puts("GET /r/index.html HTTP/1.1\r\nHost: localhost:#{@intranet.port}\r\n\r\n")
+      expect(socket.gets).to include('HTTP/1.1 200 OK')
+      expect(responder.finalized).to be false
+      socket.close
+
+      @intranet.stop
+      thread&.join
+
+      expect { TCPSocket.new('localhost', @intranet.port) }.to raise_error(Errno::ECONNREFUSED)
+      expect(responder.finalized).to be true
     end
   end
 end

data/spec/test_responder/responder.rb

@@ -38,12 +38,12 @@ module Intranet
     end
 
     def resources_dir
-      __dir__
+      super
     end
 
     def generate_page(path, query)
-      if path == '/query'
-        [200, 'text/plain', query.to_s + "\r\n"]
+      if path.start_with?('/query')
+        [200, 'text/plain', dump_with_encoding(path, query)]
       else
         @responses.fetch(path)
       end
@@ -58,5 +58,13 @@ module Intranet
     def js_dependencies
       super + @extra_js
     end
+
+    private
+
+    def dump_with_encoding(path, query)
+      "PATH=#{path} (#{path.encoding}), QUERY={" +
+        query.map { |k, v| "#{k} (#{k.encoding}) => #{v} (#{v.encoding})" }.join(',') +
+        "}\r\n"
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: intranet-core
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Ebling Mis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-10 00:00:00.000000000 Z
+date: 2021-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.63.0
+        version: 0.81.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.63.0
+        version: 0.81.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -158,6 +158,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/core_extensions.rb
+- lib/core_extensions/hash.rb
 - lib/core_extensions/string.rb
 - lib/core_extensions/tree.rb
 - lib/core_extensions/webrick/httpresponse.rb
@@ -179,6 +180,7 @@ files:
 - lib/intranet/resources/www/fonts/SourceSansPro.woff2
 - lib/intranet/resources/www/nav.js
 - lib/intranet/resources/www/style.css
+- spec/core_extensions/hash_spec.rb
 - spec/core_extensions/string_spec.rb
 - spec/core_extensions/tree_spec.rb
 - spec/core_extensions/webrick/httpresponse_spec.rb
@@ -189,7 +191,6 @@ files:
 - spec/intranet/logger_spec.rb
 - spec/spec_helper.rb
 - spec/test_responder/responder.rb
-- spec/test_responder/www/style.css
 homepage: https://rubygems.org/gems/intranet-core
 licenses:
 - MIT
@@ -211,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Core component to build a custom intranet.

data/spec/test_responder/www/style.css

@@ -1,5 +0,0 @@
-/**
- * test_responder/www/style.css
- * Design for the Test Responder of the Intranet-Core.
- */
-