itsi-server 0.2.2 → 0.2.3

data/lib/itsi/server/config/dsl.rb

@@ -9,7 +9,7 @@ module Itsi
         attr_reader :parent, :children, :middleware, :controller, :routes, :http_methods, :protocols,
                     :hosts, :ports, :extensions, :content_types, :accepts, :options
 
-        def self.evaluate(config = Itsi::Server::Config.config_file_path, &blk)
+        def self.evaluate(config = Itsi::Server::Config.config_file_path, &blk) # rubocop:disable Metrics/MethodLength
           config = new(routes: ["/"]) do
             if blk
               instance_exec(&blk)
@@ -17,14 +17,14 @@ module Itsi
               code = IO.read(config)
               instance_eval(code, config.to_s, 1)
             end
-            location("*"){}
+            location("*") {}
           end
           [config.options, config.errors]
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           [{}, [[e, e.backtrace[0]]]]
         end
 
-        def initialize(
+        def initialize( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
           parent = nil,
           routes: [],
           methods: [],
@@ -57,12 +57,7 @@ module Itsi
               @options[:middleware_loaders].each(&:call)
               @middleware[:app] ||= {}
               @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
-              if errors.any?
-                error = errors.first.first
-                error.set_backtrace(error.backtrace.drop_while{|r| r =~ /itsi\/server\/config/ })
-                raise error
-              end
-              flatten_routes
+              [flatten_routes, Config.errors_to_error_lines(errors)]
             end
           }
 
@@ -78,7 +73,7 @@ module Itsi
           option_name = option.option_name
           define_method(option_name) do |*args, **kwargs, &blk|
             option.new(self, *args, **kwargs, &blk).build!
-          rescue => e
+          rescue Exception => e # rubocop:disable Lint/RescueException
             @errors << [e, caller[1]]
           end
         end
@@ -89,7 +84,7 @@ module Itsi
             middleware.new(self, *args, **kwargs, &blk).build!
           rescue Config::Endpoint::InvalidHandlerException => e
             @errors << [e, "#{e.backtrace[0]}:in #{e.message}"]
-          rescue => e
+          rescue Exception => e # rubocop:disable Lint/RescueException
             @errors << [e, caller[1]]
           end
         end
@@ -99,7 +94,7 @@ module Itsi
           @grpc_reflected_services.concat(handlers)
 
           location("grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
-                    "grpc.reflection.v1.ServerReflection/ServerReflectionInfo") do
+                   "grpc.reflection.v1.ServerReflection/ServerReflectionInfo") do
             @middleware[:app] = { preloader: lambda {
               Itsi::Server::GrpcInterface.reflection_for(handlers)
             }, request_type: "grpc" }
@@ -141,7 +136,7 @@ module Itsi
             when Regexp
               seg.source
             else
-              parts = seg.split('/')
+              parts = seg.split("/")
               parts.map do |part|
                 case part
                 when /^:([A-Za-z_]\w*)(?:\(([^)]*)\))?$/
@@ -184,11 +179,11 @@ module Itsi
 
           chain.each do |n|
             n.middleware.each do |k, v|
-              if v[:combine]
-                merged[k] = ([merged[k] || []] + [v]).flatten
-              else
-                merged[k] = v
-              end
+              merged[k] = if v[:combine]
+                            ([merged[k] || []] + [v]).flatten
+                          else
+                            v
+                          end
             end
           end
           deep_stringify_keys(merged)

data/lib/itsi/server/config/known_paths.rb

@@ -2,16 +2,20 @@ module Itsi
   class Server
     module KnownPaths
       ALL = []
-      Dir.glob(File.join(__dir__, 'known_paths', '**', '*.txt')).each do |file|
-        method_name = file[/known_paths\/(.*?)\.txt/,1].gsub(/([a-z])([A-Z])/, "\\1_\\2")
-          .gsub(/-|\.|\//, "_")
-          .gsub(/(^|\/)[0-9]/){|match| "FO"}.downcase.to_sym
+      Dir.glob(File.join(__dir__, "known_paths", "**", "*.txt")).each do |file|
+        method_name = file[%r{known_paths/(.*?)\.txt}, 1].gsub(/([a-z])([A-Z])/, "\\1_\\2")
+                                                         .gsub(%r{-|\.|/}, "_")
+                                                         .gsub(%r{(^|/)[0-9]}) do |match|
+          match.gsub(/\d/) do |digit|
+            %w[zero one two three four five six seven eight nine][digit.to_i]
+          end
+        end.downcase.to_sym
 
         ALL << method_name
-        self.define_singleton_method(method_name) do
+        define_singleton_method(method_name) do
           File.readlines(file).map do |s|
-            s.force_encoding('UTF-8')
-            s.valid_encoding? ? s.strip : s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '').strip
+            s.force_encoding("UTF-8")
+            s.valid_encoding? ? s.strip : s.encode("UTF-8", invalid: :replace, undef: :replace, replace: "").strip
           end
         end
       end

data/lib/itsi/server/config/middleware/error_response.md

@@ -34,6 +34,19 @@ E.g.
 auth_api_key .. other options.., error_response: 'forbidden'
 ```
 
+## Example of built-in response
+### HTML
+  {{< card  title="Built-in error page" image="/error_page.jpg" subtitle="Default Itsi Error Page." method="Resize" options="10x q80 webp" >}}
+### JSON
+```json
+{
+  "error": "Too Many Requests",
+  "message": "Too many requests within a limited time frame.",
+  "code": 429,
+  "status": "error"
+}
+```
+
 ## Override the error response
 You may instead wish to completely override the error response. You can provide a status code, and a message in up to three
 formats: plain-text, JSON, or HTML (at least one must be provided). Itsi will serve the appropriate type based on the `Accept` header of the incoming request, or fall back to the default if the requested type is not available.

data/lib/itsi/server/config/middleware/static_assets.md

@@ -20,6 +20,46 @@ It can auto-index directories for simple directory listings.
 static_assets root_dir: "./"
 ```
 
+### Directory Index
+#### HTML
+
+  {{< card link="/" title="Static File Server" image="/directory_listing.jpg" subtitle="Static File Listing, Powered by Itsi." method="Resize" options="500x q80 webp" >}}
+
+#### JSON
+Directory indexes also support responding in JSON format. E.g.
+
+`curl -H "Accept: application/json" http://0.0.0.0`
+
+```json
+{
+  "directory": ".",
+  "items": [
+    {
+      "is_dir": false,
+      "modified": "2025-04-22 04:21:43",
+      "name": "Gemfile",
+      "path": "Gemfile",
+      "size": "42 B"
+    },
+    {
+      "is_dir": false,
+      "modified": "2025-04-22 04:21:48",
+      "name": "Gemfile.lock",
+      "path": "Gemfile%2Elock",
+      "size": "463 B"
+    },
+    {
+      "is_dir": false,
+      "modified": "2025-04-22 02:46:45",
+      "name": "Itsi.rb",
+      "path": "Itsi%2Erb",
+      "size": "80 B"
+    }
+  ],
+  "title": "Directory listing for ."
+}
+```
+
 ## Configuration Options
 
 

data/lib/itsi/server/config/option.rb

@@ -4,7 +4,6 @@ module Itsi
       class Option
         include ConfigHelpers
 
-
         def build!
           location.options[self.class.option_name] = @params
         end

data/lib/itsi/server/config/options/nodelay.md

@@ -8,9 +8,9 @@ This option determines whether the Nagle's algorithm is disabled, allowing small
 
 ## Configuration
 ```ruby {filename=Itsi.rb}
-reuse_address true
+nodelay true
 ```
 
 ```ruby {filename=Itsi.rb}
-reuse_address false
+nodelay false
 ```

data/lib/itsi/server/config/options/reuse_address.md

@@ -4,7 +4,7 @@ url: /options/reuse_address
 ---
 
 Configures whether the server should bind to the underlying socket using the `SO_REUSEADDR` option.
-This optiondetermines whether the server allows the reuse of local addresses during binding. This can be useful in scenarios where a socket needs to be quickly rebound without waiting for the operating system to release the address.
+This option determines whether the server allows the reuse of local addresses during binding. This can be useful in scenarios where a socket needs to be quickly rebound without waiting for the operating system to release the address.
 
 ## Configuration
 ```ruby {filename=Itsi.rb}

data/lib/itsi/server/config/typed_struct.rb

@@ -1,5 +1,7 @@
-require 'date'
-require 'time'
+# frozen_string_literal: true
+
+require "date"
+require "time"
 
 module Itsi
   class Server
@@ -10,25 +12,19 @@ module Itsi
 
         def self.new(defaults = nil, &defaults_blk)
           defaults = TypedStruct.module_eval(&defaults_blk) if defaults_blk
-          unless defaults.is_a?(Hash)
-            return defaults
-          end
+          return defaults unless defaults.is_a?(Hash)
+
           defaults.transform_values! { _1.is_a?(Validation) ? _1.default(nil) : _1 }
           Struct.new(*defaults.keys, keyword_init: true) do
             define_method(:initialize) do |*input, validate: true, **raw_input|
+              raise "─ Invalid input to #{self}: #{input.last}" if input.last && !input.last.is_a?(Hash)
 
-              if input.last && !input.last.is_a?(Hash)
-                raise "─ Invalid input to #{self}: #{input.last}"
-              end
-              raw_input.transform_keys!{|k| k.to_s.downcase.to_sym }
-              raw_input.merge!(input.pop.transform_keys!{|k| k.to_s.downcase.to_sym}) if input.last.is_a?(Hash)
+              raw_input.transform_keys! { |k| k.to_s.downcase.to_sym }
+              raw_input.merge!(input.pop.transform_keys! { |k| k.to_s.downcase.to_sym }) if input.last.is_a?(Hash)
 
               excess_keys = raw_input.keys - defaults.keys
 
-              if excess_keys.any?
-                raise "─ Unsupported keys #{excess_keys}"
-
-              end
+              raise "─ Unsupported keys #{excess_keys}" if excess_keys.any?
 
               initial_values = defaults.each_with_object({}) do |(k, default_config), inputs|
                 value = raw_input.key?(k) ? raw_input[k] : default_config[VALUE].dup
@@ -106,9 +102,7 @@ module Itsi
 
           def &(other)
             tail = self
-            while tail.next
-              tail = tail.next
-            end
+            tail = tail.next while tail.next
             tail.next = other
             self
           end
@@ -148,10 +142,14 @@ module Itsi
                       elsif validation.eql?(::Date) then Date.parse(value.to_s)
                       elsif validation.eql?(Float) then Float(value)
                       elsif validation.eql?(Integer) then Integer(value)
-                      elsif validation.eql?(Proc) then
+                      elsif validation.eql?(Proc)
                         raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(Proc)
                       elsif validation.eql?(String) || validation.eql?(Symbol)
-                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(String) || value.is_a?(Symbol)
+                        unless value.is_a?(String) || value.is_a?(Symbol)
+                          raise ArgumentError,
+                                "Invalid #{validation} value: #{value.inspect}"
+                        end
+
                         if validation.eql?(String)
                           value.to_s
                         elsif validation.eql?(Symbol)
@@ -178,33 +176,32 @@ module Itsi
         {
           Bool: Validation.new(:Bool, [[true, false]]),
           Required: Validation.new(:Required, ->(value) { !value.nil? }),
-          Or: ->(*validations){
-            Validation.new(:Or, ->(v){
-
+          Or: lambda { |*validations|
+            Validation.new(:Or, lambda { |v|
               return true if v.nil?
+
               errs = []
               validations.each do |validation|
-                begin
-                  v = validation.validate!(v)
-                  return v
-                rescue StandardError => e
-                  errs << e.message
-                end
+                v = validation.validate!(v)
+                return v
+              rescue StandardError => e
+                errs << e.message
               end
               raise StandardError.new("─ Validation failed (None match:) \n  └#{errs.join("\n  └")}")
             })
           },
-          Range: ->(input_range) {
+          Range: lambda { |input_range|
             Validation.new(:Range, [input_range])
           },
           Length: lambda { |input_length|
             Validation.new(:Length, ->(value) { input_length === value.length })
           },
-          Hash: ->(key_type, value_type) {
-            Validation.new(:Hash, ->(v){
-              return true if v.nil?
-              raise StandardError.new("Expected hash got #{v.class}") unless v.is_a?(Hash)
-              v.map do |k, v|
+          Hash: lambda { |key_type, value_type|
+            Validation.new(:Hash, lambda { |hash|
+              return true if hash.nil?
+              raise StandardError.new("Expected hash got #{hash.class}") unless hash.is_a?(Hash)
+
+              hash.map do |k, v|
                 [
                   key_type.validate!(k),
                   value_type.validate!(v)
@@ -213,7 +210,7 @@ module Itsi
             })
           },
           Type: ->(input_type) { Validation.new(:Type, input_type) },
-          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map{|v| v.kind_of?(Symbol) ? v.to_s : v}]) },
+          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map { |v| v.is_a?(Symbol) ? v.to_s : v }]) },
           Array: lambda { |*value_validations|
             Validation.new(:Array, [::Array, lambda { |value|
               return true unless value

data/lib/itsi/server/config.rb

@@ -41,15 +41,18 @@ module Itsi
           elsif args[:static]
             DSL.evaluate do
               location "/" do
-                rate_limit key: 'address', store_config: 'in_memory', requests: 2, seconds: 5
-                etag type: 'strong', algorithm: 'md5', min_body_size: 1024 * 1024
-                compress min_size: 1024 * 1024, level: 'fastest', algorithms: %w[zstd gzip br deflate], mime_types: %w[all], compress_streams: true
-                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " }, after: { level: "INFO", format: "[{request_id}] └─ {status} in {response_time}" }
+                rate_limit key: "address", store_config: "in_memory", requests: 2, seconds: 5
+                etag type: "strong", algorithm: "md5", min_body_size: 1024 * 1024
+                compress min_size: 1024 * 1024, level: "fastest", algorithms: %w[zstd gzip br deflate],
+                         mime_types: %w[all], compress_streams: true
+                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " },
+                             after: { level: "INFO",
+                                      format: "[{request_id}] └─ {status} in {response_time}" }
                 static_assets \
                   relative_path: true,
                   allowed_extensions: [],
-                  root_dir: '.',
-                  not_found_behavior: {error: 'not_found'},
+                  root_dir: ".",
+                  not_found_behavior: { error: "not_found" },
                   auto_index: true,
                   try_html_extension: true,
                   max_file_size_in_memory: 1024 * 1024, # 1MB
@@ -57,7 +60,7 @@ module Itsi
                   file_check_interval: 1,
                   serve_hidden_files: false,
                   headers: {
-                    'X-Content-Type-Options' => 'nosniff'
+                    "X-Content-Type-Options" => "nosniff"
                   }
               end
             end
@@ -69,7 +72,7 @@ module Itsi
               rackup_file args.fetch(:rackup_file, "./config.ru")
             end
           else
-            DSL.evaluate{}
+            DSL.evaluate {}
           end
 
         itsifile_config.transform_keys!(&:to_sym)
@@ -85,7 +88,7 @@ module Itsi
             Itsi.log_debug("Preloading middleware and default rack app")
             preloaded_middleware = middleware_loader.call
             middleware_loader = -> { preloaded_middleware }
-          rescue StandardError => e
+          rescue Exception => e # rubocop:disable Lint/RescueException
             errors << [e, e.backtrace[0]]
           end
         # If we're just preloading a specific gem group, we'll do that here too
@@ -107,7 +110,13 @@ module Itsi
           worker_memory_limit: args.fetch(:worker_memory_limit) { itsifile_config.fetch(:worker_memory_limit, nil) },
           silence: args.fetch(:silence) { itsifile_config.fetch(:silence, false) },
           shutdown_timeout: args.fetch(:shutdown_timeout) { itsifile_config.fetch(:shutdown_timeout, 5) },
-          hooks: args[:hooks] && itsifile_config[:hooks] ? args[:hooks].merge(itsifile_config[:hooks]) : itsifile_config.fetch(:hooks, args[:hooks]),
+          hooks: if args[:hooks] && itsifile_config[:hooks]
+                   args[:hooks].merge(itsifile_config[:hooks])
+                 else
+                   itsifile_config.fetch(
+                     :hooks, args[:hooks]
+                   )
+                 end,
           preload: !!preload,
           request_timeout: itsifile_config.fetch(:request_timeout, nil),
           header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
@@ -132,53 +141,23 @@ module Itsi
           listeners: args.fetch(:listeners) { nil },
           reuse_address: itsifile_config.fetch(:reuse_address, true),
           reuse_port: itsifile_config.fetch(:reuse_port, true),
-          listen_backlog: itsifile_config.fetch(:listen_backlog, 1024 ),
+          listen_backlog: itsifile_config.fetch(:listen_backlog, 1024),
           nodelay: itsifile_config.fetch(:nodelay, true),
           recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
         }.transform_keys(&:to_s)
 
-        error_lines = errors.flat_map do |(error, message)|
-            location =  message[/(.*?)\:in/,1]
-            file, lineno = location.split(":")
-            lineno = lineno.to_i
-            err_message = error.kind_of?(NoMethodError) ? error.detailed_message : error.message
-            file_lines = IO.readlines(file)
-            info_lines = if error.kind_of?(SyntaxError)
-              []
-            else
-              ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
-                if currline == lineno-1
-                  line = file_lines[currline][0...-1]
-                  padding = line[/^\s+/]&.length || 0
-
-                  [
-                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
-                    "     | #{' ' * padding}\e[33m^^^\e[0m "
-                  ]
-                else
-                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
-                end
-              end.flatten
-            end
-            [
-              err_message,
-              "   --> #{File.expand_path(file)}:#{lineno}",
-              *info_lines
-            ]
-          end
-
-        return srv_config, error_lines
-      rescue
+        [srv_config, errors_to_error_lines(errors)]
+      rescue StandardError
         Itsi.log_error e.message
         puts e.backtrace
       end
 
       def self.test!(cli_params)
-        _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        config, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
         unless errors.any?
           begin
-            _["middleware_loader"][]
-          rescue Exception => e
+            config["middleware_loader"][]
+          rescue Exception => e # rubocop:disable Lint/RescueException
             errors = [e]
           end
         end
@@ -191,6 +170,42 @@ module Itsi
         end
       end
 
+      def self.errors_to_error_lines(errors)
+        return unless errors
+
+        errors.flat_map do |(error, message)|
+          location = message[/(.*?):in/, 1]
+          file, lineno = location.split(":")
+          lineno = lineno.to_i
+          err_message = error.is_a?(NoMethodError) ? error.detailed_message : error.message
+          file_lines = IO.readlines(file)
+          info_lines = \
+            if error.is_a?(SyntaxError)
+              []
+            else
+
+              ([lineno - 2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                if currline == lineno - 1
+                  line = file_lines[currline][0...-1]
+                  padding = line[/^\s+/]&.length || 0
+
+                  [
+                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
+                    "     | #{" " * padding}\e[33m^^^\e[0m "
+                  ]
+                else
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
+                end
+              end.flatten
+            end
+          [
+            err_message,
+            "   --> #{File.expand_path(file)}:#{lineno}",
+            *info_lines
+          ]
+        end
+      end
+
       # Reloads the entire process
       # using exec, passing in any active file descriptors
       # and previous invocation arguments
@@ -233,56 +248,56 @@ module Itsi
 
         default_config = IO.read("#{__dir__}/default_config/Itsi.rb")
 
-        if File.exist?("./config.ru")
-          default_config << <<~RUBY
-          # You can mount several Ruby apps as either
-          # 1. rackup files
-          # 2. inline rack apps
-          # 3. inline Ruby endpoints
-          #
-          # 1. rackup_file
-          rackup_file "./config.ru"
-          #
-          # 2. inline rack app
-          # require 'rack'
-          # run(Rack::Builder.app do
-          #   use Rack::CommonLogger
-          #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
-          # end)
-          #
-          # 3. Endpoints
-          # endpoint "/" do |req|
-          #   req.ok "Hello from Itsi"
-          # end
-          RUBY
-        else
-          default_config << <<~RUBY
-            # You can mount several Ruby apps as either
-            # 1. rackup files
-            # 2. inline rack apps
-            # 3. inline Ruby endpoints
-            #
-            # 1. rackup_file
-            # Use `rackup_file` to specify the Rack app file name.
-            #
-            # 2. inline rack app
-            # require 'rack'
-            # run(Rack::Builder.app do
-            #   use Rack::CommonLogger
-            #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
-            # end)
-            #
-            # 3. Endpoint
-            endpoint "/" do |req|
-              req.ok "Hello from Itsi"
-            end
-          RUBY
-        end
+        default_config << \
+          if File.exist?("./config.ru")
+            <<~RUBY
+              # You can mount several Ruby apps as either
+              # 1. rackup files
+              # 2. inline rack apps
+              # 3. inline Ruby endpoints
+              #
+              # 1. rackup_file
+              rackup_file "./config.ru"
+              #
+              # 2. inline rack app
+              # require 'rack'
+              # run(Rack::Builder.app do
+              #   use Rack::CommonLogger
+              #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+              # end)
+              #
+              # 3. Endpoints
+              # endpoint "/" do |req|
+              #   req.ok "Hello from Itsi"
+              # end
+            RUBY
+          else
+            <<~RUBY
+              # You can mount several Ruby apps as either
+              # 1. rackup files
+              # 2. inline rack apps
+              # 3. inline Ruby endpoints
+              #
+              # 1. rackup_file
+              # Use `rackup_file` to specify the Rack app file name.
+              #
+              # 2. inline rack app
+              # require 'rack'
+              # run(Rack::Builder.app do
+              #   use Rack::CommonLogger
+              #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+              # end)
+              #
+              # 3. Endpoint
+              endpoint "/" do |req|
+                req.ok "Hello from Itsi"
+              end
+            RUBY
+          end
 
         File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
           file.write(default_config)
         end
-
       end
     end
   end

data/lib/itsi/server/default_app/default_app.rb

@@ -11,7 +11,7 @@ DEFAULT_APP = lambda {
         [
           { "Content-Type" => "application/json" },
           [{ "message" => "You're running on Itsi!", "rack_env" => env,
-              "version" => Itsi::Server::VERSION }.to_json]
+             "version" => Itsi::Server::VERSION }.to_json]
         ]
       else
         [