brut 0.0.1 → 0.0.2

data/lib/brut/framework/app.rb

@@ -1,16 +1,27 @@
-# An "App" in Brut paralance is the collection of source code and configure that is needed to operate
+# An "App" in Brut paralance is the collection of source code and configuration that is needed to operate
 # a website. This includes everything needed to serve HTTP requests, but also includes ancillary
-# tasks and any related files required for the app to exist and function.
+# tasks and any related files required for the app to exist and function.  Your app will have an `App` class that subclasses this
+# class.
+#
+# When your app is initialized, Brut will have been configured, but access to internal resources may not be available.  It is here
+# that you can override configuration values or do any other setup before everything boots.
 class Brut::Framework::App
+  include Brut::Framework::Errors
 
-  # An identifier for this app that can be used as a hostname
-  def id = raise "Subclass must implement"
+  # An identifier for this app that can be used as a hostname. Your app must provide this.
+  def id
+    abstract_method!
+  end
 
   # An identifier for the app's 'organization' that can be used as a hostname.
   # This isn't relevant in all contexts, but is useful for deploys or other
   # actions where an app needs to exist inside some organizational context.
   def organization = id
 
+  # Call this in your app's definition to define your app's routes. The contents of the block will be evaluated in the context of
+  # {Brut::SinatraHelpers::ClassMethods}, and the methods there are generally the ones you should be calling.
+  #
+  # You can call this multiple times and the routes will be concatenated together.
   def self.routes(&block)
     @routes_blocks ||= []
     if block.nil?
@@ -19,6 +30,14 @@ class Brut::Framework::App
       @routes_blocks << block
     end
   end
+
+  # Add a Rack middleware to your app. Middlewares are configured in the order in which you call this method.
+  #
+  # @param [Class] middleware a class that implements [Rack Middleware](https://github.com/rack/rack/blob/main/SPEC.rdoc).
+  # @param [Array] args arguments to be given to the `middleware` class' initializer.
+  # @param [block] block a block that is given to the initializer of the `middleware` class.
+  #
+  # @return [Array] if no parameters are given, returns all the currently-configured middleware.
   def self.middleware(middleware=nil,*args,&block)
     @middlewares ||= []
     if middleware.nil? && args.empty? && block.nil?
@@ -27,6 +46,13 @@ class Brut::Framework::App
       @middlewares << [ middleware, args, block ]
     end
   end
+
+  # Configure a {Brut::FrontEnd::RouteHook} to be called before each request.
+  #
+  # @param [String] klass_name The name of the class that extends {Brut::FrontEnd::RouteHook} and implements #before.  This uses the
+  #                            name (not the class itself) to avoid loading issues.
+  #
+  # @return [Array] If no parameters given, returns all configured before hooks.
   def self.before(klass_name=nil)
     @before ||= []
     if klass_name.nil?
@@ -35,6 +61,13 @@ class Brut::Framework::App
       @before << klass_name
     end
   end
+
+  # Configure a {Brut::FrontEnd::RouteHook} to be called after each request.
+  #
+  # @param [String] klass_name The name of the class that extends {Brut::FrontEnd::RouteHook} and implements #after.  This uses the
+  #                            name (not the class itself) to avoid loading issues.
+  #
+  # @return [Array] If no parameters given, returns all configured after hooks.
   def self.after(klass_name=nil)
     @after ||= []
     if klass_name.nil?
@@ -48,7 +81,7 @@ class Brut::Framework::App
   # code required *after* Brut has been set up and started.  You can rely on the
   # database being available. Any attempts to override configuration values
   # may not succeed.  This is called after the framework has booted, but before
-  # your apps routes are set up.
+  # your apps' routes are set up.
   def boot!
   end
 

data/lib/brut/framework/config.rb

@@ -1,32 +1,12 @@
 require_relative "project_environment"
 require "pathname"
 
-# Exists to hold configuration for the Brut framework.
-# This is a wrapper around a series of calls to Brut.container.store
-# but is a class and thus invokable, so that the configuration can
-# be controlled.
+# Holds configuration for the framework and your app.  In general, you should not interact with this class, however it's source code
+# is a good reference for what is configured by default by Brut.
 class Brut::Framework::Config
 
-  class DockerPathComponent
-    PATH_REGEXP = /\A[a-z0-9]+(-|_)?[a-z0-9]+\z/
-    def initialize(string)
-      if string.to_s.match?(PATH_REGEXP)
-        @string = string
-      else
-        raise ArgumentError.new("Value must be only lower case letters, digits, and may have at most one underscore: '#{string}'")
-      end
-    end
-
-    def to_str = @string
-    def to_s = self.to_str
-  end
-
-  class AppId < DockerPathComponent
-  end
-
-  class AppOrganizationName < DockerPathComponent
-  end
-
+  # Configures all defaults.  In general, this attempts to be lazy in setting things up, so calling this should not attempt to make a
+  # connection to your database.
   def configure!
     Brut.container do |c|
       # Brut Stuff that should not be changed
@@ -110,6 +90,13 @@ class Brut::Framework::Config
         project_root / "specs"
       end
 
+      c.store_ensured_path(
+        "e2e_specs_dir",
+        "Path to the root of all end-to-end tests"
+      ) do |app_specs_dir|
+        app_specs_dir / "e2e"
+      end
+
       c.store_ensured_path(
         "js_specs_dir",
         "Path to root of where all JS-based specs/tests are",
@@ -117,49 +104,56 @@ class Brut::Framework::Config
         app_specs_dir / "front_end" / "js"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "front_end_src_dir",
         "Path to the root of the front end layer for the app"
       ) do |app_src_dir|
         app_src_dir / "front_end"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "components_src_dir",
         "Path to where components classes and templates are stored"
       ) do |front_end_src_dir|
         front_end_src_dir / "components"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "components_specs_dir",
         "Path to where tests of components classes are stored",
       ) do |app_specs_dir|
         app_specs_dir / "front_end" / "components"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "forms_src_dir",
         "Path to where form classes are stored"
       ) do |front_end_src_dir|
         front_end_src_dir / "forms"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "handlers_src_dir",
         "Path to where handlers are stored"
       ) do |front_end_src_dir|
         front_end_src_dir / "handlers"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
+        "handlers_specs_dir",
+        "Path to where tests of handler classes are stored",
+      ) do |app_specs_dir|
+        app_specs_dir / "front_end" / "handlers"
+      end
+
+      c.store_ensured_path(
         "svgs_src_dir",
         "Path to where svgs are stored"
       ) do |front_end_src_dir|
         front_end_src_dir / "svgs"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "images_src_dir",
         "Path to where images are stored"
       ) do |front_end_src_dir|
@@ -194,7 +188,7 @@ class Brut::Framework::Config
         front_end_src_dir / "js"
       end
 
-      c.store_required_path(
+      c.store_ensured_path(
         "back_end_src_dir",
         "Path to the root of the back end layer for the app"
       ) do |app_src_dir|
@@ -229,6 +223,13 @@ class Brut::Framework::Config
         project_root / "app" / "config"
       end
 
+      c.store_ensured_path(
+        "i18n_locales_dir",
+        "Path to where I18N locale files are stored"
+      ) do |config_dir|
+        config_dir / "i18n"
+      end
+
       c.store(
         "asset_metadata_file",
         Pathname,
@@ -240,38 +241,55 @@ class Brut::Framework::Config
 
       c.store(
         "layout_locator",
-        "Brut::FrontEnd::Component::TemplateLocator",
+        "Brut::FrontEnd::Templates::Locator",
         "Object to use to locate templates for layouts"
-      ) do |layouts_src_dir|
-        Brut::FrontEnd::Component::TemplateLocator.new(paths: layouts_src_dir,
-                                                       extension: "html.erb")
+      ) do |layouts_src_dir,project_env,brut_internal_dir|
+        paths = if project_env.development?
+                  [ layouts_src_dir, brut_internal_dir / "lib" / "brut" / "front_end" / "layouts" ]
+                else
+                  layouts_src_dir
+                end
+        Brut::FrontEnd::Templates::Locator.new(paths: paths,
+                                               extension: "html.erb")
+      end
+
+      c.store_required_path(
+        "brut_internal_dir",
+        "Location to where the Brut gem is installed."
+      ) do
+        (Pathname(__FILE__).dirname / ".." / ".." / "..").expand_path
       end
 
       c.store(
         "page_locator",
-        "Brut::FrontEnd::Component::TemplateLocator",
+        "Brut::FrontEnd::Templates::Locator",
         "Object to use to locate templates for pages"
-      ) do |pages_src_dir|
-        Brut::FrontEnd::Component::TemplateLocator.new(paths: pages_src_dir,
-                                                       extension: "html.erb")
+      ) do |pages_src_dir,project_env,brut_internal_dir|
+        paths = if project_env.development?
+                  [ pages_src_dir, brut_internal_dir / "lib" / "brut" / "front_end" / "pages" ]
+                else
+                  pages_src_dir
+                end
+        Brut::FrontEnd::Templates::Locator.new(paths: paths,
+                                               extension: "html.erb")
       end
 
       c.store(
         "component_locator",
-        "Brut::FrontEnd::Component::TemplateLocator",
+        "Brut::FrontEnd::Templates::Locator",
         "Object to use to locate templates for components"
       ) do |components_src_dir, pages_src_dir|
-        Brut::FrontEnd::Component::TemplateLocator.new(paths: [ components_src_dir, pages_src_dir ],
-                                                       extension: "html.erb")
+        Brut::FrontEnd::Templates::Locator.new(paths: [ components_src_dir, pages_src_dir ],
+                                               extension: "html.erb")
       end
 
       c.store(
         "svg_locator",
-        "Brut::FrontEnd::Component::TemplateLocator",
+        "Brut::FrontEnd::Templates::Locator",
         "Object to use to locate SVGs"
       ) do |svgs_src_dir|
-        Brut::FrontEnd::Component::TemplateLocator.new(paths: svgs_src_dir,
-                                                       extension: "svg")
+        Brut::FrontEnd::Templates::Locator.new(paths: svgs_src_dir,
+                                               extension: "svg")
       end
 
       c.store(
@@ -291,15 +309,10 @@ class Brut::Framework::Config
 
       c.store(
         "instrumentation",
-        Brut::Instrumentation::Basic,
+        Brut::Instrumentation::OpenTelemetry,
         "Interface for recording instrumentable events and subscribing to them",
-      ) do |project_env|
-        if project_env.production?
-          Brut::Instrumentation::Basic.new
-        else
-          Brut::Instrumentation::Basic::TypeChecking.new
-        end
-      end
+        Brut::Instrumentation::OpenTelemetry.new
+      )
 
       # App can override
 
@@ -410,6 +423,36 @@ class Brut::Framework::Config
         allow_app_override: true,
         allow_nil: true,
       )
+
+      c.store(
+        "local_hostname",
+        String,
+        "If present, this is an additional host on which your app responds locally. Useful if you have local domain names set up for dev",
+        nil,
+        allow_app_override: true,
+        allow_nil: true
+      )
+
+
+      c.store(
+        "permitted_hosts",
+        Array,
+        "An array of hostnames or IPAddr objects representing which hosts this app will respond to",
+      ) do |local_hostname,project_env|
+        if project_env.production?
+          []
+        else
+          [
+            local_hostname,
+            "localhost",
+            ".localhost",
+            ".test",
+            IPAddr.new("0.0.0.0/0"),
+            IPAddr.new("::/0"),
+          ].compact
+        end
+      end
+
     end
   end
 end

data/lib/brut/framework/container.rb

@@ -1,6 +1,7 @@
 require "fileutils"
 
 module Brut
+  # Provides access to the singelton container that contains all of Brut's current configuration.
   def self.container(&block)
     @container ||= Brut::Framework::Container.new
     if !block.nil?
@@ -19,31 +20,49 @@ end
 # and can depend on other values in this container.
 #
 # There is no namespacing/hierarchy.
+#
+# In general, you should not create instances of this class, but you may need to access it via {Brut.container} in order to obtain
+# configuration values or set your own.
 class Brut::Framework::Container
   def initialize
     @container = {}
   end
 
-  # Store a named value for later.
+  # Store a named value for later.  You can use this to store static values, or dynamic values that require the values of other stored
+  # values.
+  #
+  # @param [String] name The name of the value. This should be a string that is a valid Ruby identifier. If `type` is a boolean, this
+  #                      parameter must end in a question mark.
+  # @param [String] type Description of the type that the value should conform to. if this value is "boolean" or :boolean, then
+  #                      the value will be coerced into `true` or `false`. Otherwise, this serves as only documentation for now.
+  # @param [String] description Documentation as to what this value is for.
+  # @param [Object] value if given, this is the value to use. If the value you want is dynamically determined, or you want to create
+  #                       it lazily, pass a block.
+  # @param [true|false] allow_app_override if true, the app may override this value. Default is false, which means the app cannot.
+  #                                        This is mostly useful for Brut internals to ensure the app doesnt' wreak havoc 
+  #                                        on things it should not mess with.
+  # @param [true|false] allow_nil if true, this value may be nil and if `allow_app_override` is true, the app can override the value
+  #                               to be `nil`.  The default is false, which means `nil` is not allowed. Generally, you don't want
+  #                               `nil`.  `nil` is no good for nobody.
+  # @yield [*any] Yields any existing configuration values to the block as *positional parameters*.
+  #               The names of the parameters must match the name of another configuration value.
+  # @yieldreturn [Object] the value to use for this configuration option.  This is memoized, so the block will not be called again.
   #
-  # name:: The name of the value. This should be a string that is a valid Ruby identifier.
-  # type:: Description of the type that the value should conform to. if this value is "boolean" or :boolean, then
-  #        the value will be coerced into `true` or `false`. Otherwise, this serves as documentation for now.
-  # description:: Documentation as to what this value is for.
-  # value:: if given, this is the value to use.
-  # block:: If value is omitted, block will be evaluated the first time the value is
-  #         fetched and is expected to return the value to use for all subsequent
-  #         requests.
+  # @example Storing a static value
+  #     container.store("num_retries",Integer,"Number of times to retry",10)
   #
-  #         The block can receive parameters and those parameters names must
-  #         match other values stored in this container.  Those values are passed in.
+  # @example Storing a dynamic value based on another one
+  #     container.store("num_retries",Integer,"Number of times to retry",10)
+  #     container.store("max_retry_ms",Integer,"Number of times to retry") { |num_retries|
+  #       num_retries * 100
+  #     }
   #
-  #         For example, if you have the value `project_root`, you can then set another
-  #         value called `tmp_dir` that uses `project_root` like so:
+  # @see #store_required_path
+  # @see #store_ensured_path
   #
-  #         ```
-  #         container.store("tmp_dir") { |project_root| project_root / "tmp" }
-  #         ```
+  # @raise [ArgumentError] if the name has already been specified, if this is a boolean and the name doesn't
+  #                        end in a question mark, or if this a `Pathname` and the name does not end in `_dir`
+  #                        or `_file`.
   def store(name,type,description,value=:use_block,allow_app_override: false,allow_nil: false,&block)
     # TODO: Check that value / block is used properly
     name = name.to_s
@@ -72,6 +91,16 @@ class Brut::Framework::Container
     self
   end
 
+  # Called by your app to override an existing value.  The value must be overridable (see {#store}).  Generally, you should call this
+  # in the initializer of your {Brut::Framework::App} subclass.  Calling this after the fact may not have the affect you want.
+  #
+  # @param [String|Symbol] name name of the value to override. Will be coerced to a String. This name must have been previously
+  #                             configured.
+  # @param [Object] value if given, this is the value to use. If omitted, the block is called
+  #
+  # @yield [*any] Yields any existing configuration values to the block as *positional parameters*.
+  #               The names of the parameters must match the name of another configuration value.
+  # @yieldreturn [Object] the value to use for this configuration option.  This is memoized, so the block will not be called again.
   def override(name,value=:use_block,&block)
     name = name.to_s
     if !@container[name]
@@ -88,46 +117,76 @@ class Brut::Framework::Container
   end
 
   # Store a value that represents a path that must exist. The value will
-  # be assumed to be of type Pathname
+  # be assumed to be a `Pathname` and the `name` must end in `_dir` or `_file`.
+  # Note that the value's existence is not checked until it is requested. When it is,
+  # an exception will be raised if it does not exist.
+  #
+  # @param [Symbol|String] name of this value. Must end in `_dir` or `_file`.
+  # @param description [String] description documentation of what this value is for
+  # @param [Object] value if given, this is the value to use. If omitted, the block is called
+  #
+  # @yield [*any] Yields any existing configuration values to the block as *positional parameters*.
+  #               The names of the parameters must match the name of another configuration value.
+  # @yieldreturn [Object] the value to use for this configuration option.  This is memoized, so the block will not be called again.
   def store_required_path(name,description,value=:use_block,&block)
     self.store(name,Pathname,description,value,&block)
     @container[name][:required_path] = true
     self
   end
 
-  # Store a value that represents a path that can be created if
-  # it does not exist. The path won't be created until the value is 
-  # accessed the first time. The value will
-  # be assumed to be of type Pathname
+  # Store a value that represents a path that will be created if it doesn't exist.
+  # The value will be assumed to be a `Pathname` and the `name` must end in `_dir` or `_file`.
+  #
+  # This is preferred over {#store_required_path} so that you don't have to have a bunch of `.keep` files hanging around
+  # just for your version control system.  The path will be created as a directory whenever it is first accessed.
+  #
+  # @param [Symbol|String] name of this value. Must end in `_dir` or `_file` (though ending it in `_file` doesn't make much sense).
+  # @param description [String] description documentation of what this value is for
+  # @param [Object] value if given, this is the value to use. If omitted, the block is called
+  #
+  # @yield [*any] Yields any existing configuration values to the block as *positional parameters*.
+  #               The names of the parameters must match the name of another configuration value.
+  # @yieldreturn [Object] the value to use for this configuration option.  This is memoized, so the block will not be called again.
   def store_ensured_path(name,description,value=:use_block,&block)
     self.store(name,Pathname,description,value,&block)
     @container[name][:ensured_path] = true
     self
   end
 
-  # Fetch a value by using its name as a method to instances of this class.
+  # Provides method-like access to configured values. Only configured values will respond and only
+  # if the accessor method is called without parameters and without a block. See {#fetch}.
+  #
+  # @example
+  #     Brut.container.store("num_retries",Integer,"Number of times to retry",10)
+  #     Brut.container.num_retries # => 10
   def method_missing(sym,*args,&block)
     if args.length == 0 && block.nil? && self.respond_to_missing?(sym)
-      fetch_value(sym.to_s)
+      fetch(sym.to_s)
     else
       super.method_missing(sym,*args,&block)
     end
   end
 
-  # Implemented to go along with method_missing
+  # Required for good decorum when overriding {#method_missing}.
+  #
+  # @param [String|Symbol] name the name of a previously-configured value.
+  #
+  # @return [true|false] true if `name` has been configured
   def respond_to_missing?(name,include_private=false)
     @container.key?(name.to_s)
   end
 
-
-  # Fetch a value given a name.
+  # Fetch the value given a name.  For lazily-defined values, this will call all necessary blocks needed to determine the value. Thus,
+  # any number of other blocks could be called, depending on what values are needed.
+  #
+  # @param name [Symbol|String] the name of the value to fetch.
+  #
+  # @return [Object] the configured value, if it has been configured. Note that if the value was defined with `allow_nil: true`
+  #                  passed to {#store}, `nil` could be returned.
+  # @raise [KeyError] if `name` has not been previously stored
+  # @raise [Brut::Framework::Errors::NotFound] if a path stored with {#store_required_path} does not exist
   def fetch(name)
-    fetch_value(name.to_s)
-  end
-
-private
-
-  def fetch_value(name)
+    name = name.to_s
     # TODO: Provide a cleanr impl and better error checking if things go wrong
     x = @container.fetch(name)
 
@@ -158,11 +217,16 @@ private
     handle_path_values(name,x)
     x[:value]
   end
+private
 
   def handle_path_values(name,contained_value)
     value = contained_value[:value]
     if contained_value[:required_path] && !Dir.exist?(value)
-      raise "For value '#{name}', the directory is represents must exist, but does not: '#{value}'"
+      raise Brut::Framework::Errors::NotFound.new(
+        resource_name: value,
+        id: name,
+        contetx: "For value '#{name}', the directory is represents must exist, but does not: '#{value}'"
+      )
     end
     if contained_value[:ensured_path]
       FileUtils.mkdir_p value

data/lib/brut/framework/errors/abstract_method.rb

@@ -1,9 +1,5 @@
+# Raised when a method must be defined by a subclass.  This is useful for making it clear
+# which methods a subclass is expected to override and for which no default behavior
+# makes sense.
 class Brut::Framework::Errors::AbstractMethod < Brut::Framework::Error
-  def initialize(message=nil)
-    if message.nil?
-      super
-    else
-      super("Subclass must implement: #{message}")
-    end
-  end
 end

data/lib/brut/framework/errors/missing_parameter.rb

@@ -0,0 +1,12 @@
+# Raised when an expected parameter in e.g. a path or a method invocation is
+# not available.  This allows classes to give a better error message than
+# the one provided by standard library exceptions like `KeyError`
+class Brut::Framework::Errors::MissingParameter < Brut::Framework::Error
+  # Create the exception
+  # @param [String|Symbol] missing_param the name of the missing parameter.
+  # @param [Array<String|Symbol>] params_received the parameters that were received in the context that generated this error
+  # @param [String] context Any additional context to understand the error
+  def initialize(missing_param, params_received:, context:)
+    super("Parameter '#{missing_param}' was not available. Received params: #{params_received.empty? ? 'no params' : "'" + params_received.join(', ') + "'"}. #{context}")
+  end
+end

data/lib/brut/framework/errors/no_class_for_path.rb

@@ -0,0 +1,25 @@
+# Raised when a path has been declared, but the class to handle it cannot be found in the app.
+class Brut::Framework::Errors::NoClassForPath < Brut::Framework::Error
+  # Array of names that, if joined with `::` would name the class that could not be found
+  # @return [Array<String>] array of parts. For a class named `Auth::LoginPage`, would return `["Auth","LoginPage"]`
+  attr_reader :class_name_path
+  # The path template that the class that couldn't be found was intended to handle
+  # @return [String] a path template as given inside {Brut::Framework::App.routes}
+  attr_reader :path_template
+
+  # Create the exception
+  # @param [Array<String>] class_name_path array of names that, if joined with `::` would name the class that could not be found
+  # @param [String] path_template The path template that the class that couldn't be found was intended to handle
+  # @param [NameError] name_error The `NameError` that was caught
+  def initialize(class_name_path:, path_template:, name_error:)
+    @class_name_path = class_name_path
+    @path_template = path_template
+    module_message = if name_error.receiver == Module
+                       "Could not find"
+                     else
+                       "Module '#{name_error.receiver}' did not have"
+                     end
+    message = "Cannot find page class for route '#{path_template}', which should be #{class_name_path.join("::")}. #{module_message} the class or module '#{name_error.name}'"
+    super(message)
+  end
+end

data/lib/brut/framework/errors/not_found.rb

@@ -1,10 +1,20 @@
 # Indicates that a resource or database row does not exist.
 class Brut::Framework::Errors::NotFound < Brut::Framework::Error
-  def initialize(resource_name:,id:,context:nil)
+  # @param [String] resource_name Name of the type of resource
+  # @param [String|Int] id Identifier of the resource. If present, search_terms is ignored.
+  # @param [Object] search_terms If provided, these are the search terms used. Will be converted to a string via `inspect`. Ignored if
+  # id is present.
+  # @param [String] context Any additional context about what went wrong
+  def initialize(resource_name:,id: nil, search_terms: nil,context:nil)
     if !context.nil?
       context = ": #{context}"
     end
-    super("Could not find a #{resource_name} using ID #{id}#{context}")
+    fragment = if id.nil?
+                 "Search '#{search_terms.inspect}'"
+               else
+                 "ID '#{id}'"
+               end
+    super("Could not find a #{resource_name} using #{fragment}#{context}")
   end
 end
 

data/lib/brut/framework/errors/not_implemented.rb

@@ -0,0 +1,14 @@
+# Thrown when use of a feature of Brut is detected, but that
+# feature is not yet implemented.  This is advisory only and
+# not a promise to ever implement that feature.  It's mostly used
+# when two APIs are very similar and one might expect both to  
+# support the same features, but for technical reasons one of the APIs does not.
+class Brut::Framework::Errors::NotImplemented < Brut::Framework::Error
+  def initialize(message=nil)
+    if message.nil?
+      super
+    else
+      super("NOT IMPLEMENTED: #{message}")
+    end
+  end
+end