brut 0.0.1

data/lib/brut/framework/mcp.rb

@@ -0,0 +1,215 @@
+require_relative "container"
+require_relative "config"
+require_relative "../junk_drawer"
+require_relative "app"
+require "sequel"
+require "semantic_logger"
+require "i18n"
+require "zeitwerk"
+
+# Represents the Brut framework and its behavior for the app that requires it.
+# Essentially, this handles all default configuration and default setup behavior.
+class Brut::Framework::MCP
+  def initialize(app_klass:)
+    @config    = Brut::Framework::Config.new
+    @booted    = false
+    @loader    = Zeitwerk::Loader.new
+    @app_klass = app_klass
+    self.configure!
+  end
+
+  def configure!
+    @config.configure!
+
+    project_root = Brut.container.project_root
+    project_env  = Brut.container.project_env
+
+    SemanticLogger.default_level = Brut.container.log_level
+    semantic_logger_appenders = Brut.container.semantic_logger_appenders
+    if semantic_logger_appenders.kind_of?(Hash)
+      semantic_logger_appenders = [ semantic_logger_appenders ]
+    end
+    if semantic_logger_appenders.length == 0
+      raise "No loggers are set up - something is wrong"
+    end
+    semantic_logger_appenders.each do |appender|
+      SemanticLogger.add_appender(**appender)
+    end
+    SemanticLogger["Brut"].info("Logging set up")
+
+    i18n_locales_path = Brut.container.config_dir / "i18n"
+    locales = Dir[i18n_locales_path / "*"].map { |_|
+      Pathname(_).basename
+    }
+    ::I18n.load_path += Dir[i18n_locales_path / "**/*.rb"]
+    ::I18n.available_locales = locales.map(&:to_s).map(&:to_sym)
+
+    Brut.container.store(
+      "zeitwerk_loader",
+      @loader.class,
+      "Zeitwerk Loader configured for this app",
+      @loader
+    )
+
+    Dir[Brut.container.front_end_src_dir / "*"].each do |dir|
+      if Pathname(dir).directory?
+        @loader.push_dir(dir)
+      end
+    end
+    Dir[Brut.container.back_end_src_dir / "*"].each do |dir|
+      if Pathname(dir).directory?
+        @loader.push_dir(dir)
+      end
+    end
+    @loader.ignore(Brut.container.migrations_dir)
+    @loader.inflector.inflect(
+      "db" => "DB"
+    )
+    if Brut.container.auto_reload_classes?
+      SemanticLogger["Brut"].info("Auto-reloaded configured")
+      @loader.enable_reloading
+    else
+      SemanticLogger["Brut"].info("Classes will not be auto-reloaded")
+    end
+    @loader.setup
+    @app = @app_klass.new
+  end
+
+  # Starts up the internals of Brut and that app so that it can receive requests from
+  # the web server.  This *can* make network connections to establish connectivity
+  # to external resources.
+  def boot!
+    if @booted
+      raise "already booted!"
+    end
+    if Brut.container.debug_zeitwerk?
+      @loader.log!
+    end
+    Kernel.at_exit do
+      begin
+      Brut.container.sequel_db_handle.disconnect
+      rescue Sequel::DatabaseConnectionError
+        SemanticLogger["Sequel::Database"].info "Not connected to database, so not disconnecting"
+      end
+    end
+
+    Sequel::Database.extension :pg_array
+    Sequel::Database.extension :brut_instrumentation
+
+    sequel_db = Brut.container.sequel_db_handle
+
+    Sequel::Model.db = sequel_db
+
+
+    Sequel::Model.plugin :find_bang
+    Sequel::Model.plugin :created_at
+
+    if !Brut.container.external_id_prefix.nil?
+      Sequel::Model.plugin :external_id, global_prefix: Brut.container.external_id_prefix
+    end
+    if Brut.container.eager_load_classes?
+      SemanticLogger["Brut"].info("Eagerly loading app's classes")
+      @loader.eager_load
+    else
+      SemanticLogger["Brut"].info("Lazily loading app's classes")
+    end
+    Brut.container.instrumentation.subscribe do |event:,start:,stop:,exception:|
+      SemanticLogger["Instrumentation"].info("#{event.category}/#{event.subcategory}/#{event.name}: #{start}/#{stop} = #{stop-start}: #{exception&.message} (#{event.details})")
+    end
+    @app.boot!
+
+    require "sinatra/base"
+
+    @sinatra_app = Class.new(Sinatra::Base)
+    @sinatra_app.include(Brut::SinatraHelpers)
+
+    default_middlewares = [
+      [ Rack::Protection::AuthenticityToken, [ { allow_if: ->(env) { env["PATH_INFO"] =~ /^\/__brut\// } } ] ],
+    ]
+    if Brut.container.auto_reload_classes?
+      default_middlewares << Brut::FrontEnd::Middlewares::ReloadApp
+    end
+
+    middlewares = default_middlewares + @app.class.middleware
+
+    middlewares.each do |(middleware,args,block)|
+      @sinatra_app.use(middleware,*args,&block)
+    end
+    befores = [
+      Brut::FrontEnd::RouteHooks::SetupRequestContext,
+      Brut::FrontEnd::RouteHooks::LocaleDetection,
+    ] + @app.class.before
+
+    afters = [
+      Brut::FrontEnd::RouteHooks::AgeFlash,
+      Brut.container.csp_class,
+      Brut.container.csp_reporting_class,
+    ].compact + @app.class.after
+
+    [
+      [ befores, :before ],
+      [ afters,  :after  ],
+    ].each do |hooks,method|
+      hooks.each do |klass_name|
+        klass = klass_name.to_s.split(/::/).reduce(Module) { |mod,part|
+          mod.const_get(part)
+        }
+        hook_method = klass.instance_method(method)
+        @sinatra_app.send(method) do
+          args = {}
+
+          hook_method.parameters.each do |(type,name)|
+            if name.to_s == "**" || name.to_s == "*"
+              raise ArgumentError,"#{method.class}##{method.name} accepts '#{name}' and not keyword args. Define it in your class to accept the keyword arguments your method needs"
+            end
+            if ![ :key,:keyreq ].include?(type)
+              raise ArgumentError,"#{name} is not a keyword arg, but is a #{type}"
+            end
+
+            if name == :request_context
+              args[name] = Thread.current.thread_variable_get(:request_context)
+            elsif name == :app_session
+              args[name] = Brut.container.session_class.new(rack_session: session)
+            elsif name == :request
+              args[name] = request
+            elsif name == :response
+              args[name] = response
+            elsif name == :env
+              args[name] = env
+            elsif type == :keyreq
+              raise ArgumentError,"#{method} argument '#{name}' is required, but it's not available in a #{method} hook"
+            else
+              # this keyword arg has a default value which will be used
+            end
+          end
+
+          hook = klass.new
+          result = hook.send(method,**args)
+          case result
+          in URI => uri
+            redirect to(uri.to_s)
+          in Brut::FrontEnd::HttpStatus => http_status
+            halt http_status.to_i
+          in FalseClass
+            halt 500
+          in NilClass
+            nil
+          in TrueClass
+            nil
+          else
+            raise NoMatchingPatternError, "Result from #{method} hook #{klass}'s #{method} method was a #{result.class} (#{result.to_s} as a string), which cannot be used to understand the response to generate. Return nil or true if processing should proceed"
+          end
+        end
+      end
+    end
+    @app.class.routes.each do |route_block|
+      @sinatra_app.instance_eval(&route_block)
+    end
+
+    @booted = true
+  end
+  def sinatra_app = @sinatra_app
+  def app = @app
+
+
+end

data/lib/brut/framework/project_environment.rb

@@ -0,0 +1,18 @@
+class Brut::Framework::ProjectEnvironment
+  def initialize(string_value)
+    @value = case string_value
+    when "development" then "development"
+    when "test"        then "test"
+    when "production"  then "production"
+    else
+      raise ArgumentError.new("'#{string_value}' is not a valid project environment")
+    end
+  end
+
+  def development? = @value == "development"
+  def test?        = @value == "test"
+  def production?  = @value == "production"
+
+  def to_s = @value
+end
+

data/lib/brut/framework.rb

@@ -0,0 +1,13 @@
+module Brut
+  module Framework
+    autoload(:App,"brut/framework/app")
+    autoload(:Config,"brut/framework/config")
+    autoload(:Container,"brut/framework/container")
+    autoload(:MCP,"brut/framework/mcp")
+    autoload(:ProjectEnvironment,"brut/framework/project_environment")
+    autoload(:Error,"brut/framework/errors")
+    autoload(:Errors,"brut/framework/errors")
+    autoload(:FussyTypeEnforcement,"brut/framework/fussy_type_enforcement")
+  end
+end
+require_relative "framework/mcp"

data/lib/brut/front_end/asset_metadata.rb

@@ -0,0 +1,76 @@
+
+class Brut::FrontEnd::AssetMetadata
+  def initialize(asset_metadata_file:,out:$stdout)
+    @asset_metadata_file = asset_metadata_file
+    @out = out
+    @asset_metadata = nil
+  end
+
+  def merge!(extension:,esbuild_metafile:)
+    @out.puts "Parsing metafile '#{esbuild_metafile}'"
+    esbuild_metafile = ESBuildMetafile.new(metafile:esbuild_metafile)
+    metadata = esbuild_metafile.parse(extension:)
+    begin
+      self.load!
+    rescue Errno::ENOENT
+      @out.puts "'#{@asset_metadata_file}' does not exist - creating it"
+      @asset_metadata = {}
+    end
+    existing_metadata = @asset_metadata[extension] || {}
+    @asset_metadata[extension] = existing_metadata.merge(metadata)
+  end
+
+  def load!
+    metadata = JSON.parse(File.read(@asset_metadata_file))
+    if !metadata.key?("asset_metadata")
+      raise "Asset metadata file '#{@asset_metadata_file}' is corrupted. There is no top-level 'asset_metadata' key"
+    end
+    @asset_metadata = metadata["asset_metadata"]
+  end
+
+  def resolve(path)
+    extension = File.extname(path)
+    @asset_metadata ||= {}
+    if @asset_metadata[extension]
+      if @asset_metadata[extension][path]
+        @asset_metadata[extension][path]
+      else
+        raise "Asset metadata does not have a mapping for '#{path}'"
+      end
+    else
+      raise "Asset metadata has not been set up for files with extension '#{extension}'"
+    end
+  end
+
+  def save!
+    @out.puts "Writing updated asset metadata file '#{@asset_metadata_file}'"
+    File.open(@asset_metadata_file,"w") do |file|
+      file.puts({ "asset_metadata" => @asset_metadata }.to_json)
+    end
+  end
+
+  class ESBuildMetafile
+    def initialize(metafile:)
+      @metafile = metafile
+    end
+
+    def parse(extension:)
+      metafile_contents = JSON.parse(File.read(@metafile))
+
+      name_with_hash_regexp = /app\/public\/(?<path>.+)\/(?<name>.+)\-(?<hash>.+)#{Regexp.escape(extension)}/
+      metadata = metafile_contents["outputs"].keys.map { |key|
+        match_data = key.match(name_with_hash_regexp)
+        if match_data
+          path = match_data[:path]
+          name = match_data[:name]
+          hash = match_data[:hash]
+
+          [ "/#{path}/#{name}#{extension}", "/#{path}/#{name}-#{hash}#{extension}" ]
+        else
+          nil
+        end
+      }.compact.to_h
+    end
+  end
+
+end

data/lib/brut/front_end/component.rb

@@ -0,0 +1,213 @@
+require "json"
+require "rexml"
+require_relative "template"
+
+module Brut::FrontEnd::Components
+  autoload(:FormTag,"brut/front_end/components/form_tag")
+  autoload(:Input,"brut/front_end/components/input")
+  autoload(:Inputs,"brut/front_end/components/input")
+  autoload(:I18nTranslations,"brut/front_end/components/i18n_translations")
+  autoload(:Timestamp,"brut/front_end/components/timestamp")
+  autoload(:PageIdentifier,"brut/front_end/components/page_identifier")
+  autoload(:LocaleDetection,"brut/front_end/components/locale_detection")
+end
+# A Component is the top level class for managing the rendering of 
+# content.  A component is essentially an ERB template and a class whose
+# instance servces as it's binding.
+#
+# The component has a few more smarts and helpers.
+class Brut::FrontEnd::Component
+  using Brut::FrontEnd::Templates::HTMLSafeString::Refinement
+
+  class TemplateLocator
+    def initialize(paths:, extension:)
+      @paths     = Array(paths).map { |path| Pathname(path) }
+      @extension = extension
+    end
+
+    def locate(base_name)
+      paths_to_try = @paths.map { |path|
+        path / "#{base_name}.#{@extension}"
+      }
+      paths_found = paths_to_try.select { |path|
+        path.exist?
+      }
+      if paths_found.empty?
+        raise "Could not locate template for #{base_name}. Tried: #{paths_to_try.map(&:to_s).join(', ')}"
+      end
+      if paths_found.length > 1
+        raise "Found more than one valid pat for #{base_name}.  You must rename your files to disambiguate them. These paths were all found: #{paths_found.map(&:to_s).join(', ')}"
+      end
+      return paths_found[0]
+    end
+  end
+
+  class AssetPathResolver
+    def initialize(metadata_file:)
+      @metadata_file = metadata_file
+      reload
+    end
+
+    def reload
+      @asset_metadata = Brut::FrontEnd::AssetMetadata.new(asset_metadata_file: @metadata_file)
+      @asset_metadata.load!
+    end
+
+    def resolve(path)
+      @asset_metadata.resolve(path)
+    end
+  end
+
+  attr_writer :yielded_block
+
+  def render_yielded_block
+    if @yielded_block
+      @yielded_block.().html_safe!
+    else
+      raise Brut::FrontEnd::Errors::Bug, "No block was yielded to #{self.class.name}"
+		end
+	end
+
+  # The core method of a component. This is expected to return
+  # a string to be sent as a response to an HTTP request.
+  #
+  # This implementation uses the associated template for the component
+  # and sends it through ERB using this component as
+  # the binding.
+  def render
+    Brut.container.component_locator.locate(self.template_name).
+      then { |erb_file| Brut::FrontEnd::Template.new(erb_file) }.
+      then { |template| template.render_template(self).html_safe! }
+  end
+
+  def page_name
+    @page_name ||= begin
+                     page = self.class.name.split(/::/).reduce(Module) { |accumulator,class_path_part|
+                       if accumulator.ancestors.include?(Brut::FrontEnd::Page)
+                         accumulator
+                       else
+                         accumulator.const_get(class_path_part)
+                       end
+                     }
+                     if page.ancestors.include?(Brut::FrontEnd::Page)
+                       page.name
+                     else
+                       raise "#{self.class} is not nested inside a page, so #page_name should not have been called"
+                     end
+                   end
+  end
+
+  def self.component_name = self.name
+  def component_name = self.class.component_name
+
+  # Helper methods that subclasses can use.
+  # This is a separate module to distinguish the public
+  # interface of this class (`render`) from these helper methods
+  # that are useful to subclasses and their templates.
+  #
+  # This is not intended to be extracted or used outside this class!
+  module Helpers
+
+    # Render a component. This is the primary way in which
+    # view re-use happens.  The component instance will be able to locate its
+    # HTML template and render itself.
+    def component(component_instance,&block)
+      if component_instance.kind_of?(Class)
+        if !component_instance.ancestors.include?(Brut::FrontEnd::Component)
+          raise ArgumentError,"#{component_instance} is not a component and cannot be created"
+        end
+        Thread.current.thread_variable_get(:request_context).
+          then { |request_context| request_context.as_constructor_args(component_instance,request_params: nil)
+        }.then { |constructor_args| component_instance.new(**constructor_args)
+        } => component_instance
+      end
+      if !block.nil?
+        component_instance.yielded_block = block
+      end
+      request_context = Thread.current.thread_variable_get(:request_context).
+        then { |request_context| request_context.as_method_args(component_instance,:render,request_params: nil, form: nil)
+      }.then { |render_args| component_instance.render(**render_args).html_safe!
+      }
+    end
+
+    # Inline an SVG into the page.
+    def svg(svg)
+      Brut.container.svg_locator.locate(svg).then { |svg_file|
+        File.read(svg_file).html_safe!
+      }
+    end
+
+    # Given a public path to an asset—the value you'd use in HTML—return
+    # the same value, but with any content hashes that are part of the filename.
+    def asset_path(path) = Brut.container.asset_path_resolver.resolve(path)
+
+    # Render a form that should include CSRF protection.
+    def form_tag(**attributes,&block)
+      component(Brut::FrontEnd::Components::FormTag.new(**attributes,&block))
+    end
+
+    def timestamp(timestamp, **component_options)
+      component(Brut::FrontEnd::Components::Timestamp.new(**(component_options.merge(timestamp:))))
+    end
+
+    def html_safe!(string)
+      string.html_safe!
+    end
+
+    VOID_ELEMENTS = [
+      :area,
+      :base,
+      :br,
+      :col,
+      :embed,
+      :hr,
+      :img,
+      :input,
+      :link,
+      :meta,
+      :source,
+      :track,
+      :wbr,
+    ]
+
+    def html_tag(tag_name, **html_attributes, &block)
+      tag_name = tag_name.to_s.downcase.to_sym
+      attributes_string = html_attributes.map { |key,value|
+        [
+          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
+          value
+        ]
+      }.select { |key,value|
+        !value.nil?
+      }.map { |key,value|
+        if value == true
+          key
+        elsif value == false
+          ""
+        else
+          REXML::Attribute.new(key,value).to_string
+        end
+      }.join(" ")
+      contents = (block.nil? ? nil : block.()).to_s
+      if VOID_ELEMENTS.include?(tag_name)
+        if !contents.empty?
+          raise ArgumentError,"#{tag_name} may not have child nodes"
+        end
+        html_safe!(%{<#{tag_name} #{attributes_string}>})
+      else
+        html_safe!(%{<#{tag_name} #{attributes_string}>#{contents}</#{tag_name}>})
+      end
+    end
+  end
+  include Helpers
+  include Brut::I18n::ForHTML
+
+private
+
+  def binding_scope = binding
+
+  # Determines the canonical name/location of the template used for this
+  # component.  It does this base do the class name. CameCase is converted
+  # to snake_case. 
+  def template_name = RichString.new(self.class.name).underscorized.to_s.gsub(/^components\//,"")
+end

data/lib/brut/front_end/components/form_tag.rb

@@ -0,0 +1,71 @@
+require "rexml"
+# Represents a <form> HTML component
+class Brut::FrontEnd::Components::FormTag < Brut::FrontEnd::Component
+  def initialize(**attributes,&contents)
+    form_class = attributes.delete(:for)
+    if !form_class.nil?
+      if attributes[:action]
+        raise ArgumentError, "You cannot specify both for: (#{form_class}) and and action: (#{attributes[:action]}) to a form_tag"
+      end
+      if attributes[:method]
+        raise ArgumentError, "You cannot specify both for: (#{form_class}) and and method: (#{attributes[:method]}) to a form_tag"
+      end
+      route = Brut.container.routing.route(form_class)
+      attributes[:method] = route.http_method
+      attributes[:action] = route.path
+    end
+
+    @include_csrf_token = true
+    @csrf_token_omit_reasoning = nil
+
+    http_method = Brut::FrontEnd::HttpMethod.new(attributes[:method])
+
+    if http_method.get?
+      if attributes.key?(:no_csrf_token)
+        raise ArgumentError,":no_csrf_token is not allowed for form_tag when the HTTP method is a GET"
+      end
+      force_csrf_token = attributes.delete(:force_csrf_token)
+      if !force_csrf_token
+        @include_csrf_token = false
+        @csrf_token_omit_reasoning = "because this form's action is GET"
+      end
+    else
+      if attributes.key?(:force_csrf_token)
+        raise ArgumentError,":force_csrf_token is not allowed for form_tag when the HTTP method is not a GET"
+      end
+      no_csrf_token = attributes.delete(:no_csrf_token)
+      if no_csrf_token
+        @include_csrf_token = false
+        @csrf_token_omit_reasoning = "because :no_csrf_token was passed to form_tag"
+      end
+    end
+    @attributes = attributes
+    @contents = contents
+  end
+
+  def render
+    attribute_string = @attributes.map { |key,value|
+      key = key.to_s
+      if value == true
+        key
+      elsif value == false
+        ""
+      else
+        REXML::Attribute.new(key,value).to_string
+      end
+    }.join(" ")
+    csrf_token_component = if @include_csrf_token
+                             component(Brut::FrontEnd::Components::Inputs::CsrfToken)
+                           elsif Brut.container.project_env.development?
+                             html_safe!("<!-- CSRF Token omitted #{@csrf_token_omit_reasoning} (this message only appears in development) -->")
+                           else
+                             ""
+                           end
+    %{
+      <form #{attribute_string}>
+        #{ csrf_token_component }
+        #{ @contents.() }
+      </form>
+    }
+  end
+end

data/lib/brut/front_end/components/i18n_translations.rb

@@ -0,0 +1,36 @@
+require "rexml"
+
+# Produces `<brut-i18n-translation>` entries for the given values
+class Brut::FrontEnd::Components::I18nTranslations < Brut::FrontEnd::Component
+  def initialize(i18n_key_root)
+    @i18n_key_root = i18n_key_root
+  end
+
+  def render
+    values = ::I18n.t(@i18n_key_root)
+    if values.kind_of?(String)
+      values = { "" => values }
+    end
+
+    values.map { |key,value|
+      if !value.kind_of?(String)
+        raise "Key #{key} under #{@i18n_key_root} maps to a #{value.class} instead of a String. For #{self.class} to work, the value must be a String"
+      end
+      i18n_key = if key == ""
+                   @i18n_key_root
+                 else
+                   "#{@i18n_key_root}.#{key}"
+                 end
+      attributes = [
+        REXML::Attribute.new("key",i18n_key),
+        REXML::Attribute.new("value",value.to_s),
+      ]
+      if !Brut.container.project_env.production?
+        attributes << REXML::Attribute.new("show-warnings",true)
+        attributes << REXML::Attribute.new("id","brut-18n-#{key}")
+      end
+      attribute_string = attributes.map(&:to_string).join(" ")
+      %{<brut-i18n-translation #{attribute_string}></brut-i18n-translation>}
+    }.join("\n")
+  end
+end

data/lib/brut/front_end/components/input.rb

@@ -0,0 +1,13 @@
+require "rexml"
+module Brut::FrontEnd::Components
+
+  module Inputs
+    autoload(:TextField,"brut/front_end/components/inputs/text_field")
+    autoload(:Select,"brut/front_end/components/inputs/select")
+    autoload(:Textarea,"brut/front_end/components/inputs/textarea")
+    autoload(:CsrfToken,"brut/front_end/components/inputs/csrf_token")
+  end
+
+  class Input < Brut::FrontEnd::Component
+  end
+end

data/lib/brut/front_end/components/inputs/csrf_token.rb

@@ -0,0 +1,8 @@
+class Brut::FrontEnd::Components::Inputs::CsrfToken < Brut::FrontEnd::Components::Input
+  def initialize(csrf_token:)
+    @csrf_token = csrf_token
+  end
+  def render
+    html_tag(:input, type: "hidden", name: "authenticity_token", value: @csrf_token)
+  end
+end