itsi-server 0.2.2 → 0.2.4

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: [],
@@ -52,17 +52,12 @@ module Itsi
           @accepts = accepts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
 
           @options = {
-            middleware_loaders: [],
+            nested_locations: [],
             middleware_loader: lambda do
-              @options[:middleware_loaders].each(&:call)
+              @options[:nested_locations].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/endpoint/endpoint.rb

@@ -84,10 +84,6 @@ module Itsi
             end
           else
             @params[:paths] << "" if @params[:paths].empty?
-            @params[:paths] = @params[:paths].flat_map do |p|
-              stripped_trailing = p[/(.*)\/?$/, 1]
-              [stripped_trailing, stripped_trailing + "/"]
-            end.uniq
             location.location(*@params[:paths], methods: @params[:http_methods]) do
               @middleware[:app] = app
             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/location.rb

@@ -27,7 +27,7 @@ module Itsi
         end
 
         attr_accessor :location, :routes, :block, :protocols, :hosts, :ports,
-          :extensions, :content_types, :accepts, :block
+          :extensions, :content_types, :accepts
 
         def initialize(location,
           *routes,
@@ -56,13 +56,13 @@ module Itsi
             block: block
           }).to_h
           @routes = params[:routes].empty? ? ["*"] : params[:routes]
-          @methods = params[:methods]
-          @protocols = params[:protocols] | params[:schemes]
-          @hosts = params[:hosts]
-          @ports = params[:ports]
-          @extensions = params[:extensions]
-          @content_types = params[:content_types]
-          @accepts = params[:accepts]
+          @methods = params[:methods].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @protocols = (params[:protocols] | params[:schemes]).map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @hosts = params[:hosts].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @ports = params[:ports].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @extensions = params[:extensions].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @content_types = params[:content_types].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @accepts = params[:accepts].map { |s| s.is_a?(Regexp) ? s : s.to_s }
           @block = block
         end
 
@@ -70,27 +70,31 @@ module Itsi
           @methods
         end
 
+        def intersect(a, b)
+          return b if a.empty?
+          return a if b.empty?
+          a & b
+        end
+
         def build!
           build_child = lambda {
-            location.children << DSL.new(
+            child = DSL.new(
               location,
               routes: routes,
-              methods: Array(http_methods) | location.http_methods,
-              protocols: Array(protocols) | location.protocols,
-              hosts: Array(hosts) | location.hosts,
-              ports: Array(ports) | location.ports,
-              extensions: Array(extensions) | location.extensions,
-              content_types: Array(content_types) | location.content_types,
-              accepts: Array(accepts) | location.accepts,
+              methods: intersect(http_methods, location.http_methods),
+              protocols: intersect(protocols, location.protocols),
+              hosts: intersect(hosts, location.hosts),
+              ports: intersect(ports, location.ports),
+              extensions: intersect(extensions, location.extensions),
+              content_types: intersect(content_types, location.content_types),
+              accepts: intersect(accepts, location.accepts),
               controller: location.controller,
               &block
             )
+            child.options[:nested_locations].each(&:call)
+            location.children << child
           }
-          if location.parent.nil?
-            location.options[:middleware_loaders] << build_child
-          else
-            build_child[]
-          end
+          location.options[:nested_locations] << build_child
         end
 
       end

data/lib/itsi/server/config/middleware/proxy.rb

@@ -2,17 +2,16 @@ module Itsi
   class Server
     module Config
       class Proxy < Middleware
-
         insert_text <<~SNIPPET
-        proxy \\
-          to: "${1:http://backend.example.com/api{path}{query}}", \\
-          backends: [${2:"127.0.0.1:3001", "127.0.0.1:3002"}], \\
-          backend_priority: ${3|"round_robin","ordered","random"|}, \\
-          headers: { ${4| "X-Forwarded-For" => { rewrite: "{addr}" },|} }, \\
-          verify_ssl: ${5|true,false|}, \\
-          timeout: ${6|30,60|}, \\
-          tls_sni: ${7|true,false|}, \\
-          error_response: ${8|"bad_gateway", "service_unavailable", { code: 503\\, default_format: "html"\\, html: { inline: "<h1>Service Unavailable</h1>" } }|}
+          proxy \\
+            to: "${1:http://backend.example.com{path_and_query}",
+            backends: [${2:"127.0.0.1:3001", "127.0.0.1:3002"}],
+            backend_priority: ${3|"round_robin","ordered","random"|},
+            headers: { ${4| "X-Forwarded-For" => { rewrite: "{addr}" },|} },
+            verify_ssl: ${5|true,false|},
+            timeout: ${6|30,60|},
+            tls_sni: ${7|true,false|},
+            error_response: ${8|"bad_gateway", "service_unavailable", { code: 503\\, default_format: "html"\\, html: { inline: "<h1>Service Unavailable</h1>" } }|}
         SNIPPET
 
         detail "Forwards incoming requests to a backend server using dynamic URL rewriting. Supports various backend selection strategies and header overriding."
@@ -21,18 +20,20 @@ module Itsi
           {
             to: Type(String) & Required(),
             backends: Array(Type(String)),
-            backend_priority: Enum(["round_robin", "ordered", "random"]).default("round_robin"),
+            backend_priority: Enum(%w[round_robin ordered random]).default("round_robin"),
             headers: Hash(Type(String), Type(String)).default({}),
             verify_ssl: Bool().default(true),
             tls_sni: Bool().default(true),
             timeout: Type(Integer).default(30),
-            error_response: Type(ErrorResponseDef).default("bad_gateway"),
+            error_response: Type(ErrorResponseDef).default("bad_gateway")
           }
         end
 
         def build!
-          require 'uri'
-          @params[:backends]||=  URI.extract(@params[:to]).map(&URI.method(:parse)).map{|u| "#{u.scheme}://#{u.host}:#{u.port}" }
+          require "uri"
+          @params[:backends] ||= URI.extract(@params[:to]).map(&URI.method(:parse)).map do |u|
+            "#{u.scheme}://#{u.host}:#{u.port}"
+          end
           super
         end
       end

data/lib/itsi/server/config/middleware/rackup_file.rb

@@ -2,12 +2,11 @@ module Itsi
   class Server
     module Config
       class RackupFile < Middleware
-
         insert_text <<~SNIPPET
-        rackup_file \\
-          "config.ru",
-          nonblocking: ${2|true,false|},
-          sendfile: ${3|true,false|}
+          rackup_file \\
+            "config.ru",
+            nonblocking: ${2|true,false|},
+            sendfile: ${3|true,false|}
 
         SNIPPET
 
@@ -23,20 +22,18 @@ module Itsi
         def initialize(location, app, **params)
           super(location, params)
           raise "Rackup file must be a string" unless app.is_a?(String)
+
           @app = Itsi::Server::RackInterface.for(app)
         end
 
         def build!
           app_args = {
-            preloader: -> { @app},
+            preloader: -> { @app },
             sendfile: @params[:sendfile],
             nonblocking: @params[:nonblocking],
-            base_path: "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/, ')')}).*$"
+            base_path: "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/, ")")}).*$"
           }
           location.middleware[:app] = app_args
-          location.location("*") do
-            @middleware[:app] = app_args
-          end
         end
       end
     end

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/middleware/static_assets.rb

@@ -75,11 +75,15 @@ module Itsi
             @params[:allowed_extensions] << ""
           end
 
-          @params[:base_path] = "^(?<base_path>#{location.paths_from_parent}).*$"
-          params = @params
-          location.location("*", extensions: @params[:allowed_extensions]) do
-            @middleware[:static_assets] = params
+          if @params[:allowed_extensions].any? && @params[:auto_index]
+            @params[:allowed_extensions] |= ["html"]
+            @params[:allowed_extensions] |= [""]
           end
+
+          @params[:base_path] = "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/,")")}).*$"
+          params = @params
+
+          location.middleware[:static_assets] = params
         end
       end
     end

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

@@ -13,6 +13,20 @@ The String Rewrite mechanism is used when configuring Itsi for
 
 It allows you to create dynamic strings from a template by combining literal text with placeholders. Placeholders (denoted using curly braces: `{}`) are replaced at runtime with data derived from the HTTP request, response, or context.
 
+Modifiers can be appended after a pipe | to transform the substituted value.
+
+## Modifiers
+
+After a placeholder name, add |<modifier>:<arg> (or for replace, |replace:<from>,<to>). Available modifiers:
+
+`strip_prefix:<text>` If the substituted value starts with <text>, remove that prefix.
+
+`strip_suffix:<text>` If the substituted value ends with <text>, remove that suffix.
+
+`replace:<from>,<to>` Replace all occurrences of <from> in the substituted value with <to>.
+
+Modifiers are applied in the order they appear. You can chain multiple modifiers by repeating the |<modifier>:<arg> syntax (e.g. `{path|strip_prefix:/rails|replace:old,new}`).
+
 ### Rewriting a Request
 
 The following placeholders are supported:

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/include.rb

@@ -3,7 +3,7 @@ module Itsi
     module Config
       class Include < Option
 
-        insert_text "include \"${1|other_file.rb|}\" # Include another file to be loaded within the current configuration"
+        insert_text "include \"${1|other_file|}\" # Include another file to be loaded within the current configuration"
 
         detail "Include another file to be loaded within the current configuration"
 

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