intranet-core 2.1.4 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1d7d91fa0a962e4835681a46f50c7e49b5aaa77327ab112d2999aa90b26a312
-  data.tar.gz: 3c67a863896c42b5b83de33863e372678bae92ee831c05f91a6484343ecff88e
+  metadata.gz: a6860141eca0145a6d51787a137641ead4978b69d2f7b2d28ce5dcf1a5193f42
+  data.tar.gz: 6f43415cdf7334c81466b1205a838b92762c15dff3fb8ca3e096ccb71ebecfa2
 SHA512:
-  metadata.gz: 2df2d7de87df4c1a267c6fa39f3188ec8231b265c7206351bcde3a1203ad4c4c5d6b163a747888f1967e783c8fd1e1d0a1bbf5d081bd8d5f864eee83ae67ef03
-  data.tar.gz: 0ca99259824749ffe9f08c3c8c32a0faa7b7f6afaa063c5e45072fe883355ed684beb35af5ab878f94ff2a037ca391bb9a4a05c918ec3e31ea9e817b716531b7
+  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/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/version.rb

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

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,59 +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])
-        @thread = Thread.new do
-          @intranet.start
-        end
+
+        @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
@@ -179,148 +187,142 @@ RSpec.describe Intranet::Core do
 
     context 'given a valid and registered module' do
       it 'should be called with the decoded URL path and query in UTF-8 encoding' 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%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)}'
-          )
-        ensure
-          socket.close
-          Thread.kill(thread)
-          thread.join
+        @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 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
-          )
-        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
@@ -329,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: intranet-core
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.2.0
 platform: ruby
 authors:
 - Ebling Mis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-12 00:00:00.000000000 Z
+date: 2021-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -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