brut 0.0.1

data/lib/brut/front_end/routing.rb

@@ -0,0 +1,236 @@
+require "uri"
+
+# Holds the registered routes for this app.
+class Brut::FrontEnd::Routing
+
+  include SemanticLogger::Loggable
+
+  def initialize
+    @routes = Set.new
+  end
+
+  def for(path:,method:)
+    http_method = Brut::FrontEnd::HttpMethod.new(method)
+    @routes.detect { |route|
+      route.path_template == path &&
+        route.http_method == http_method
+    }
+  end
+
+  def reload
+    new_routes = @routes.map { |route|
+      if route.class == Route
+        route.class.new(route.http_method,route.path_template)
+      else
+        route.class.new(route.path_template)
+      end
+    }
+    @routes = Set.new(new_routes)
+    @routes.each do |route|
+      handler_class = route.handler_class
+      if handler_class.name !~ /^Brut::[A-Z]/
+        add_routing_method(route)
+      end
+    end
+  end
+
+  def register_page(path)
+    route = PageRoute.new(path)
+    @routes << route
+    add_routing_method(route)
+    route
+  end
+
+  def register_form(path)
+    route = FormRoute.new(path)
+    @routes << route
+    add_routing_method(route)
+    route
+  end
+
+  def register_handler_only(path)
+    route = FormHandlerRoute.new(path)
+    @routes << route
+    add_routing_method(route)
+    route
+  end
+
+  def register_path(path, method:)
+    route = Route.new(method, path)
+    @routes << route
+    add_routing_method(route)
+    route
+  end
+
+  def route(handler_class)
+    route = @routes.detect { |route|
+      handler_class_match = route.handler_class.name == handler_class.name
+      form_class_match = if route.respond_to?(:form_class)
+                           route.form_class.name == handler_class.name
+                         else
+                           false
+                         end
+      handler_class_match || form_class_match
+    }
+    if !route
+      raise ArgumentError,"There is no configured route for #{handler_class}"
+    end
+    route
+  end
+
+  def uri(handler_class, with_method: :any, **rest)
+    route = self.route(handler_class)
+    route_allowed_for_method = if with_method == :any
+                                 true
+                               elsif Brut::FrontEnd::HttpMethod.new(with_method) == route.http_method
+                                 true
+                               else
+                                 false
+                               end
+    if !route_allowed_for_method
+      raise ArgumentError,"The route for '#{handler_class}' (#{route.path}) is not supported by HTTP method '#{with_method}'"
+    end
+    route.path(**rest)
+  end
+
+  def inspect
+    @routes.map { |route|
+      "#{route.http_method}:#{route.path_template} - #{route.handler_class.name}"
+    }.join("\n")
+  end
+
+  def add_routing_method(route)
+    handler_class = route.handler_class
+    if handler_class.respond_to?(:routing) && handler_class.method(:routing).owner != Brut::FrontEnd::Form
+      raise ArgumentError,"#{handler_class} (that handles path #{route.path_template}) got it's ::routing method from #{handler_class.method(:routing).owner}, meaning it has overridden the value fro Brut::FrontEnd::Form"
+    end
+    form_class = route.respond_to?(:form_class) ? route.form_class : nil
+    [ handler_class, form_class ].compact.each do |klass|
+      klass.class_eval do
+        def self.routing(**args)
+          Brut.container.routing.uri(self,**args)
+        end
+      end
+    end
+  end
+
+  class Route
+
+    include SemanticLogger::Loggable
+
+    attr_reader :handler_class, :path_template, :http_method
+
+    def initialize(method,path_template)
+      http_method = Brut::FrontEnd::HttpMethod.new(method)
+      if ![:get, :post].include?(http_method.to_sym)
+        raise ArgumentError,"Only GET and POST are supported. '#{method}' is not"
+      end
+      if path_template !~ /^\//
+        raise ArgumentError,"Routes must start with a slash: '#{path_template}'"
+      end
+      @http_method   = http_method
+      @path_template = path_template
+      @handler_class = self.locate_handler_class(self.suffix,self.preposition)
+    end
+
+    def path(**query_string_params)
+      path = @path_template.split(/\//).map { |path_part|
+        if path_part =~ /^:(.+)$/
+          param_name = $1.to_sym
+          if !query_string_params.key?(param_name)
+            query_string_params_for_message = if query_string_params.keys.any?
+                                                query_string_params.keys.map(&:to_s).join(", ")
+                                              else
+                                                "no params"
+                                              end
+            raise ArgumentError,"path for #{@handler_class} requires '#{param_name}' as a path parameter, but it was not specified to #path. Got #{query_string_params_for_message}"
+          end
+          query_string_params.delete(param_name)
+        else
+          path_part
+        end
+      }
+      uri = URI(path.join("/"))
+      uri.query = URI.encode_www_form(query_string_params)
+      uri
+    end
+
+    def ==(other)
+      self.method == other.method && self.path == other.path
+    end
+
+  private
+    def locate_handler_class(suffix,preposition, on_missing: :raise)
+      if @path_template == "/"
+        return Module.const_get("HomePage")
+      end
+      path_parts = @path_template.split(/\//)[1..-1]
+
+      part_names = path_parts.reduce([]) { |array,path_part|
+        if path_part =~ /^:(.+)$/
+          if array.empty?
+            raise ArgumentError,"Your path may not start with a placeholder: '#{@path_template}'"
+          end
+          placeholder_camelized = RichString.new($1).camelize
+          array[-1] << preposition
+          array[-1] << placeholder_camelized.to_s
+        elsif array.empty? && path_part == "__brut"
+          array << "Brut"
+          array << "FrontEnd"
+          array << "Handlers"
+        else
+          array << RichString.new(path_part).camelize.to_s
+        end
+        array
+      }
+      part_names[-1] += suffix
+      part_names.inject(Module) { |mod,path_element|
+        mod.const_get(path_element,mod == Module)
+      }
+    rescue NameError => ex
+      if on_missing == :raise
+        module_message = if ex.receiver == Module
+                           "Could not find"
+                         else
+                           "Module '#{ex.receiver}' did not have"
+                         end
+        message = "Cannot find page class for route '#{@path_template}', which should be #{part_names.join("::")}. #{module_message} the class or module '#{ex.name}'"
+        raise message
+      else
+        nil
+      end
+    end
+
+    def suffix = "Handler"
+    def preposition = "With"
+
+  end
+
+  class PageRoute < Route
+    def initialize(path_template)
+      super(Brut::FrontEnd::HttpMethod.new(:get),path_template)
+    end
+    def suffix = "Page"
+    def preposition = "By"
+  end
+
+  class FormRoute < Route
+    attr_reader :form_class
+    def initialize(path_template)
+      super(Brut::FrontEnd::HttpMethod.new(:post),path_template)
+      @form_class = self.locate_handler_class("Form","With")
+    end
+  end
+
+  class FormHandlerRoute < Route
+    def initialize(path_template)
+      super(Brut::FrontEnd::HttpMethod.new(:post),path_template)
+      unnecessary_class = self.locate_handler_class("Form","With", on_missing: nil)
+      if !unnecessary_class.nil?
+        raise ArgumentError,"#{path_template} should only have #{handler_class} defined, however #{unnecessary_class} was found. If #{path_template} should be a form submission, use `form \"#{path_template}\"` instead of `action \"#{path_template}\"`. Otherwise, delete #{unnecessary_class}"
+      end
+    end
+  end
+
+end
+

data/lib/brut/front_end/session.rb

@@ -0,0 +1,56 @@
+# A class that represents the current session, as opposed to just a Hash.
+# Generally, this can act like a Hash for setting and accessing values stored in the session.
+# It provides a few useful additions:
+#
+# * Your app can extend this to provide an app-specific API around the session.
+# * There is direct access to commonly-used data stored in the session, such as the flash.
+class Brut::FrontEnd::Session
+  def initialize(rack_session:)
+    @rack_session = rack_session
+  end
+
+  def http_accept_language = Brut::I18n::HTTPAcceptLanguage.from_session(self[:__brut_http_accept_language])
+  def http_accept_language=(http_accept_language)
+    self[:__brut_http_accept_language] = http_accept_language.for_session
+  end
+
+  # Get the timezone as reported by the browser, as a TZInfo::Timezone.
+  # If none is available or the browser reported an invalid value, this returns nil.
+  def timezone_from_browser
+    tz_name = self[:__brut_timezone_from_browser]
+    if tz_name.nil?
+      return nil
+    end
+    begin
+      TZInfo::Timezone.get(tz_name)
+    rescue TZInfo::InvalidTimezoneIdentifier => ex
+      SemanticLogger[self.class.name].warn(ex)
+      nil
+    end
+  end
+
+  # Set the timezone as reported by the browser. This alleviates the need to keep
+  # asking the browser for this information.
+  def timezone_from_browser=(timezone)
+    if timezone.kind_of?(TZInfo::Timezone)
+      timezone = timezone.name
+    end
+    self[:__brut_timezone_from_browser] = timezone
+  end
+
+  def[](key) = @rack_session[key.to_s]
+
+  def[]=(key,value)
+    @rack_session[key.to_s] = value
+  end
+
+  def delete(key) = @rack_session.delete(key.to_s)
+
+  # Access the flash, as an instance of whatever class has been configured.
+  def flash
+    Brut.container.flash_class.from_h(self[:__brut_flash])
+  end
+  def flash=(new_flash)
+    self[:__brut_flash] = new_flash.to_h
+  end
+end

data/lib/brut/front_end/template.rb

@@ -0,0 +1,32 @@
+require "temple"
+
+module Brut::FrontEnd::Templates
+  autoload(:HTMLSafeString,"brut/front_end/templates/html_safe_string")
+  autoload(:ERBParser,"brut/front_end/templates/erb_parser")
+  autoload(:EscapableFilter,"brut/front_end/templates/escapable_filter")
+  autoload(:BlockFilter,"brut/front_end/templates/block_filter")
+  autoload(:ERBEngine,"brut/front_end/templates/erb_engine")
+end
+
+# Handles rendering HTML templates
+class Brut::FrontEnd::Template
+
+  TempleTemplate = Temple::Templates::Tilt(Brut::FrontEnd::Templates::ERBEngine,
+                                           register_as: "html.erb")
+
+  # Wraps a string that is deemed safe to insert into
+  # HTML without escaping it.  This allows stuff like
+  # <%= component(SomeComponent) %> to work without
+  # having to remember to <%== all the time.
+  def initialize(template_file_path)
+    @tilt_template = Tilt.new(template_file_path)
+  end
+
+  def render_template(...)
+    @tilt_template.render(...)
+  end
+
+  def self.escape_html(string)
+    Brut::FrontEnd::Templates::EscapableFilter.escape_html(string)
+  end
+end

data/lib/brut/front_end/templates/block_filter.rb

@@ -0,0 +1,60 @@
+# This is a slightly modified copy if Hanamis' Filters::Block:
+#
+# https://github.com/hanami/view/blob/main/lib/hanami/view/erb/filters/block.rb
+#
+class Brut::FrontEnd::Templates::BlockFilter < Temple::Filter
+  END_LINE_RE = /\bend\b/
+
+  def on_erb_block(escape, code, content)
+    tmp = unique_name
+
+    # Remove the last `end` :code sexp, since this is technically "outside" the block
+    # contents, which we want to capture separately below. This `end` is added back after
+    # capturing the content below.
+    case content.last
+    in [:code, c] if c =~ END_LINE_RE
+      content.pop
+    end
+
+    [:multi,
+     # Capture the result of the code in a variable. We can't do `[:dynamic, code]` because
+     # it's probably not a complete expression (which is a requirement for Temple).
+     # DBC: an example is that 'code' might be "form_for do" which is not an expression.
+     #      Because we later put an "end" in, the result will be
+     #
+     #      some_var = helper do
+     #      end
+     #
+     #      Which IS valid Ruby.
+     [:code, "#{tmp} = #{code}"],
+     # Capture the content of a block in a separate buffer. This means that `yield` will
+     # not output the content to the current buffer, but rather return the output.
+     [:capture, unique_name, compile(content)],
+     [:code, "end"],
+     # Output the content, without escaping it.
+     # Hanami has this ↴
+     # [:escape, escape, [:dynamic, tmp]]
+     [:escape, escape, [:dynamic, Brut::FrontEnd::Templates.name + "::HTMLSafeString.new(#{tmp})"]]
+    ]
+
+    # Details explaining the change:
+    #
+    # The sexps for template are quite convoluted and highly dynamic, so it is hard
+    # to understand exactly what effect they will have.  Basically, what this [:multi thing is
+    # doing is to capture the result of the block in a variable:
+    #
+    # some_var = form_for(args) do
+    #
+    # It then captures the inside of the block in a new variable:
+    #
+    # some_other_var = «whatever was inside that `do`»
+    #
+    # And follows it with an end.
+    #
+    # The first variable—some_var—now holds the return value of the helper, form_for in this case. To
+    # output this content to the actual view, it must be dereferenced, thus [ :dynamic, "some_var" ].
+    #
+    # We are going to treat the return value of the block helper as HTML safe.  Thus, we'll wrap it
+    # with HTMLSafeString.new(…).
+  end
+end

data/lib/brut/front_end/templates/erb_engine.rb

@@ -0,0 +1,26 @@
+# A temple "engine" that can be used to parse ERB and generate HTML
+# in just the way we need.
+class Brut::FrontEnd::Templates::ERBEngine < Temple::Engine
+  # Parse the ERB into sexps
+  use Brut::FrontEnd::Templates::ERBParser
+
+  # Handle block syntax used in a <%= 
+  use Brut::FrontEnd::Templates::BlockFilter
+
+  # Trim whitespace like ERB does
+  use Temple::ERB::Trimming
+
+  # Escape strings only if they are not HTMLSafeString
+  use Brut::FrontEnd::Templates::EscapableFilter
+  # This filter actually runs the Ruby code
+  use Temple::Filters::StaticAnalyzer
+  # Flattens nested :multi expressions which I'm not sure is needed, but
+  # have cargo-culted from hanami
+  use Temple::Filters::MultiFlattener
+  # merges sequential :static, which again, not sure is needed, but
+  # have cargo-culted from hanami
+  use Temple::Filters::StaticMerger
+
+  # This generates everything into a string
+  use Temple::Generators::ArrayBuffer
+end

data/lib/brut/front_end/templates/erb_parser.rb

@@ -0,0 +1,84 @@
+# Almost verbatim copy of Hanami's parser:
+#
+# https://github.com/hanami/view/blob/main/lib/hanami/view/erb/parser.rb
+#
+# That is licensed MIT and thus so is this.
+#
+# Avoid changes to this file so it can be kept updated with Hanami.
+class Brut::FrontEnd::Templates::ERBParser < Temple::Parser
+  ERB_PATTERN = /(\n|<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
+
+  IF_UNLESS_CASE_LINE_RE = /\A\s*(if|unless|case)\b/
+  BLOCK_LINE_RE = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+  END_LINE_RE = /\bend\b/
+
+  def call(input)
+    results = [[:multi]]
+    pos = 0
+
+    input.scan(ERB_PATTERN) do |token, indicator, code|
+      # Capture any text between the last ERB tag and the current one, and update the position
+      # to match the end of the current tag for the next iteration of text collection.
+      text = input[pos...$~.begin(0)]
+      pos  = $~.end(0)
+
+      if token
+        # First, handle certain static tokens picked up by our ERB_PATTERN regexp. These are
+        # newlines as well as the special codes for literal `<%` and `%>` values.
+        case token
+        when "\n"
+          results.last << [:static, "#{text}\n"] << [:newline]
+        when "<%%", "%%>"
+          results.last << [:static, text] unless text.empty?
+          token.slice!(1)
+          results.last << [:static, token]
+        end
+      else
+        # Next, handle actual ERB tags. Start by adding any static text between this match and
+        # the last.
+        results.last << [:static, text] unless text.empty?
+
+        case indicator
+        when "#"
+          # Comment tags: <%# this is a comment %>
+          results.last << [:code, "\n" * code.count("\n")]
+        when %r{=}
+          # Expression tags: <%= "hello (auto-escaped)" %> or <%== "hello (not escaped)" %>
+          if code =~ BLOCK_LINE_RE
+            # See Hanami::View::Erb::Filters::Block for the processing of `:erb, :block` sexps
+            block_node = [:erb, :block, indicator.size == 1, code, (block_content = [:multi])]
+            results.last << block_node
+
+            # For blocks opened in ERB expression tags, push this `[:multi]` sexp
+            # (representing the content of the block) onto the stack of resuts. This allows
+            # subsequent results to be appropriately added inside the block, until its closing
+            # tag is encountered, and this `block_content` multi is subsequently popped off
+            # the results stack.
+            results << block_content
+          else
+            results.last << [:escape, indicator.size == 1, [:dynamic, code]]
+          end
+        else
+          # Code tags: <% if some_cond %>
+          if code =~ BLOCK_LINE_RE || code =~ IF_UNLESS_CASE_LINE_RE
+            results.last << [:code, code]
+
+            # For ERB code tags that will result in a matching `end`, push the last result
+            # back onto the stack of results. This might seem redundant, but it allows
+            # subsequent sexps to continue to be pushed onto the same result while also
+            # allowing it to be safely popped again when the matching `end` is encountered.
+            results << results.last
+          elsif code =~ END_LINE_RE
+            results.last << [:code, code]
+            results.pop
+          else
+            results.last << [:code, code]
+          end
+        end
+      end
+    end
+
+    # Add any text after the final ERB tag
+    results.last << [:static, input[pos..-1]]
+  end
+end

data/lib/brut/front_end/templates/escapable_filter.rb

@@ -0,0 +1,18 @@
+# A temple filter that handles escaping HTML unless it's been wrapped in
+# an HTMLSafeString.
+class Brut::FrontEnd::Templates::EscapableFilter < Temple::Filters::Escapable
+  using Brut::FrontEnd::Templates::HTMLSafeString::Refinement
+
+  def initialize(opts = {})
+    opts[:escape_code] ||= "::Brut::FrontEnd::Templates::EscapableFilter.escape_html((%s))"
+    super(opts)
+  end
+
+  def self.escape_html(html)
+    if html.kind_of?(Brut::FrontEnd::Templates::HTMLSafeString)
+      html.string
+    else
+      Temple::Utils.escape_html(html)
+    end
+  end
+end

data/lib/brut/front_end/templates/html_safe_string.rb

@@ -0,0 +1,40 @@
+# A wrapper around a string to indicate it is HTML-safe and
+# can be rendered directly without escaping.
+class Brut::FrontEnd::Templates::HTMLSafeString
+  module Refinement
+    refine String do
+      def html_safe! = Brut::FrontEnd::Templates::HTMLSafeString.from_string(self)
+      def html_safe? = false
+    end
+  end
+  attr_reader :string
+  def initialize(string)
+    @string = string
+  end
+
+  # Wrap a string in an HTMLSafeString if needed.
+  def self.from_string(string_or_html_safe_string)
+    if string_or_html_safe_string.kind_of?(self)
+      string_or_html_safe_string
+    else
+      self.new(string_or_html_safe_string)
+    end
+  end
+
+  # This must be convertible to a string
+  def to_s       = @string
+  def to_str     = @string
+  def html_safe! = self
+  def html_safe? = true
+  def capitalize = self.class.new(@string.capitalize)
+  def downcase   = self.class.new(@string.downcase)
+  def upcase     = self.class.new(@string.upcase)
+
+  def +(other)
+    if other.html_safe?
+      self.class.new(@string + other.to_s)
+    else
+      @string + other.to_s
+    end
+  end
+end