intranet-core 2.1.1 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 33d4ae0d118eb6df517196db16108065df87c47d
-  data.tar.gz: 1bc931bf597059ef00c54368e8e8548548c66fa2
+SHA256:
+  metadata.gz: db45417345875ffcbd1500ce99febcb8e52cdd55934c44812310e75d8dbd85a1
+  data.tar.gz: e330a7b69c123a4c380682dbf3a39ff3a92365f8d0bdcf4ceaa1e175a74ad497
 SHA512:
-  metadata.gz: ec89f5cbf9fb1466b3c22d475380980d44c9d1a369d126c276cb41c719ecc0e193609a17eaffffd1e6f1f7ba74b6d26b95744ab06304bbaff2216d6215038204
-  data.tar.gz: e3baf947cbd08ccc04a96cbaca311030560e70e1b7cd586e6e14a16429b56df42b9c2c7eccec77f1e246a6a335d688c0f734e2d44ff1eef9c06eebc132dd22d5
+  metadata.gz: 360437f3351b25f886a44da9232ab7d844f4fcfcc25d1030b92ea3f6b24370613a3bc9a0dc3fc80ac000df6365a4cdc39da4c85f50ed3351603a345797e1e842
+  data.tar.gz: ad870fc6849c997b62d60618828c292087d3a0232202d340bd18772dda6241f11ccd86a6bd91589f66f3e1cbd67165356728a0e552baf0019f30bc207c10a1d2

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/core_extensions/tree.rb

@@ -62,10 +62,10 @@ module CoreExtensions
     # (depth-first).
     # @return [String]
     def to_s(offset = '')
-      str = offset + 'VALUE: ' + @value.to_s + "\n"
+      str = offset + "VALUE: #{@value}\n"
       @children_nodes.each do |id, node|
-        str += offset + ' * ID:   \'' + id.to_s + '\'' + "\n"
-        str += node.to_s(offset + '   ')
+        str += offset + " * ID:   '#{id}'\n"
+        str += node.to_s("#{offset}   ")
       end
       str
     end

data/lib/intranet/core.rb

@@ -56,7 +56,7 @@ module Intranet
       raise Errno::EALREADY if @server.status != :Stop
 
       @builder.register(responder, path)
-      module_add_servlet(path.empty? ? ['home'] : path, resources_dir)
+      module_add_servlet(path, resources_dir)
       module_add_locales(resources_dir)
       module_add_haml_templates(resources_dir)
     end
@@ -70,8 +70,8 @@ module Intranet
 
     # Starts the web server.
     def start
-      @logger.info('Intranet::Core: using locale \'' + I18n.default_locale.to_s + '\'')
-      @logger.info('Intranet::Core: running Intranet version ' + VERSION)
+      @logger.info("Intranet::Core: using locale '#{I18n.default_locale}'")
+      @logger.info("Intranet::Core: running Intranet version #{VERSION}")
       # Start serving HTTP requests
       @server.start
     end
@@ -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
@@ -113,7 +115,7 @@ module Intranet
     end
 
     def module_add_servlet(path, resources_dir)
-      @server.mount('/' + path.join('/') + '/design',
+      @server.mount("/#{path.join('/')}/design",
                     WEBrick::HTTPServlet::FileHandler,
                     File.join(resources_dir, 'www'))
     end

data/lib/intranet/core/builder.rb

@@ -38,7 +38,7 @@ module Intranet
         @responders.to_h.each do |path, responder|
           next if responder.nil?
 
-          @logger.debug('Intranet::Builder: finalize responder at \'' + path + '\'')
+          @logger.debug("Intranet::Builder: finalize responder at '#{path}'")
           responder.finalize
         end
       end
@@ -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
 
@@ -108,10 +108,21 @@ module Intranet
           end
         end
 
-        [current_treenode.value, '/' + parsed_path.join('/'), '/' + unparsed_path.join('/')]
+        [current_treenode.value, "/#{parsed_path.join('/')}", "/#{unparsed_path.join('/')}"]
       end
 
-      # Check whether a path is valid.
+      # 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. In particular, this function excludes a path containing an
+      # empty ('') or dot ('.') part, for instance '/path//to/./responder'.
       # @param path [Array] The path to test.
       # @return [Boolean] True if the path is valid, False otherwise.
       def valid_path?(path)
@@ -127,8 +138,6 @@ module Intranet
       def insert_responder(responder, path)
         current_node = @responders
         path.each do |part|
-          next if part.empty? || part == '.'
-
           current_node = current_node.add_child_node(part)
         end
         current_node.value = responder

data/lib/intranet/core/haml_wrapper.rb

@@ -50,7 +50,7 @@ module Intranet
       # @return [String] The path to the template if it exists, an empty string otherwise.
       def find_template(template)
         HamlWrapper.load_path.each do |dir|
-          candidate = File.join(dir, template + '.haml')
+          candidate = File.join(dir, "#{template}.haml")
           return candidate if File.exist?(candidate)
         end
         ''

data/lib/intranet/core/servlet.rb

@@ -48,7 +48,7 @@ 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
 

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.1'
+    VERSION = '2.3.1'
 
     # The URL of the gem homepage.
     HOMEPAGE_URL = 'https://rubygems.org/gems/intranet-core'

data/lib/intranet/logger.rb

@@ -26,7 +26,7 @@ module Intranet
     # @param level The level of the message
     # @param msg [String] The message
     def log(level, msg)
-      super(level, COLOR[level] + Time.now.strftime('[%Y-%m-%d %H:%M:%S] ') + msg + "\033[0m")
+      super(level, "#{COLOR[level]}#{Time.now.strftime('[%Y-%m-%d %H:%M:%S]')} #{msg}\033[0m")
     end
 
     # Logs an object that responds to +to_s+ at level INFO.

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;
@@ -193,7 +192,7 @@ ul.breadcrumb li a, main article a {
 /******************************** Main content *******************************/
 
 body > main {
-    background: #f2f2f2;
+    background: #f7f8fa;
     padding: 57px 0px; /* height of the navigation bar */
 }
 
@@ -266,7 +265,7 @@ body > footer aside#modal { /* modal box container */
     background-color: rgba(0, 0, 0, 0.8);
 }
 body > footer aside#modal #modal-content { /* modal box */
-    background-color: #f2f2f2;
+    background-color: #f7f8fa;
     margin: 15% auto;
     padding: 20px 25px 40px; /* top sides bottom */
     border: 1px solid #1e262b;

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/core_extensions/tree_spec.rb

@@ -122,16 +122,18 @@ RSpec.describe CoreExtensions::Tree do
       end
       it 'should return a depth-first representation of the Tree' do
         expect(@tree.to_h).to eql(
-          Hash['/' => 'node0',
-               '/left' => 'node1',
-               '/left/left' => 'node1.1',
-               '/left/right' => 'node1.2',
-               '/middle' => 'node2',
-               '/middle/middle' => 'node2.1',
-               '/right' => 'node3',
-               '/right/left' => 'node3.1',
-               '/right/middle' => 'node3.2',
-               '/right/right' => 'node3.3']
+          {
+            '/' => 'node0',
+            '/left' => 'node1',
+            '/left/left' => 'node1.1',
+            '/left/right' => 'node1.2',
+            '/middle' => 'node2',
+            '/middle/middle' => 'node2.1',
+            '/right' => 'node3',
+            '/right/left' => 'node3.1',
+            '/right/middle' => 'node3.2',
+            '/right/right' => 'node3.3'
+          }
         )
       end
     end
@@ -151,16 +153,18 @@ RSpec.describe CoreExtensions::Tree do
       end
       it 'should return a depth-first representation of the Tree, using the given separator' do
         expect(@tree.to_h(':')).to eql(
-          Hash[':' => 0.0,
-               ':left' => 1.0,
-               ':left:left' => 1.1,
-               ':left:right' => 1.2,
-               ':middle' => 2.0,
-               ':middle:middle' => 2.1,
-               ':right' => 3.0,
-               ':right:left' => 3.1,
-               ':right:middle' => 3.2,
-               ':right:right' => 3.3]
+          {
+            ':' => 0.0,
+            ':left' => 1.0,
+            ':left:left' => 1.1,
+            ':left:right' => 1.2,
+            ':middle' => 2.0,
+            ':middle:middle' => 2.1,
+            ':right' => 3.0,
+            ':right:left' => 3.1,
+            ':right:middle' => 3.2,
+            ':right:right' => 3.3
+          }
         )
       end
     end

data/spec/intranet/core/haml_wrapper_spec.rb

@@ -37,20 +37,12 @@ RSpec.describe Intranet::Core::HamlWrapper do
     end
 
     context 'if the template is not found in path' do
-      before do
-        described_class.load_path = [] # empty load path
-        expect(described_class.load_path).to be_empty
-      end
-
       it 'should return an empty string' do
         expect(included.new.to_markup('')).to be_empty
         expect(extended.to_markup('')).to be_empty
 
         expect(included.new.to_markup('unknown')).to be_empty
         expect(extended.to_markup('unknown')).to be_empty
-
-        expect(included.new.to_markup('title_and_breadcrumb')).to be_empty
-        expect(extended.to_markup('title_and_breadcrumb')).to be_empty
       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,64 +83,76 @@ 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
         socket = TCPSocket.new('localhost', @intranet.port)
-        socket.puts("GET /responder/index.html HTTP/1.1\r\n" \
+        socket.puts("GET /responder/ HTTP/1.1\r\n" \
                     "Host: localhost:#{@intranet.port}\r\n\r\n")
         expect(socket.gets).to include('HTTP/1.1 200 OK')
         socket.close
@@ -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 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
+        )
+
+        # 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

data/spec/intranet/logger_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Intranet::Logger do
       @logger = described_class.new
     end
 
-    TEST_CASES = [
+    test_cases = [
       {
         level: described_class::FATAL, level_str: 'FATAL', level_method: :fatal,
         displayed: {
@@ -81,9 +81,9 @@ RSpec.describe Intranet::Logger do
       }
     ].freeze
 
-    TEST_CASES.each do |tc|
-      context 'given a ' + tc[:level_str] + ' message' do
-        it 'should only be displayed if logger level is at least ' + tc[:level_str] do
+    test_cases.each do |tc|
+      context "given a #{tc[:level_str]} message" do
+        it "should only be displayed if logger level is at least #{tc[:level_str]}" do
           tc[:displayed].each do |level, displayed|
             @logger.level = level
             if displayed
@@ -112,7 +112,7 @@ RSpec.describe Intranet::Logger do
             .to_stderr_from_any_process
         end
 
-        it 'should be colored in ' + tc[:color_desc] do
+        it "should be colored in #{tc[:color_desc]}" do
           @logger.level = tc[:level]
           expect { @logger.log(tc[:level], 'TEST_MSG') }
             .to output(tc[:color_regex]).to_stderr_from_any_process

data/spec/spec_helper.rb

@@ -43,8 +43,11 @@ RSpec.configure do |config|
   # Load and start SimpleCov to gather code coverage information
   unless config.files_to_run.one?
     require 'simplecov'
-    SimpleCov.add_filter 'spec' # exclude 'spec' folder from coverage
-    SimpleCov.start
-    require 'intranet/core'
+    SimpleCov.start do
+      enable_coverage :branch                   # measure branches coverage
+      primary_coverage :branch
+      minimum_coverage line: 100, branch: 100   # minimal coverage rate to succeed
+      add_filter 'spec'                         # exclude 'spec' folder from coverage
+    end
   end
 end

data/spec/test_responder/responder.rb

@@ -6,7 +6,7 @@ module Intranet
   class TestResponder < AbstractResponder
     attr_reader :finalized
 
-    def initialize(responses = {}, extra_css = [], extra_js = [], hide_from_menu = false)
+    def initialize(responses = {}, extra_css = [], extra_js = [], hide_from_menu = false) # rubocop:disable Metrics/ParameterLists
       @responses = responses
       @extra_css = extra_css
       @extra_js = extra_js
@@ -37,10 +37,6 @@ module Intranet
       'http://nil/'
     end
 
-    def resources_dir
-      super
-    end
-
     def generate_page(path, query)
       if path.start_with?('/query')
         [200, 'text/plain', dump_with_encoding(path, query)]
@@ -62,7 +58,7 @@ module Intranet
     private
 
     def dump_with_encoding(path, query)
-      "PATH=#{path} (#{path.encoding}), QUERY={" +
+      "PATH=#{path} (#{path.encoding}), QUERY={" + # rubocop:disable Style/StringConcatenation
         query.map { |k, v| "#{k} (#{k.encoding}) => #{v} (#{v.encoding})" }.join(',') +
         "}\r\n"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: intranet-core
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.3.1
 platform: ruby
 authors:
 - Ebling Mis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-20 00:00:00.000000000 Z
+date: 2021-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -112,30 +112,30 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.63.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.63.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.21'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.21'
 - !ruby/object:Gem::Dependency
   name: yard
   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
@@ -202,7 +204,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -210,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.