brut 0.0.1

data/lib/brut/i18n/base_methods.rb

@@ -0,0 +1,168 @@
+# Interface for translations.  This is prefered over using Ruby's I18n directly.
+# This is intended to be mixed-in to any class that requires this, so that you can more
+# expediently access the `t` method.
+module Brut::I18n::BaseMethods
+
+  # Access a translation and insert interpolated elemens as needed. This will use the provided key to determine
+  # the actual full key to the translation, as described below.  The value returned is not HTML escaped,
+  # assuming that you have not placed HTML injections in your own translation files.  Interpolated
+  # values *are* HTML escaped, so external input is safe to provide.
+  #
+  # This method also may take a block, and the results of the block are inserted into the `%{block}`
+  # interpolation value in the i18n string, if it's present.
+  #
+  # Any missing interpolation will result in an exception, *except* for the value `field`. When
+  # a string has `%{field}` in it, but `field:` is omitted in this call, the value for 
+  # `"general.cv.this_field"` is used. This value, in English, is "this field", so a call
+  # to `t("email.required")` would generate `"This field is required"`, while a call
+  # to `t("email.required", field: "E-mail address")` would generate `"E-mail address is required"`.
+  #
+  # @param [String,Symbol,Array<String>,Array<Symbol>] key used to create one or more keys to be translated.
+  #        This value's behavior is designed to a balance predictabilitiy in what actual key is chosen
+  #        but without needless repetition on a page.  If this value is provided, and is an array, the values
+  #        are joined with "." to form a key.  If the value is not an array, that value is used directly.
+  #        Given this key, two values are checked for a translation: the key itself and 
+  #        the key inside "general.".  If this value is *not* provided, it is expected
+  #        taht the `**rest` hash includes page: or component:.  See that parameter and the example.
+  #
+  # @param [Hash] rest values to use for interpolation of the key's translation. If `key` is omitted,
+  #               this hash should have a value for either `page:` or `component:` (not both).  If
+  #               `page:` is present, it is assumed that the class that has included this module
+  #               is a `Brut::FrontEnd::Page` or is a page component.  It's `page_name` will be used to create
+  #               a key based on the value of `page:`: `pages.«page_name».«page: value»`.
+  #               if `component:` is included, the behavior is the same but for `component` instead of `page`.
+  # @option interpolated_values [Numeric] count Special interpolation to control pluralization.
+  #
+  # @raise [I18n::MissingTranslation] if no translation is found
+  # @raise [I18n::MissingInterpolationArgument] if interpolation arguments are missing, or if the key
+  #                                             has pluralizations and no count: was given
+  #
+  # @example Simplest usage
+  #   # in your translations file
+  #   en: {
+  #     general: {
+  #       hello: "Hi!"
+  #     },
+  #     formalized: {
+  #       hello: "Greetings!"
+  #     }
+  #   }
+  #   # in your code
+  #   t(:hello) # => Hi!
+  #   t("formalized.hello") # => Greetings!
+  #
+  # @example Using an array for the key
+  #   # in your translations file
+  #   en: {
+  #     general: {
+  #       actions: {
+  #         edit: "Make an edit"
+  #       }
+  #     },
+  #   }
+  #   # in your code
+  #   t([:actions, :edit]) # => Make an edit
+  #
+  # @example Using page:
+  #   # in your translations file
+  #   en: {
+  #     pages: {
+  #       HomePage: {
+  #         new_widget: "Create new Widget"
+  #       },
+  #       WidgetsPage: {
+  #         new_widget: "Create New"
+  #       },
+  #     },
+  #   }
+  #   # in your code for HomePage
+  #   t(page: :new_widget) # => Create new Widget
+  #   # in your code for WidgetsPage
+  #   t(page: :new_widget) # => Create New
+  #
+  # @example Using page: with an array
+  #   # in your translations file
+  #   en: {
+  #     pages: {
+  #       WidgetsPage: {
+  #         new_widget: "Create New"
+  #         captions: {
+  #           new: "New Widgets"
+  #         }
+  #       },
+  #     },
+  #   }
+  #   # in your code for HomePage
+  #   t(page: [ :captions, :new ]) # => New Widgets
+  def t(key=:look_in_rest,**rest)
+    if key == :look_in_rest
+
+      page      = rest.delete(:page)
+      component = rest.delete(:component)
+
+      if !page.nil? && !component.nil?
+        raise ArgumentError, "You may only specify page or component, not both"
+      end
+
+      if page
+        key = ["pages.#{self.page_name}.#{Array(page).join('.')}"]
+      elsif component
+        key = ["components.#{self.component_name}.#{Array(component).join('.')}"]
+      else
+        raise ArgumentError, "If you omit an explicit key, you must specify page or component"
+      end
+    else
+      key = Array(key).join('.')
+      key = [key,"general.#{key}"]
+    end
+    if block_given?
+      if rest[:block]
+        raise ArgumentError,"t was given a block and a block: param. You can't do both "
+      end
+      rest[:block] = html_safe(yield.to_s.strip)
+    end
+    html_safe(t_direct(key,**rest))
+  rescue I18n::MissingInterpolationArgument => ex
+    if ex.key.to_s == "block"
+      raise ArgumentError,"One of the keys #{key.join(", ")} contained a %{block} interpolation value: '#{ex.string}'. This means you must use t_html *and* yield a block to it"
+    else
+      raise
+    end
+  end
+
+  def this_field_value
+    @__this_field_value ||= ::I18n.t("general.cv.this_field", raise: true)
+  end
+
+  # Directly access translations without trying to be smart about deriving the key.  This is useful
+  # if you have the exact keys you want.
+  #
+  # @param [Array<String>,Array<Symbol>] keys list of keys representing what is to be translated. The
+  #                                           first key found will be used. If no key in the list is found
+  #                                           will raise a I18n::MissingTranslation
+  # @param [Hash] interpolated_values value to use for interpolation of the key's translation
+  # @option interpolated_values [Numeric] count Special interpolation to control pluralization.
+  #
+  # @raise [I18n::MissingTranslation] if no translation is found
+  # @raise [I18n::MissingInterpolationArgument] if interpolation arguments are missing, or if the key
+  #                                             has pluralizations and no count: was given
+  def t_direct(keys,interpolated_values={})
+    keys = Array(keys).map(&:to_sym)
+    default_interpolated_values = {
+      field: this_field_value,
+    }
+    escaped_interpolated_values = interpolated_values.map { |key,value|
+      if value.kind_of?(String)
+        [ key, Brut::FrontEnd::Template.escape_html(value) ]
+      else
+        [ key, value ]
+      end
+    }.to_h
+    result = ::I18n.t(keys.first, default: keys[1..-1],raise: true, **default_interpolated_values.merge(escaped_interpolated_values))
+    if result.kind_of?(Hash)
+      raise I18n::MissingInterpolationArgument.new(:count,interpolated_values,keys.join(","))
+    end
+    result
+  end
+
+end

data/lib/brut/i18n/for_cli.rb

@@ -0,0 +1,4 @@
+module Brut::I18n::ForCLI
+  include Brut::I18n::BaseMethods
+  def html_safe(string) = string
+end

data/lib/brut/i18n/for_html.rb

@@ -0,0 +1,4 @@
+module Brut::I18n::ForHTML
+  include Brut::I18n::BaseMethods
+  def html_safe(string) = Brut::FrontEnd::Templates::HTMLSafeString.from_string(string)
+end

data/lib/brut/i18n/http_accept_language.rb

@@ -0,0 +1,68 @@
+class Brut::I18n::HTTPAcceptLanguage
+  WeightedLocale = Data.define(:locale, :q) do
+    def primary_locale = self.locale.gsub(/\-.*$/,"")
+    def primary? = self.primary_locale == self.locale
+
+    def primary_only
+      self.class.new(locale: self.primary_locale, q: self.q)
+    end
+
+    def ==(other)
+      self.locale == other.locale
+    end
+  end
+
+  def self.from_session(session_value)
+    values = session_value.to_s.split(/,/).map { |value|
+      locale,q = value.split(/;/)
+      WeightedLocale.new(locale:,q:)
+    }
+    if values.any?
+      self.new(values)
+    else
+      AlwaysEnglish.new
+    end
+  end
+
+  def self.from_browser(value)
+    value = value.to_s.strip
+    if value == ""
+      AlwaysEnglish.new
+    else
+      self.new([ WeightedLocale.new(locale: value, q: 1) ])
+    end
+  end
+
+  def self.from_header(header_value)
+    header_value = header_value.to_s.strip
+    if header_value == "*" || header_value == ""
+      AlwaysEnglish.new
+    else
+      values = header_value.split(/,/).map(&:strip).map { |language|
+        locale,q = language.split(/;\s*q\s*=\s*/,2)
+        WeightedLocale.new(locale: locale,q: q.nil? ? 1 : q.to_f)
+      }
+      if values.any?
+        self.new(values)
+      else
+        AlwaysEnglish.new
+      end
+    end
+  end
+
+  attr_reader :weighted_locales
+  def initialize(weighted_locales)
+    @weighted_locales = weighted_locales.sort_by(&:q).reverse
+  end
+  def known? = true
+  def for_session = @weighted_locales.map { |weighted_locale| "#{weighted_locale.locale};#{weighted_locale.q}" }.join(",")
+  def to_s = self.for_session
+
+  class AlwaysEnglish < Brut::I18n::HTTPAcceptLanguage
+    def initialize
+      super([ WeightedLocale.new(locale: "en", q: 1) ])
+    end
+    def known? = false
+  end
+
+end

data/lib/brut/i18n.rb

@@ -0,0 +1,6 @@
+module Brut::I18n
+  autoload(:BaseMethods, "brut/i18n/base_methods")
+  autoload(:ForCLI, "brut/i18n/for_cli")
+  autoload(:ForHTML, "brut/i18n/for_html")
+  autoload(:HTTPAcceptLanguage, "brut/i18n/http_accept_language")
+end

data/lib/brut/instrumentation/basic.rb

@@ -0,0 +1,66 @@
+class Brut::Instrumentation::Basic
+  def initialize
+    @subscribers = Concurrent::Set.new
+  end
+
+  class TypeChecking < Brut::Instrumentation::Basic
+    def instrument(event,&block)
+      if !event.kind_of?(Brut::Instrumentation::Event)
+        raise "You cannot instrument a #{event.class} - it must be a Brut::Instrumentation::Event or subclass"
+      end
+      super
+    end
+  end
+
+  def instrument(event,&block)
+    block ||= ->() {}
+
+    start     = Time.now
+    result    = nil
+    exception = nil
+
+    begin
+      result = block.(event)
+    rescue => ex
+      exception = ex
+    end
+    stop = Time.now
+    notify(event:,start:,stop:,exception:)
+    if exception
+      raise exception
+    else
+      result
+    end
+  end
+
+  def subscribe(subscriber=:use_block,&block)
+    if block.nil? && subscriber == :use_block
+      raise ArgumentError,"subscriber requires a Brut::Instrumentation::Subscriber or a block"
+    end
+    if !block.nil? && subscriber != :use_block
+      raise ArgumentError,"subscriber requires a Brut::Instrumentation::Subscriber or a block, not both"
+    end
+    if block.nil?
+      if subscriber.kind_of?(Proc)
+        subscriber = Brut::Instrumentation::Subscriber.from_proc(subscriber)
+      elsif !subscriber.kind_of?(Brut::Instrumentation::Subscriber)
+        raise ArgumentError, "subscriber must be a Proc or Brut::Instrumentation::Subscriber, not a #{subscriber.class}"
+      end
+    else
+      subscriber = Brut::Instrumentation::Subscriber.from_proc(block)
+    end
+    @subscribers << subscriber
+  end
+
+  def notify(event:,start:,stop:,exception:)
+    Thread.new do
+      @subscribers.each do |subscriber|
+        begin
+          subscriber.(event:,start:,stop:,exception:)
+        rescue => ex
+          warn "#{subscriber} raised #{ex}"
+        end
+      end
+    end
+  end
+end

data/lib/brut/instrumentation/event.rb

@@ -0,0 +1,19 @@
+class Brut::Instrumentation::Event
+  include Brut::Framework::FussyTypeEnforcement
+
+  attr_reader :category,
+              :subcategory,
+              :name,
+              :details
+
+  def initialize(category:,
+                 subcategory:nil,
+                 name:,
+                 details:{})
+    @category    = type!(category,String,"category",required: true, coerce: :to_s)
+    @subcategory = type!(subcategory,String,"subcategory",required: false, coerce: :to_s)
+    @name        = type!(name,String,"name",required:true,coerce: :to_s)
+    @details     = type!(details,Hash,"details",required:false) || {}
+  end
+
+end

data/lib/brut/instrumentation/http_event.rb

@@ -0,0 +1,5 @@
+class Brut::Instrumentation::HTTPEvent < Brut::Instrumentation::Event
+  def initialize(http_method:,name:,path:,details:{})
+    super(category: "http", subcategory: http_method, name: name, details: details.merge(path:path))
+  end
+end

data/lib/brut/instrumentation/subscriber.rb

@@ -0,0 +1,41 @@
+class Brut::Instrumentation::Subscriber
+  def self.from_proc(block)
+    required_parameter_names_found   = self.instance_method(:call).parameters.map { |(type,name)| [ name, false ] }.to_h
+    unexpected_parameter_names_error = {}
+
+    block.parameters.each do |(type,name)|
+      if required_parameter_names_found.key?(name)
+        if type == :key || type == :keyreq
+          required_parameter_names_found[name] = true
+        else
+          unexpected_parameter_names[name] = "Not a keyword arg"
+        end
+      elsif type != :key
+        if type == :keyreq
+          unexpected_parameter_names[name] = "keyword arg without a default value"
+        else
+          unexpected_parameter_names[name] = "Not a keyword arg"
+        end
+      end
+    end
+    errors = []
+    if unexpected_parameter_names_error.any?
+      messages = unexpected_parameter_names_error.map { |name,problem|
+        "#{name} - #{problem}"
+      }.join(", ")
+      errors << "Unexpected parameters were required, so this cannot be used as a subscriber: #{messages}"
+    end
+    if required_parameter_names_found.any? { |_name,found| !found }
+      messages = required_parameter_names_found.select { |_name,found| !found }.map { |name,_found| "#{name} must be a keyword argument" }.join(",")
+      errors << "Required parameters were missing, so this cannot be used as a subscriber: #{messages}"
+    end
+    if errors.any?
+      raise ArgumentError,errors.join(", ")
+    end
+    block
+  end
+
+  def call(event:,start:,stop:,exception:)
+  end
+
+end

data/lib/brut/instrumentation.rb

@@ -0,0 +1,11 @@
+module Brut::Instrumentation
+  autoload(:Basic,"brut/instrumentation/basic")
+  autoload(:Subscriber,"brut/instrumentation/subscriber")
+  autoload(:Event,"brut/instrumentation/event")
+  autoload(:HTTPEvent,"brut/instrumentation/http_event")
+
+  def instrument(**args,&block)
+    Brut.container.instrumentation.instrument(Brut::Instrumentation::Event.new(**args),&block)
+  end
+end
+

data/lib/brut/junk_drawer.rb

@@ -0,0 +1,88 @@
+require "tzinfo"
+class Clock
+  def initialize(tzinfo_timezone)
+    if tzinfo_timezone
+      @timezone = tzinfo_timezone
+    elsif ENV["TZ"]
+      @timezone = begin
+                    TZInfo::Timezone.get(ENV["TZ"])
+                  rescue TZInfo::InvalidTimezoneIdentifier => ex
+                    SemanticLogger[self.class.name].warn("#{ex} from ENV['TZ'] value '#{ENV['TZ']}'")
+                    nil
+                  end
+    end
+    if @timezone.nil?
+      @timezone = TZInfo::Timezone.get("UTC")
+    end
+  end
+
+  def now
+    Time.now(in: @timezone)
+  end
+
+  def in_time_zone(time)
+    @timezone.to_local(time)
+  end
+end
+
+class RichString
+  def initialize(string)
+    @string = string.to_s
+  end
+
+  def underscorized
+    return self unless /[A-Z-]|::/.match?(@string)
+    word = @string.gsub("::", "/")
+    word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
+    word.tr!("-", "_")
+    word.downcase!
+    RichString.new(word)
+  end
+
+  def camelize
+    @string.to_s.split(/[_-]/).map { |part|
+      part.capitalize
+    }.join("")
+  end
+
+  def humanized
+    RichString.new(@string.tr("_-"," "))
+  end
+
+  def to_s = @string
+  def to_str = self.to_s
+
+  def to_s_or_nil = @string.empty? ? nil : self.to_s
+
+  def ==(other)
+    if other.kind_of?(RichString)
+      self.to_s == other.to_s
+    elsif other.kind_of?(String)
+      self.to_s == other
+    else
+      false
+    end
+  end
+
+  def <=>(other)
+    if other.kind_of?(RichString)
+      self.to_s <=> other.to_s
+    elsif other.kind_of?(String)
+      self.to_s <=> other
+    else
+      super
+    end
+  end
+
+  def +(other)
+    if other.kind_of?(RichString)
+      RichString.new(self.to_s + other.to_s)
+    elsif other.kind_of?(String)
+      self.to_s + other
+    else
+      super(other)
+    end
+  end
+
+end
+

data/lib/brut/sinatra_helpers.rb

@@ -0,0 +1,183 @@
+module Brut::SinatraHelpers
+
+  def self.included(sinatra_app)
+    sinatra_app.extend(ClassMethods)
+
+    sinatra_app.set :logging, false
+    sinatra_app.set :public_folder, Brut.container.public_root_dir
+    sinatra_app.path("/__brut/csp-reporting",method: :post)
+    sinatra_app.path("/__brut/locale_detection",method: :post)
+  end
+
+  # @private
+  def render_html(component_or_page_instance)
+    result = component_or_page_instance.render
+    case result
+    in Brut::FrontEnd::HttpStatus => http_status
+      http_status.to_i
+    else
+      result
+    end
+  end
+
+
+  module ClassMethods
+
+    # Regsiters a page in your app. A page is what it sounds like - a web page that's rendered from a URL.  It will be provided
+    # via an HTTP get to the path provided.
+    #
+    # The page is rendered dynamically by using an instance of a page class as binding to HTML via ERB.  The name of the class and the name of the
+    # ERB file are based on the path, according to the conventions described below.
+    #
+    # A few examples:
+    #
+    # * `page("/widgets")` will use `WidgetsPage`, and expect the HTML in `app/src/pages/widgets_page.html.erb`
+    # * `page("/widgets/:id")` will use `WidgetsByIdPage`, and expect the HTML in `app/src/pages/widgets_by_id_page.html.erb`
+    # * `page("/admin/widgets/:internal_id") will use `Admin::WidgetsByInternalIdPage`, and expect HTML in
+    # `app/src/pages/admin/widgets_by_internal_id_page.html.erb`
+    #
+    # The general conventions are:
+    #
+    # * Each part of the path that is not a placeholder will be camelized
+    # * Any part of the path that *is* a placholder has its leading colon removed, then is camelized, but appended to
+    #   the previous part with `By`, thus `WidgetsById` is created from `Widgets`, `By`, and `Id`.
+    # * The final part of the path is further appended with `Page`.
+    # * These parts now make up a path to a class, so the entire thing is joined by `::` to form the fully-qualified class name.
+    #
+    # When a  GET is issued to the path, the page is instantiated.  The page's constructor may accept keyword arguments (however it must not accept
+    # any other type of argument).
+    #
+    # Each keyword argument found will be provided when the class is created, as follows:
+    #
+    # * Any placeholders, so when a path `/widgets/1234` is requested, `WidgetsPage.new(id: "1234")` will be used to create the page object.
+    # * Anything in the request context, such as the current user
+    # * Any query string parameters 
+    # * Anything passed as keyword args to this method, with the following adjustment:
+    #   - Any key ending in `_class` whose value is a Class will be instantiated and
+    #     passed in as the key withoutr `_class`, e.g. form_class: SomeForm will
+    #     pass `form: SomeForm.new` to the constructor
+    # * The flash
+    #
+    # Once this page object exists, `render` will be called to produce HTML to send back to the browser.
+    def page(path)
+      Brut.container.routing.register_page(path)
+
+      get path do
+        Brut.container.instrumentation.instrument(Brut::Instrumentation::HTTPEvent.new(name: :get_page, http_method: "GET", path: path )) do
+          route = Brut.container.routing.for(path: path,method: :get)
+          page_class = route.handler_class
+          request_context = Thread.current.thread_variable_get(:request_context)
+          constructor_args = request_context.as_constructor_args(
+            page_class,
+            request_params: params,
+          )
+          page_instance = page_class.new(**constructor_args)
+          result = page_instance.handle!
+          case result
+          in URI => uri
+            redirect to(uri.to_s)
+          in Brut::FrontEnd::HttpStatus => http_status
+            http_status.to_i
+          else
+            result
+          end
+        end
+      end
+    end
+
+    # Declares a form that will be submitted to the app. To handle the submission you must providate
+    # a handler and an optional form.  The form defines all the fields in your form, including constraints.
+    # These can be used to generate HTML for the form.  When the form is submitted to your app, the form
+    # is instantiated and filled in with all the values it is requesting.  That form is then passed off to the
+    # configured handler.  The handle! method performs whatever processing is needed.
+    #
+    # If you have no form elements and are just responding to a POST action from a browser, use `action`.
+    #
+    # The name of the classes are based on a convention similar to `page`:
+    #
+    # * Each part of the path that is not a placeholder will be camelized
+    # * Any part of the path that *is* a placholder has its leading colon removed, then is camelized, but appended to
+    #   the previous part with `With`, thus `WidgetsWithId` is created from `Widgets`, `With`, and `Id`.
+    # * The final part of the path is further appended with `Form` or `Handler`.
+    # * These parts now make up a path to a class, so the entire thing is joined by `::` to form the fully-qualified class name.
+    #
+    # Examples:
+    #
+    # * `form("/widgets")` will use `WidgetsForm` and `WidgetsHandler`
+    # * `form("/widgets/:id")` will use `WidgetsWithIdForm` and `WidgetsWithIdHandler`
+    # * `form("/admin/widgets/:internal_id") will use `Admin::WidgetsWithInternalIdForm` and `Admin::WidgetsWithInternalIdHandler`
+    #
+    def form(path)
+      route = Brut.container.routing.register_form(path)
+      self.define_handled_route(route, type: :form)
+    end
+
+    # Declare a form action that has no associated form elements.  This is used when you need to use a button to submit to the
+    # back-end, and the route contains all the context you need. For example a post to `/approved_widgets/:id` communicates that the 
+    # Widget with ID `:id` can be approved.
+    #
+    # This is preferred over `path` because a) it's more explicit that this is handling a POST from some HTML and b) this will check
+    # to make sure there is no form defined.
+    def action(path)
+      route = Brut.container.routing.register_handler_only(path)
+      self.define_handled_route(route, type: :action)
+    end
+
+    # When you need to respond to a given path/method, but it's not a page nor a form.  For example, webhooks often
+    # require responding to GET even though they aren't rendering pages nor considered to be idempotent.
+    #
+    # This will locate a handler class based on the same naming convention as for forms.
+    def path(path, method:)
+      route = Brut.container.routing.register_path(path, method: Brut::FrontEnd::HttpMethod.new(method))
+      self.define_handled_route(route,type: :generic)
+    end
+
+  private
+
+    def define_handled_route(original_brut_route,type:)
+
+      method = original_brut_route.http_method.to_s.upcase
+      path   = original_brut_route.path_template
+
+      route method, path do
+        Brut.container.instrumentation.instrument(Brut::Instrumentation::HTTPEvent.new(name: type, http_method: method, path: path)) do
+          brut_route = Brut.container.routing.for(path:,method:)
+
+          handler_class = brut_route.handler_class
+          form_class    = brut_route.respond_to?(:form_class) ? brut_route.form_class : nil
+
+          request_context = Thread.current.thread_variable_get(:request_context)
+          handler = handler_class.new
+          form = if form_class.nil?
+                   nil
+                 else
+                   form_class.new(params: params)
+                 end
+
+          process_args = request_context.as_method_args(handler,:handle,request_params: params,form: form)
+
+          result = handler.handle!(**process_args)
+
+          case result
+          in URI => uri
+            redirect to(uri.to_s)
+          in Brut::FrontEnd::Component => component_instance
+            render_html(component_instance).to_s
+          in [ Brut::FrontEnd::Component => component_instance, Brut::FrontEnd::HttpStatus => http_status ]
+            [
+              http_status.to_i,
+              render_html(component_instance).to_s,
+            ]
+          in Brut::FrontEnd::HttpStatus => http_status
+            http_status.to_i
+          in Brut::FrontEnd::Download => download
+            [ 200, download.headers, download.data ]
+          else
+            raise NoMatchingPatternError, "Result from #{handler.class}'s handle! method was a #{result.class}, which cannot be used to understand the response to generate"
+          end
+        end
+      end
+    end
+
+  end
+end