itsi 0.2.2 → 0.2.4

data/gems/server/lib/itsi/http_response.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
-require 'forwardable'
+
+require "forwardable"
 require "stringio"
 require "socket"
 
 module Itsi
-
   class HttpResponse
-
-    def respond _body=nil, _status=200, _header=nil, status: _status, headers: _header, body: _body, hijack: false, &blk
-
-      self.status = status.kind_of?(Symbol) ? HTTP_STATUS_NAME_TO_CODE_MAP.fetch(status) : status.to_i
+    def respond(
+      _body = nil, _status = 200, _header = nil, # rubocop:disable Lint/UnderscorePrefixedVariableName
+      status: _status, headers: _header, body: _body,
+      hijack: false
+    )
+      self.status = status.is_a?(Symbol) ? HTTP_STATUS_NAME_TO_CODE_MAP.fetch(status) : status.to_i
 
       body = body.to_s unless body.is_a?(String)
 
@@ -33,9 +35,9 @@ module Itsi
 
         # If you hijack the connection, you are responsible for closing it.
         # Otherwise, the response will be closed automatically.
-        self.close unless hijack
+        close unless hijack
       else
-        self.close
+        close
       end
     end
   end

data/gems/server/lib/itsi/passfile.rb

@@ -1,8 +1,7 @@
 module Itsi
   class Server
-
     module Passfile
-      require 'io/console'
+      require "io/console"
 
       module_function
 
@@ -18,7 +17,7 @@ module Itsi
             line.chomp!
             next if line.empty?
 
-            user, pass = line.split(':', 2)
+            user, pass = line.split(":", 2)
             creds[user] = pass
           end
         end
@@ -26,14 +25,14 @@ module Itsi
       end
 
       def save(creds, filename)
-        File.open(filename, 'w', 0o600) do |f|
+        File.open(filename, "w", 0o600) do |f|
           creds.each do |u, p|
             f.puts "#{u}:#{p}"
           end
         end
       end
 
-      def echo(filename, algorithm)
+      def echo(_, algorithm)
         print "Enter username: "
         username = $stdin.gets.chomp
 
@@ -56,6 +55,7 @@ module Itsi
 
       def add(filename, algorithm)
         return unless (creds = load(filename))
+
         print "Enter username: "
         username = $stdin.gets.chomp
 
@@ -98,11 +98,11 @@ module Itsi
       def list(filename)
         puts "Current credentials in '#{filename}':"
         return unless (creds = load(filename))
+
         creds.each do |u, p|
           puts "#{u}:#{p}"
         end
       end
-
     end
   end
 end

data/gems/server/lib/itsi/server/config/config_helpers.rb

@@ -2,7 +2,6 @@ module Itsi
   class Server
     module Config
       module ConfigHelpers
-
         def self.load_and_register(klass)
           config_type = klass.name.split("::").last.downcase.gsub(/([a-z]()[A-Z])/, '\1_\2')
 
@@ -17,35 +16,35 @@ module Itsi
             following = klass.subclasses
             new_class = (following - current).first
 
-            documentation_file = "#{file[/(.*)\.rb/,1]}.md"
-            if ! File.exist?(documentation_file)
-              documentation_file =  "#{file[/(.*)\/[^\/]+\.rb/,1]}/_index.md"
-            end
-            if File.exist?(documentation_file) && new_class
-              new_class.documentation IO.read(documentation_file)
-                .gsub(/^---.*?\n.*?-+/m,'') # Strip frontmatter
-                .gsub(/^(```.*?)\{.*?\}.*$/, "\\1") # Strip filename from code blocks
-                .gsub(/^\{\{[^\}]+\}\}/, "") # Strip Hugo blocks
-            end
+            documentation_file = "#{file[/(.*)\.rb/, 1]}.md"
+            documentation_file = "#{file[%r{(.*)/[^/]+\.rb}, 1]}/_index.md" unless File.exist?(documentation_file)
+            next unless File.exist?(documentation_file) && new_class
+
+            new_class.documentation IO.read(documentation_file)
+                                      .gsub(/^---.*?\n.*?-+/m, "") # Strip frontmatter
+                                      .gsub(/^(```.*?)\{.*?\}.*$/, "\\1") # Strip filename from code blocks
+                                      .gsub(/^\{\{[^}]+\}\}/, "") # Strip Hugo blocks
           end
         end
 
-        def normalize_keys!(hash, expected=[])
+        def normalize_keys!(hash, expected = [])
           hash.keys.each do |key|
             value = hash.delete(key)
             key = key.to_s.downcase.to_sym
             hash[key] = value
             raise "Unexpected key: #{key}" unless expected.include?(key)
+
             expected -= [key]
           end
-          raise "Missing required keys: #{expected.join(', ')}" unless expected.empty?
+          raise "Missing required keys: #{expected.join(", ")}" unless expected.empty?
+
           hash
         end
 
-        def self.included(cls)
-          def cls.inherited(base)
+        def self.included(cls) # rubocop:disable Metrics/PerceivedComplexity,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          def cls.inherited(base) # rubocop:disable Metrics/MethodLength,Lint/MissingSuper,Metrics/PerceivedComplexity
             %i[detail documentation insert_text schema].each do |attr|
-              base.define_singleton_method(attr) do |value=nil|
+              base.define_singleton_method(attr) do |value = nil|
                 @middleware_class_attrs ||= {}
                 if value
                   @middleware_class_attrs[attr] = value
@@ -54,12 +53,12 @@ module Itsi
                 end
               end
 
-              base.define_method(attr) do |value=nil|
+              base.define_method(attr) do |_value = nil|
                 self.class.send(attr)
               end
             end
 
-            def base.schema(value=nil, &blk)
+            def base.schema(value = nil, &blk)
               @middleware_class_attrs ||= {}
               if blk
                 @middleware_class_attrs[:schema] = TypedStruct.new(&blk)
@@ -75,29 +74,30 @@ module Itsi
 
           config_type = cls.name.split("::").last.downcase
 
-          cls.define_singleton_method("#{config_type}_name") do |name=self.name|
+          cls.define_singleton_method("#{config_type}_name") do |name = self.name|
             @config_name ||= name.split("::").last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
           end
-          cls.define_method(:opt_name){ self.class.send("#{config_type}_name") }
-          cls.define_method(:location){ @location }
+          cls.define_method(:opt_name) { self.class.send("#{config_type}_name") }
+          cls.define_method(:location) { @location }
         end
 
-        def initialize(location, params={})
+        def initialize(location, params = {})
           if !self.class.ancestors.include?(Middleware) && !location.parent.nil?
             raise "#{opt_name} must be set at the top level"
           end
+
           @location = location
-          @params = case self.schema
-          when TypedStruct::Validation
-            self.schema.validate!(params)
-          when Array
-            default, validation = self.schema
-            params ? validation.validate!(params) : default
-          when nil
-            nil
-          else
-            self.schema.new(params).to_h
-          end
+          @params = case schema
+                    when TypedStruct::Validation
+                      schema.validate!(params)
+                    when Array
+                      default, validation = schema
+                      params ? validation.validate!(params) : default
+                    when nil
+                      nil
+                    else
+                      schema.new(params).to_h
+                    end
         end
       end
     end

data/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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/gems/server/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"