brut 0.10.0 → 0.12.0

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

@@ -0,0 +1,40 @@
+# Creates a button tag to be used inside a form. This is only 
+# needed if your form declared a `button` and you wish the value
+# to be included whern the form is submitted (for example, if you have
+# more than one submit button and wish to know which one was clicked on the
+# back end).
+class Brut::FrontEnd::Components::Inputs::ButtonTag < Brut::FrontEnd::Components::Input
+
+  # Creates the appropriate button for the given {Brut::FrontEnd::Form} and input name.
+  #
+  # @param [Brut::FrontEnd::Form} form The form that is being rendered. This method will consult this class to understand the requirements on this input so its HTML is generated correctly.
+  # @param [String] input_name the name of the input, which should be a member of `form`
+  # @param [Integer] index if this input is part of an array, this is the index into that array. This is used to get the input's value.
+  # @param [Hash] html_attributes any additional HTML attributes to include on the `<input>` element. Note 
+  #               that if you set `type` here to be `reset` or `button`, this button will not submit
+  #               the form (as per the HTML spec).  Also note that the various
+  #               `form*` attributes *will* take effect and work as desired.
+  def initialize(form:, input_name:, index: nil, **html_attributes)
+    input = form.input(input_name, index:)
+    if input.class.name != "Brut::FrontEnd::Forms::Button"
+      raise ArgumentError, "#{self.class} can only be used with `button` elements, not #{input.class.name} form elements"
+    end
+    default_html_attributes = {}
+    html_attributes = html_attributes.map { |key,value| [ key.to_sym, value ] }.to_h
+
+    default_html_attributes[:name] = if input.array?
+                                       "#{input.name}[]"
+                                     else
+                                       input.name
+                                     end
+    default_html_attributes[:value] = input.value
+
+    @attributes = default_html_attributes.merge(html_attributes)
+  end
+
+  def view_template
+    button(**@attributes) do
+      yield
+    end
+  end
+end

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

@@ -3,7 +3,6 @@ class Brut::FrontEnd::Components::Inputs::InputTag < Brut::FrontEnd::Components:
   def invalid? = @attributes["data-invalid"] == true
 
   # Creates the appropriate input for the given {Brut::FrontEnd::Form} and input name.
-  # Generally, you want to use this method over the initializer.
   #
   # @param [Brut::FrontEnd::Form} form The form that is being rendered. This method will consult this class to understand the requirements on this input so its HTML is generated correctly.
   # @param [String] input_name the name of the input, which should be a member of `form`
@@ -11,6 +10,9 @@ class Brut::FrontEnd::Components::Inputs::InputTag < Brut::FrontEnd::Components:
   # @param [Hash] html_attributes any additional HTML attributes to include on the `<input>` element.
   def initialize(form:, input_name:, index: nil, **html_attributes)
     input = form.input(input_name, index:)
+    if input.class.name != "Brut::FrontEnd::Forms::Input"
+      raise ArgumentError, "#{self.class} can only be used with `input` elements, not #{input.class.name} form elements"
+    end
     default_html_attributes = {}
     html_attributes = html_attributes.map { |key,value| [ key.to_sym, value ] }.to_h
 

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

@@ -1,7 +1,6 @@
 # Renders an HTML `<select>`.
 class Brut::FrontEnd::Components::Inputs::SelectTagWithOptions < Brut::FrontEnd::Components::Input
   # Creates the appropriate select input for the given {Brut::FrontEnd::Form} and input name.
-  # Generally, you want to use this method over the initializer.
   #
   # @param [Brut::FrontEnd::Form} form The form that is being rendered.
   #        This method will consult this class to understand the requirements

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

@@ -2,7 +2,6 @@
 class Brut::FrontEnd::Components::Inputs::TextareaTag < Brut::FrontEnd::Components::Input
 
   # Creates the appropriate textarea for the given {Brut::FrontEnd::Form} and input name.
-  # Generally, you want to use this method over the initializer.
   #
   # @param [Brut::FrontEnd::Form} form The form that is being rendered. This method will consult this class to understand the requirements on this textarea so its HTML is generated correctly.
   # @param [String] input_name the name of the input, which should be a member of `form`

data/lib/brut/front_end/form.rb

@@ -5,10 +5,12 @@ module Brut::FrontEnd::Forms
   autoload(:InputDeclarations, "brut/front_end/forms/input_declarations")
   autoload(:InputDefinition, "brut/front_end/forms/input_definition")
   autoload(:SelectInputDefinition, "brut/front_end/forms/select_input_definition")
+  autoload(:ButtonInputDefinition, "brut/front_end/forms/button_input_definition")
   autoload(:RadioButtonGroupInputDefinition, "brut/front_end/forms/radio_button_group_input_definition")
   autoload(:ConstraintViolation, "brut/front_end/forms/constraint_violation")
   autoload(:ValidityState, "brut/front_end/forms/validity_state")
   autoload(:Input, "brut/front_end/forms/input")
+  autoload(:Button, "brut/front_end/forms/button")
   autoload(:SelectInput, "brut/front_end/forms/select_input")
   autoload(:RadioButtonGroupInput, "brut/front_end/forms/radio_button_group_input")
 end
@@ -38,11 +40,11 @@ class Brut::FrontEnd::Form
       Brut.container.instrumentation.add_attributes(prefix: :brut, ignored_unknown_params: unknown_params.join(","))
     end
     @params = params.except(*unknown_params).map { |name,value|
-        input_definition = begin
-                             self.class.input_definitions[name] || self.class.input_definitions.fetch(name.to_s)
-                           rescue KeyError
-                             raise "cannot find input definition for '#{name}'. Have these: #{self.class.input_definitions.keys.inspect}"
-                           end
+      input_definition = begin
+                           self.class.input_definitions[name] || self.class.input_definitions.fetch(name.to_s)
+                         rescue KeyError
+                           raise "cannot find input definition for '#{name}'. Have these: #{self.class.input_definitions.keys.inspect}"
+                         end
       if value.kind_of?(Array)
         input_definition = begin
                              self.class.input_definitions[name] || self.class.input_definitions.fetch(name.to_s)

data/lib/brut/front_end/forms/button.rb

@@ -0,0 +1,21 @@
+# Represents the current state of a particular button that is part of a form.
+# Button's in this context don't really have state, but this allows the button to be
+# modeled like any other form element.
+class Brut::FrontEnd::Forms::Button < Brut::FrontEnd::Forms::Input
+  # Create the input with the given definition and value
+  # @param [Brut::FrontEnd::Forms::InputDefinition] input_definition
+  # @param [String] value Value of the button, which would be submitted with the form. Note
+  #                       that {Brut::FrontEnd::Forms::ButtonInputDefinition#make_input} will
+  #                       default this value to `"true"`.
+  def initialize(input_definition:, value:, index:)
+    @input_definition = input_definition
+    @validity_state = Brut::FrontEnd::Forms::ValidityState.new
+    @index = index
+    self.value=(value)
+  end
+
+  def value=(new_value)
+    @value = new_value.to_s
+    @typed_value = @value
+  end
+end

data/lib/brut/front_end/forms/button_input_definition.rb

@@ -0,0 +1,37 @@
+# Defines a button to be used to submit a form (as opposed to an `<input type="submit">`).
+# This is needed when the name/value of the button should be submitted witih the form.
+class Brut::FrontEnd::Forms::ButtonInputDefinition
+  include Brut::Framework::FussyTypeEnforcement
+
+  attr_reader :name
+
+  # Create a ButtonInputDefinition.
+  #
+  # @param [String] name Name of the button (required)
+  # @param [true|false] array If true, the form will expect multiple values for this input.  The values will be available as an array. Any values omitted by the user will be present as empty strings.
+  #
+  # @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button BUTTON Element
+  def initialize(
+    name:,
+    array: false
+  )
+    name  = name.to_s
+    @name  = type!(name,  String,        "name",  required: true)
+    @array = type!(array, [true, false], "array", required: true)
+  end
+
+  def array? = @array
+
+
+  # Create an Input based on this definition, initializing it with the given value.
+  # @param [String] value the value to give this input initially. If this is blank,
+  #                 the button's value will be `"true"`.
+  # @param [Integer] index the index of this input, if it is part of an array of
+  #                  inputs. `nil` is allowed only if the input definition is not for an array.
+  def make_input(value:, index:)
+    if value.to_s.strip == ""
+      value = "true"
+    end
+    Brut::FrontEnd::Forms::Button.new(input_definition: self, value:, index:)
+  end
+end

data/lib/brut/front_end/forms/input_declarations.rb

@@ -11,6 +11,16 @@ module Brut::FrontEnd::Forms::InputDeclarations
     )
   end
 
+  # Declares a named button for this form, which is required in order to have this button's name and
+  # value sent to the back.  This will generate a `<button>` tag. To use `<input type="submit">`, {.input} should
+  # be used instead.
+  # @param [String] name The name of the button (used in the `name` attribute)
+  def button(name)
+    self.add_input_definition(
+      Brut::FrontEnd::Forms::ButtonInputDefinition.new(name:)
+    )
+  end
+
   # Declares a select for this form, to be modeled via an HTML `<SELECT>` tag. Note that this will not define the values that appear
   # in the select.  That is done when the select is rendered, which you might do with a
   # {Brut::FrontEnd::Components::Inputs::Select}

data/lib/brut/front_end/forms/input_definition.rb

@@ -32,6 +32,7 @@ class Brut::FrontEnd::Forms::InputDefinition
     "radio"          => String,
     "range"          => String,
     "search"         => String,
+    "submit"         => String,
     "tel"            => String,
     "text"           => String,
     "time"           => Time, # XXX
@@ -49,7 +50,7 @@ class Brut::FrontEnd::Forms::InputDefinition
   # @param [Integer] maxlength Maximum length of the value allowed.
   # @param [String] name Name of the input (required)
   # @param [Regexp] pattern that the value must match. Note that this technically must be a regular expression that works for both Ruby and JavaScript, so don't get fancy.
-  # @param [true|false] required true if this field is required, false otherwise. Default is `true` unless `type` is `"checkbox"`.
+  # @param [true|false] required true if this field is required, false otherwise. Default is `true` unless `type` is `"checkbox"` or `"submit"`.
   # @param [Integer] step Step value for ranged inputs.  A value that is not on a step is considered invalid.
   # @param [String] type the type of input to create. Should be a value from the HTML spec. Default is based on the value of `name`. If `email`, `type` is `email`. If `password` or `password_confirmation`, type is `password`. Otherwise `text`.
   # @param [true|false] array If true, the form will expect multiple values for this input.  The values will be available as an array. Any values omitted by the user will be present as empty strings.
@@ -84,7 +85,11 @@ class Brut::FrontEnd::Forms::InputDefinition
 
     type = type.to_s
     if required == :based_on_type
-      required = type != "checkbox"
+      required = case type
+                 when "checkbox" then false
+                 when "submit"   then false
+                 else true
+                 end
     end
 
     @max       = max

data/lib/brut/instrumentation/methods.rb

@@ -0,0 +1,153 @@
+require "set"
+require "opentelemetry-sdk"
+
+# Allows instrumentation of methods via a class method. While Pages, Handlers, and Components are generally
+# instrumented, this module can be used for your back-end classes (or private methods of pages, handlers, or
+# component).
+#
+# @example Instrument specific methods
+#   class Widget
+#     include Brut::Instrumentation::Methods
+#
+#     def save
+#       # ...
+#     end
+#
+#     def search
+#       # ...
+#     end
+#
+#     instrument :save # search is not instrumented
+#   end
+#
+# @example Instrument all methods
+#   class Widget
+#     include Brut::Instrumentation::Methods
+#
+#     instrument_all!
+#
+#     def save
+#       # ...
+#     end
+#
+#     def search
+#       # ...
+#     end
+#
+#   private
+#
+#     def delete_orphans
+#     end
+#   end
+module Brut::Instrumentation::Methods
+
+  # @!visibility private
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def __module_for_instrumented_methods
+      @__module_for_instrumented_methods ||= begin
+        mod = Module.new
+        prepend mod
+        mod
+      end
+    end
+
+    # Instrument methods that have already been defined.
+    #
+    # @param method_names [Array<Symbol>] the method names to instrument.  They must
+    #                     exist and they must not already have been instrumented.
+    # @raise [ArgumentError] if any method does not exist or has already been instrumented
+    def instrument(*method_names)
+
+      method_names.each do |method_name|
+        if __module_for_instrumented_methods.method_defined?(method_name)
+          raise ArgumentError, "Method #{method_name} is already instrumented in #{self}"
+        end
+
+        method_defined = method_defined?(method_name) ||
+                         private_method_defined?(method_name) ||
+                         protected_method_defined?(method_name)
+
+        if !method_defined
+          raise ArgumentError, "Method #{method_name} is not defined in #{self.name}"
+        end
+
+        visibility = if private_method_defined?(method_name)
+                       :private
+                     elsif protected_method_defined?(method_name)
+                       :protected
+                     else
+                       :public
+                     end
+
+        __module_for_instrumented_methods.module_eval do
+          define_method(method_name) do |*args, **kwargs, &blk|
+            span_name = "#{self.class.name}##{method_name}"
+            span_attrs = {
+              "brut.class" => self.class.name,
+              "brut.method"  => method_name.to_s,
+            }
+
+            Brut.container.instrumentation.span(span_name, attributes: span_attrs) do |span|
+              super(*args, **kwargs, &blk)
+            end
+          end
+
+          # match original visibility
+          send(visibility, method_name)
+        end
+      end
+      nil
+    end
+
+    # Instrument all methods, public, protected, and private, other than `initialize`.
+    # This will also instrument any methods defined in this class after it's called, meaning
+    # you can it at the top of the class.  Do note that this will not instrument any
+    # methods brought in via modules.
+    def instrument_all
+      @__instrument_all = true
+      method_names = instance_methods(false) + private_instance_methods(false) - [ :initialize ]
+
+      instrument(*method_names)
+
+      nil
+    end
+
+    # Instrument all public and protected methods, other than `initialize`.
+    # This will also instrument any public or protected methods defined in this class after it's called,
+    # meaning you can it at the top of the class.  Do note that this will not instrument any
+    # methods brought in via modules.
+    def instrument_public
+      @__instrument_public = true
+      method_names = instance_methods(false) - [ :initialize ]
+
+      instrument(*method_names)
+
+      nil
+    end
+
+    def method_added(meth)
+      if !@__instrument_all && !@__instrument_public
+        return
+      end
+      if @__adding__
+        return
+      end
+      if meth == :initialize
+        return
+      end
+      if !@__instrument_all && private_instance_methods(false).include?(meth)
+        return
+      end
+
+      @__adding__ = true
+      instrument(meth)
+      @__adding__ = false
+    end
+  end
+end
+

data/lib/brut/instrumentation/open_telemetry.rb

@@ -25,6 +25,7 @@ class Brut::Instrumentation::OpenTelemetry
         result = block.(wrapped_span)
       rescue => ex
         span.record_exception(ex)
+        span.status = OpenTelemetry::Trace::Status.error("Unhandled exception: #{ex.class}")
         raise
       end
     end

data/lib/brut/instrumentation.rb

@@ -4,5 +4,6 @@
 module Brut::Instrumentation
   autoload(:OpenTelemetry,"brut/instrumentation/open_telemetry")
   autoload(:LoggerSpanExporter,"brut/instrumentation/logger_span_exporter")
+  autoload(:Methods,"brut/instrumentation/methods")
 end
 

data/lib/brut/version.rb

@@ -1,4 +1,4 @@
 module Brut
   # @!visibility private
-  VERSION = "0.10.0"
+  VERSION = "0.12.0"
 end

data/mkbrut/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mkbrut (0.10.0)
+    mkbrut (0.12.0)
 
 GEM
   remote: https://rubygems.org/

data/mkbrut/bin/publish

@@ -67,7 +67,7 @@ setup_docker_buildx() {
 detect_gem_version() {
 
   GEM_VERSION=$( rake -T | grep "rake install " | sed 's/^.*mkbrut-//g' | sed 's/\.gem.*$//g')
-  if [[ "$GEM_VERSION" =~ ^[0-9]+\.[0-9]\.[0-9]+$ ]]; then
+  if [[ "$GEM_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
     log "Releasing version ${GEM_VERSION}"
   else
     log "Version '${GEM_VERSION}' does not look like a version: X.Y.Z"

data/mkbrut/lib/mkbrut/version.rb

@@ -1,3 +1,3 @@
 module MKBrut
-  VERSION = "0.10.0"
+  VERSION = "0.12.0"
 end