itsi 0.1.20 → 0.2.3

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

@@ -2,12 +2,12 @@ module Itsi
   class Server
     module Config
       module ConfigHelpers
-
         def self.load_and_register(klass)
-          config_type = klass.name.split("::").last.downcase
+          config_type = klass.name.split("::").last.downcase.gsub(/([a-z]()[A-Z])/, '\1_\2')
+
           listing = [
-            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}/**.rb")],
-            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}s/**.rb")]
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}/**/*.rb")],
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}s/**/*.rb")]
           ].flatten
 
           listing.each do |file|
@@ -16,32 +16,35 @@ module Itsi
             following = klass.subclasses
             new_class = (following - current).first
 
-            documentation_file = "#{file[/(.*)\.rb/,1]}.md"
-            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
@@ -50,15 +53,17 @@ 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)
+              elsif value
+                @middleware_class_attrs[:schema] = value
               else
                 @middleware_class_attrs[:schema]
               end
@@ -69,23 +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 }
         end
 
-        def initialize(location, params)
-          @location = location
-          @params = case self.schema
-          when TypedStruct::Validation
-            self.schema.validate!(params)
-          else
-            self.schema.new(params).to_h
+        def initialize(location, params = {})
+          if !self.class.ancestors.include?(Middleware) && !location.parent.nil?
+            raise "#{opt_name} must be set at the top level"
           end
-        end
 
-        def build!
-          @params
+          @location = location
+          @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

@@ -6,10 +6,10 @@ module Itsi
         require_relative "option"
         require_relative "middleware"
 
-        attr_reader :parent, :children, :middleware, :controller_class, :routes, :http_methods, :protocols,
+        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,13 +17,14 @@ module Itsi
               code = IO.read(config)
               instance_eval(code, config.to_s, 1)
             end
+            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: [],
@@ -39,7 +40,6 @@ module Itsi
           @parent           = parent
           @children         = []
           @middleware       = {}
-          @controller_class = nil
 
           @controller = controller
           @routes = Array(routes).flatten
@@ -57,7 +57,7 @@ module Itsi
               @options[:middleware_loaders].each(&:call)
               @middleware[:app] ||= {}
               @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
-              flatten_routes
+              [flatten_routes, Config.errors_to_error_lines(errors)]
             end
           }
 
@@ -66,14 +66,14 @@ module Itsi
         end
 
         def errors
-          @children.map(&:errors).flatten + @errors
+          @children.map(&:errors).flatten(1) + @errors
         end
 
         Option.subclasses.each do |option|
           option_name = option.option_name
           define_method(option_name) do |*args, **kwargs, &blk|
-            @options[option_name] = option.new(self, *args, **kwargs, &blk).build!
-          rescue => e
+            option.new(self, *args, **kwargs, &blk).build!
+          rescue Exception => e # rubocop:disable Lint/RescueException
             @errors << [e, caller[1]]
           end
         end
@@ -81,452 +81,28 @@ module Itsi
         Middleware.subclasses.each do |middleware|
           middleware_name = middleware.middleware_name
           define_method(middleware_name) do |*args, **kwargs, &blk|
-            @middleware[middleware_name] = middleware.new(@parent, *args, **kwargs, &blk).build!
-          rescue => e
+            middleware.new(self, *args, **kwargs, &blk).build!
+          rescue Config::Endpoint::InvalidHandlerException => e
+            @errors << [e, "#{e.backtrace[0]}:in #{e.message}"]
+          rescue Exception => e # rubocop:disable Lint/RescueException
             @errors << [e, caller[1]]
           end
         end
 
-        def oob_gc_responses_threshold(threshold)
-          raise "OOB GC responses threshold must be set at the root" unless @parent.nil?
-
-          @options[:oob_gc_responses_threshold] = threshold.to_i
-        end
-
-        def log_level(level)
-          raise "Log level must be set at the root" unless @parent.nil?
-
-          @options[:log_level] = level.to_s
-        end
-
-        def log_target(target)
-          raise "Log target must be set at the root" unless @parent.nil?
-
-          @options[:log_target] = target.to_s
-        end
-
-        def log_target_filters(target_filters)
-          raise "Log target filters must be set at the root" unless @parent.nil?
-
-          @options[:log_target_filters] = target_filters
-        end
-
-        def log_format(target)
-          raise "Log format must be set at the root" unless @parent.nil?
-
-          @options[:log_format] = target.to_s
-        end
-
-        def get(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:get], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def post(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:post], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def put(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:put], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def delete(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:delete], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def patch(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:patch], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def endpoint(route=nil, methods=[], app_proc = nil, nonblocking: false, &blk)
-          raise "You must provide either a block or an explicit handler for the endpoint" if app_proc.nil? && blk.nil?
-
-          app_proc = @controller.method(app_proc).to_proc if app_proc.is_a?(Symbol)
-
-          app_proc ||= blk
-          num_required, keywords = Itsi::Server::TypedHandlers::SourceParser.extract_expr_from_source_location(app_proc)
-          params_schema = keywords[:params]
-
-          if params_schema && num_required > 1
-            raise "Cannot accept multiple required parameters in a single endpoint. A single typed or untyped params argument is supported"
-          end
-          if num_required > 2
-            raise "Cannot accept more than two required parameters in a single endpoint. An can either accept a single request argument, or a request and a params argument (which may be typed or untyped)"
-          end
-          if num_required == 0
-            raise "Cannot accept zero required parameters in a single endpoint. Endpoint must accept a request parameter"
-          end
-
-          accepts_params = !params_schema.nil? || num_required > 1
-
-          if accepts_params
-            app_proc = Itsi::Server::TypedHandlers.handler_for(app_proc, params_schema)
-          end
-
-          if route || http_methods.any?
-            # For endpoints, it's usually assumed trailing slash and non-trailing slash behaviour is the same
-            routes = route == "/" ? ["", "/"] : [route]
-            location(*routes, methods: http_methods) do
-              @middleware[:app] = { preloader: -> { app_proc }, nonblocking: nonblocking }
-            end
-          else
-            app = { preloader: -> { app_proc }, nonblocking: nonblocking }
-            @middleware[:app] = app
-            location("*") do
-              @middleware[:app] = app
-            end
-          end
-        end
-
-        def grpc(*handlers, reflection: true, nonblocking: false, **, &blk)
-          if @middleware[:app] && @middleware[:app][:request_type].to_s != "grpc"
-            raise "App has already been set. You can use only one of `run` and `rackup_file` or `grpc` per location"
-          end
-
-          grpc_reflection(handlers) if reflection
-
-          handlers.each do |handler|
-            location(Regexp.new("#{Regexp.escape(handler.class.service_name)}/(?:#{handler.class.rpc_descs.keys.map(&:to_s).join("|")})")) do
-              @middleware[:app] = { preloader: -> { Itsi::Server::GrpcInterface.for(handler) }, request_type: "grpc", nonblocking: nonblocking }
-              instance_exec(&blk)
-            end
-          end
-        end
-
         def grpc_reflection(handlers)
           @grpc_reflected_services ||= []
           @grpc_reflected_services.concat(handlers)
 
-          location(["grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
-                    "grpc.reflection.v1.ServerReflection/ServerReflectionInfo"]) do
+          location("grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
+                   "grpc.reflection.v1.ServerReflection/ServerReflectionInfo") do
             @middleware[:app] = { preloader: lambda {
               Itsi::Server::GrpcInterface.reflection_for(handlers)
             }, request_type: "grpc" }
           end
         end
 
-        def run(app, sendfile: true, nonblocking: false, path_info: "/")
-          app_args = { preloader: -> { Itsi::Server::RackInterface.for(app) }, sendfile: sendfile, base_path: "^(?<base_path>#{paths_from_parent.gsub(/\.\*\)$/, ')')}).*$", path_info: path_info, nonblocking: nonblocking }
-          base_path =  "^(?<base_path>#{paths_from_parent.gsub(/\.\*\)$/, ')')}).*$"
-          @middleware[:app] = app_args
-          location("*") do
-            @middleware[:app] = app_args
-          end
-        end
-
-        def rackup_file(rackup_file, nonblocking: false, sendfile: true, path_info: "/")
-          raise "Rackup file #{rackup_file} doesn't exist" unless File.exist?(rackup_file)
-          app_args = { preloader: -> { Itsi::Server::RackInterface.for(rackup_file) }, sendfile: sendfile, base_path: "^(?<base_path>#{paths_from_parent.gsub(/\.\*\)$/, ')')}).*$", path_info: path_info, nonblocking: nonblocking }
-          @middleware[:app] = app_args
-          location("*") do
-            @middleware[:app] = app_args
-          end
-        end
-
-        def include(path)
-          code = IO.read("#{path}.rb")
-          instance_eval(code, "#{path}.rb", 1)
-        end
-
-        def reuse_address(reuse_address)
-          raise "reuse_address must be set at the root" unless @parent.nil?
-          @options[:reuse_address] = reuse_address
-        end
-
-        def reuse_port(reuse_port)
-          raise "reuse_port must be set at the root" unless @parent.nil?
-          @options[:reuse_port] = reuse_port
-        end
-
-        def listen_backlog(listen_backlog)
-          raise "listen_backlog must be set at the root" unless @parent.nil?
-          @options[:listen_backlog] = listen_backlog
-        end
-
-        def nodelay(nodelay)
-          raise "nodelay must be set at the root" unless @parent.nil?
-          @options[:nodelay] = nodelay
-        end
-
-        def recv_buffer_size(recv_buffer_size)
-          raise "recv_buffer_size must be set at the root" unless @parent.nil?
-          @options[:recv_buffer_size] = recv_buffer_size
-        end
-
-        def bind(bind_str)
-          raise "Bind must be set at the root" unless @parent.nil?
-
-          @options[:binds] ||= []
-          @options[:binds] << bind_str.to_s
-        end
-
-        def after_fork(&block)
-          raise "After fork must be set at the root" unless @parent.nil?
-
-          @options[:hooks] ||= {}
-          @options[:hooks][:after_fork] = block
-        end
-
-        def before_fork(&block)
-          raise "Before fork must be set at the root" unless @parent.nil?
-
-          @options[:hooks] ||= {}
-          @options[:hooks][:before_fork] = block
-        end
-
-        def after_memory_threshold_reached(&block)
-          raise "Before fork must be set at the root" unless @parent.nil?
-
-          @options[:hooks] ||= {}
-          @options[:hooks][:after_memory_threshold_reached] = block
-        end
-
-        def worker_memory_limit(memory_limit)
-          raise "Worker memory limit must be set at the root" unless @parent.nil?
-
-          @options[:worker_memory_limit] = memory_limit
-        end
-
-        def multithreaded_reactor(multithreaded)
-          raise "Multithreaded reactor must be set at the root" unless @parent.nil?
-
-          @options[:multithreaded_reactor] = !!multithreaded
-        end
-
-        def pin_worker_cores(pin_worker_cores)
-          raise "Pin worker cores must be set at the root" unless @parent.nil?
-
-          @options[:pin_worker_cores] = !!pin_worker_cores
-        end
-
-        def auto_reload_config!
-          if ENV["BUNDLE_BIN_PATH"]
-            watch "Itsi.rb", [%w[bundle exec itsi restart]]
-          else
-            watch "Itsi.rb", [%w[itsi restart]]
-          end
-        end
-
-        def watch(path, commands)
-          raise "Watch be set at the root" unless @parent.nil?
-
-          @options[:notify_watchers] ||= []
-          @options[:notify_watchers] << [path, commands]
-        end
-
-        def fiber_scheduler(klass_name = true)
-          raise "Fiber scheduler must be set at the root" unless @parent.nil?
-
-          klass_name = "Itsi::Scheduler" if klass_name == true
-          @options[:scheduler_class] = klass_name if klass_name
-        end
-
-        def scheduler_threads(threads = 1)
-          raise "Scheduler threads must be set at the root" unless @parent.nil?
-
-          @options[:scheduler_threads] = threads
-        end
-
-        def request_timeout(request_timeout)
-          raise "Request timeout must be set at the root" unless @parent.nil?
-
-          @options[:request_timeout] = request_timeout
-        end
-
-        def preload(preload)
-          raise "Preload must be set at the root" unless @parent.nil?
-
-          @options[:preload] = preload
-        end
-
-        def shutdown_timeout(shutdown_timeout)
-          raise "Shutdown timeout must be set at the root" unless @parent.nil?
-
-          @options[:shutdown_timeout] = shutdown_timeout.to_f
-        end
-
-        def header_read_timeout(header_read_timeout)
-          raise "Header read timeout must be set at the root" unless @parent.nil?
-
-          @options[:header_read_timeout] = header_read_timeout.to_f
-        end
-
-        def stream_body(stream_body)
-          raise "Stream body must be set at the root" unless @parent.nil?
-
-          @options[:stream_body] = !!stream_body
-        end
-
-        def location(*routes, methods: [], protocols: [], hosts: [], ports: [], extensions: [], content_types: [],
-                     accepts: [], &block)
-          build_child = lambda {
-            @children << DSL.new(
-              self,
-              routes: routes,
-              methods: Array(methods) | self.http_methods,
-              protocols: Array(protocols) | self.protocols,
-              hosts: Array(hosts) | self.hosts,
-              ports: Array(ports) | self.ports,
-              extensions: Array(extensions) | self.extensions,
-              content_types: Array(content_types) | self.content_types,
-              accepts: Array(accepts) | self.accepts,
-              controller: @controller,
-              &block
-            )
-          }
-          if @parent.nil?
-            @options[:middleware_loaders] << build_child
-          else
-            build_child[]
-          end
-        end
-
-
-        def allow_list(**args)
-          args[:allowed_patterns] = Array(args[:allowed_patterns]).map do |pattern|
-            if pattern.is_a?(Regexp)
-              pattern.source
-            else
-              pattern
-            end
-          end
-          @middleware[:allow_list] = args
-        end
-
-        def deny_list(**args)
-          args[:denied_patterns] = Array(args[:denied_patterns]).map do |pattern|
-            if pattern.is_a?(Regexp)
-              pattern.source
-            else
-              pattern
-            end
-          end
-          @middleware[:deny_list] = args
-        end
-
-        def controller(controller)
-          @controller = controller
-        end
-
-        def auth_basic(**args)
-          if File.exist?(".itsi-credentials") && !args[:credential_file]
-            args[:credential_file] = ".itsi-credentials"
-          end
-
-          if args[:credential_file] && File.exist?(args[:credential_file])
-            args[:credential_pairs] = Passfile.load(args[:credential_file])
-          end
-
-          @middleware[:auth_basic] = args
-        end
-
-        def redirect(**args)
-          @middleware[:redirect] = args
-        end
-
-        def proxy(**args)
-          @middleware[:proxy] = args
-        end
-
-        def static_response(**args)
-          args[:body] = args[:body].bytes
-          @middleware[:static_response] = args
-        end
-
-        def auth_jwt(**args)
-          @middleware[:auth_jwt] = args
-        end
-
-        def auth_api_key(**args)
-          if args[:valid_keys] && args[:valid_keys].is_a?(Array)
-            args[:valid_keys] = args[:valid_keys].each_with_index.map { |key, index| [index, key] }.to_h
-            args[:key_id_source] = nil
-          end
-
-          if File.exist?(".itsi-credentials") && !args[:credential_file]
-            args[:credential_file] = ".itsi-credentials"
-          end
-
-          if args[:credential_file] && File.exist?(args[:credential_file])
-            args[:valid_keys] = Passfile.load(args[:credential_file])
-          end
-
-          @middleware[:auth_api_key] = args
-        end
-
-        def compress(**args)
-          @middleware[:compression] = args
-        end
-
-        def request_headers(**args)
-          @middleware[:request_headers] = args
-        end
-
-        def max_body(**args)
-          @middleware[:max_body] = args
-        end
-
-        def response_headers(**args)
-          @middleware[:response_headers] = args
-        end
-
-        def rate_limit(**args)
-          @middleware[:rate_limit] = args
-        end
-
-        def cache_control(**args)
-          @middleware[:cache_control] = args
-        end
-
-        def etag(**args)
-          @middleware[:etag] = args
-        end
-
-        def csp(**args)
-          @middleware[:csp] = args
-        end
-
-        def intrusion_protection(**args)
-          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).flatten.map do |pattern|
-            if pattern.is_a?(Regexp)
-              pattern.source
-            else
-              pattern
-            end
-          end
-          @middleware[:intrusion_protection] = args
-        end
-
-        def cors(**args)
-          @middleware[:cors] = args
-        end
-
-        def static_assets(**args)
-          root_dir = args[:root_dir] || "."
-
-          if !File.exist?(root_dir)
-            warn "Warning: static_assets root_dir '#{root_dir}' does not exist!"
-          elsif !File.directory?(root_dir)
-            warn "Warning: static_assets root_dir '#{root_dir}' is not a directory!"
-          end
-
-          args[:relative_path] = true unless args.key?(:relative_path)
-
-          args[:allowed_extensions] ||= []
-
-          if (args[:allowed_extensions].include?("html") || args[:allowed_extensions].include?(:html)) && args[:try_html_extension]
-            args[:allowed_extensions] << ""
-          end
-
-          args[:base_path] = "^(?<base_path>#{paths_from_parent}).*$"
-
-          location("*", extensions: args[:allowed_extensions]) do
-            @middleware[:static_assets] = args
-          end
-        end
-
         def file_server(**args)
-          # Forward to static_assets for implementation
-          puts "Note: file_server is an alias for static_assets"
+          Itsi.log_info "Note: file_server is an alias for static_assets"
           static_assets(**args)
         end
 
@@ -560,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*)(?:\(([^)]*)\))?$/
@@ -603,7 +179,11 @@ module Itsi
 
           chain.each do |n|
             n.middleware.each do |k, v|
-              merged[k] = v
+              merged[k] = if v[:combine]
+                            ([merged[k] || []] + [v]).flatten
+                          else
+                            v
+                          end
             end
           end
           deep_stringify_keys(merged)