brut 0.0.26 → 0.0.28

data/lib/brut/cli/apps/heroku_container_based_deploy.rb

@@ -0,0 +1,194 @@
+require "brut/cli"
+class Brut::CLI::Apps::HerokuContainerBasedDeploy < Brut::CLI::Apps::DeployBase
+  description "Deploy to Heroku using containers"
+  default_command :deploy
+  configure_only!
+
+  class Deploy < Brut::CLI::Command
+    description "Build images, push them to Heroku, and deploy them"
+
+    detailed_description %{
+Manages a deploy process based on using Heroku's Container Registry. See
+
+    https://devcenter.heroku.com/articles/container-registry-and-runtime
+
+    for details. You are assumed to understand this.  This command will make the process somewhat easier.
+
+    This will use deploy/Dockerfile as a template to create one Dockerfile for each process you want to run in Heroku.  deploy/heroku_config.rb is where the processes and their commands are configured.
+
+    The release phase is included automatically, based on bin/release.
+}
+
+    opts.on("--platform=PLATFORM","Override default platform. Can be any Docker platform.")
+    opts.on("--[no-]dry-run", "Print the commands that would be run and don't actually do anything. Implies --skip-checks")
+    opts.on("--[no-]skip-checks", "Skip checks for code having been committed and pushed")
+    opts.on("--[no-]deploy", "After images are pushed, actually deploy them")
+    opts.on("--[no-]push", "After images are created, push them to Heroku's registry. If false, implies --no-deploy")
+
+    def after_bootstrap(app:)
+      @app_id       = app.id
+      @organization = app.organization
+    end
+
+    def execute
+      options.set_default(:deploy, true)
+      options.set_default(:push, true)
+      if !options.push?
+        options[:deploy] = false
+      end
+      local_repo_checks = Brut::CLI::Apps::DeployBase::GitChecks.new(
+        out: @out,
+        err: @err,
+        executor: @executor,
+        warn_only: options.skip_checks? || options.dry_run?
+      )
+      if options.dry_run?
+        def system!(*args)
+          out.puts "DRY RUN, NOT EXECUTING '#{args}'"
+        end
+      end
+
+      version = begin
+                  git_guess = %{git rev-parse HEAD}
+                  stdout, stderr, status = Open3.capture3(git_guess)
+                  if status.success?
+                    stdout.strip
+                  else
+                    raise "Attempt to use git via command '#{git_guess}' to figure out the version failed: #{stdout}#{stderr}"
+                  end
+                end
+      short_version = version[0..7]
+
+      platform = options.platform || "linux/amd64"
+      heroku_app_name = @app_id
+
+      out.puts "Reading HerokuConfig:"
+      require_relative Brut.container.project_root / "deploy" / "heroku_config"
+
+      additional_images = HerokuConfig.additional_images.map { |name,config|
+        cmd = config.fetch(:cmd)
+        out.puts "  - #{name} will run #{cmd} in production"
+        image_name = %{#{@organization}/#{@app_id}:#{short_version}-#{name}}
+        [
+          name,
+          {
+            cmd:,
+            image_name:,
+            dockerfile: "deploy/Dockerfile.#{name}",
+            heroku_image_name: "registry.heroku.com/#{heroku_app_name}/#{name}",
+          }
+        ]
+      }.to_h
+
+      images = {
+        "web" => {
+          cmd: "bin/run",
+          image_name: %{#{@organization}/#{@app_id}:#{short_version}-web},
+          dockerfile: "deploy/Dockerfile.web",
+          heroku_image_name: "registry.heroku.com/#{heroku_app_name}/web",
+        },
+        "release" => {
+          cmd: "bin/release",
+          image_name: %{#{@organization}/#{@app_id}:#{short_version}-release},
+          dockerfile: "deploy/Dockerfile.release",
+          heroku_image_name: "registry.heroku.com/#{heroku_app_name}/release",
+        },
+      }.merge(additional_images)
+
+      out.puts "  - release will run bin/release in production"
+
+      local_repo_checks.check!
+require_heroku_login!(options)
+
+      FileUtils.chdir Brut.container.project_root do
+
+        out.puts "Generating Dockerfiles"
+        images.each do |name,metadata|
+          cmd        = metadata.fetch(:cmd)
+          dockerfile = metadata.fetch(:dockerfile)
+
+          out.puts "Creating '#{dockerfile}' for '#{name}' that will use command '#{cmd}'"
+
+          File.open(dockerfile,"w") do |file|
+            file.puts "# DO NOT EDIT - THIS IS GENERATED"
+            file.puts "# To make changes, modifiy deploy/Dockerfile and run #{$0}"
+            file.puts File.read("deploy/Dockerfile")
+            file.puts
+            file.puts "# Added by #{$0}"
+            file.puts %{CMD [ "bundle", "exec", "#{cmd}" ]}
+          end
+        end
+
+        out.puts "Building images"
+        docker_quiet_option = if global_options.log_level != "debug"
+                                "--quiet"
+                              else
+                                ""
+                              end
+        images.each do |name,metadata|
+          image_name = metadata.fetch(:image_name)
+          dockerfile = metadata.fetch(:dockerfile)
+
+
+          out.puts "Creating docker image with name '#{image_name}' and platform '#{platform}'"
+          command = %{docker build #{docker_quiet_option} --build-arg app_git_sha1=#{version} --file #{Brut.container.project_root}/#{dockerfile} --platform #{platform} --tag #{image_name} .}
+          system!(command)
+        end
+
+        out.puts "Taggging images for Heroku"
+        images.each do |name,metadata|
+          image_name        = metadata.fetch(:image_name)
+          heroku_image_name = metadata.fetch(:heroku_image_name)
+
+          out.puts "Tagging '#{image_name}' with '#{heroku_image_name}' for Heroku"
+          command = %{docker tag #{image_name} #{heroku_image_name}}
+          system!(command)
+        end
+
+        if options.push?
+          out.puts "Pushing to Heroku Registry"
+          images.each do |name,metadata|
+            heroku_image_name = metadata.fetch(:heroku_image_name)
+
+            out.puts "Pushing '#{heroku_image_name}'"
+
+            command = %{docker push #{docker_quiet_option} #{heroku_image_name}}
+            system!(command)
+          end
+        else
+          out.puts "Not pushing images"
+        end
+
+        names = images.map(&:first).join(" ")
+        deploy_command = "heroku container:release #{names}"
+        if options.deploy?
+          out.puts "Deploying images to Heroku"
+          system!(deploy_command)
+        else
+          out.puts "Not deploying.  To deploy the images just pushed:"
+          out.puts ""
+          out.puts "  #{deploy_command}"
+        end
+      end
+    end
+  private
+    def require_heroku_login!(options)
+      if system("heroku whoami")
+        out.puts "You are logged in to Heroku"
+      else
+        out.puts "You are not logged into Heroku."
+        out.puts "Please run the following:"
+        out.puts ""
+        out.puts "heroku auth:login"
+        out.puts "heroku container:login"
+        out.puts ""
+        out.puts "Then, re-run this"
+        if options.dry_run?
+          out.puts "Dry run - ignoring"
+          return
+        end
+        exit 1
+      end
+    end
+  end
+end

data/lib/brut/cli/apps/test.rb

@@ -133,7 +133,8 @@ class Brut::CLI::Apps::Test < Brut::CLI::App
           test_expected: true,
         }
         if pathname.fnmatch?( (Brut.container.components_src_dir / "**").to_s )
-          if pathname.basename.to_s == "app_component.rb"
+          if pathname.basename.to_s == "app_component.rb" || 
+             pathname.basename.to_s == "custom_element_registration.rb"
             hash[:type] = :infrastructure
             hash[:test_expected] = false
           else

data/lib/brut/cli/command.rb

@@ -198,6 +198,13 @@ class Brut::CLI::Command
   def before_execute
   end
 
+  # Called after all setup has been executed. Brut will have been started/loaded.
+  # This will *not* be called if anything caused execution to be aborted.
+  #
+  # @param [Brut::Framework::App] app Your Brut app.
+  def after_bootstrap(app:)
+  end
+
   # @!visibility private
   def set_env_if_needed
     if self.class.requires_project_env?
@@ -219,19 +226,6 @@ class Brut::CLI::Command
     raise ex
   end
 
-  # @!visibility private
-  def bootstrap!(project_root:, configure_only:)
-    require "bundler"
-    Bundler.require(:default, ENV["RACK_ENV"].to_sym)
-    if configure_only
-      require "#{project_root}/app/pre_boot"
-      Brut::Framework.new(app: ::App.new)
-    else
-      require "#{project_root}/app/boot"
-    end
-    continue_execution
-  end
-
 private
 
   # @!visibility public

data/lib/brut/cli/executor.rb

@@ -16,14 +16,40 @@ class Brut::CLI::Executor
     @err = err
   end
 
-  # Execute a command, logging it to the standard output and outputing the commands output and error to the standard output and error,
-  # respecitively
+  # Execute a command, logging it to the standard output and outputing the 
+  # commands output and error to the standard output and error, respectively. If 
+  # the command exits nonzero, the exit status is returned.
+  #
+  # Generally, you want to use {#system!} for commands that must succeed
+  # for the caller to continue.  Only use this method if you need 
+  # to do special error-handling when the underlying command fails.
+  #
+  # @see https://docs.ruby-lang.org/en/3.3/Open3.html#method-c-popen3
+  # @see #system!
+  #
+  # @param [String|Array] args Whatever you would give to `Kernel#system` or `Open3.popen3`.
+  # @return [int] 0 if the command completed normally, otherwise the nonzero exit status. **DO NOT TREAT THIS AS A BOOLEAN VALUE**
+  def system(*args)
+    self.system!(*args)
+    0
+  rescue Brut::CLI::SystemExecError => e
+    e.exit_status
+  end
+
+  # Execute a command, logging it to the standard output and outputing the 
+  # commands output and error to the standard output and error, respectively. If 
+  # the command exits nonzero, an exception is raised and your CLI app will
+  # also exit nonzero.
+  #
+  # If you need to handle  the command exiting nonzero, use {#system}
+  # instead, as it will not raise an exception.
   #
   # @see https://docs.ruby-lang.org/en/3.3/Open3.html#method-c-popen3
+  # @see #system
   #
   # @param [String|Array] args Whatever you would give to `Kernel#system` or `Open3.popen3`.
-  # @raise Brut::CLI::Error::SystemExecError if the spawed command exits nonzer
-  # @return [true]
+  # @raise Brut::CLI::Error::SystemExecError if the spawed command exits nonzero
+  # @return [int] Always returns 0
   def system!(*args)
     @out.puts "Executing #{args}"
     wait_thread = Open3.popen3(*args) do |_stdin,stdout,stderr,wait_thread|
@@ -52,6 +78,6 @@ class Brut::CLI::Executor
     else
       raise Brut::CLI::SystemExecError.new(args,wait_thread.value.exitstatus)
     end
-    true
+    0
   end
 end

data/lib/brut/cli/options.rb

@@ -12,6 +12,10 @@ class Brut::CLI::Options
   # Access an options value directly.
   # @param [String] key the key to use. This must be the exact name you used when calling `opts.on` or when creating the `OptionParser` for your app or command. Generally, use the {#method_missing}-provided version instead of this.
   def [](key) = @parsed_options[key]
+
+  def []=(key,value)
+    @parsed_options[key] = value
+  end
   # Check if `key` was provided on the command line.
   # @param [String] key the key to use. This must be the exact name you used when calling `opts.on` or when creating the `OptionParser` for your app or command.
   def key?(key) = @parsed_options.key?(key)

data/lib/brut/cli.rb

@@ -42,9 +42,10 @@ module Brut
     # Holds Brut-provided CLI apps that are set up in your project.
     module Apps
       autoload(:DB,"brut/cli/apps/db")
-      autoload(:DB,"brut/cli/apps/test")
-      autoload(:DB,"brut/cli/apps/build_assets")
-      autoload(:DB,"brut/cli/apps/scaffold")
+      autoload(:Test,"brut/cli/apps/test")
+      autoload(:BuildAssets,"brut/cli/apps/build_assets")
+      autoload(:Scaffold,"brut/cli/apps/scaffold")
+      autoload(:DeployBase,"brut/cli/apps/deploy_base")
     end
   end
 end

data/lib/brut/framework/container.rb

@@ -78,7 +78,7 @@ class Brut::Framework::Container
     self.validate_name!(name:,type:,allow_app_override:)
     if value == :use_block
       derive_with = block
-      @container[name] = { value: nil, derive_with: derive_with }
+      @container[name] = { derive_with: derive_with }
     else
       if type == :boolean
         value = !!value
@@ -111,9 +111,11 @@ class Brut::Framework::Container
       raise ArgumentError,"#{name} does not allow the app to override it"
     end
     if value == :use_block
-      @container[name] = { value: nil, derive_with: block }
+      @container[name][:derive_with] = block
+      @container[name].delete(:value)
     else
-      @container[name] = { value: value }
+      @container[name][:value] = value
+      @container[name].delete(:derive_with)
     end
   end
 
@@ -191,16 +193,16 @@ class Brut::Framework::Container
     # TODO: Provide a cleanr impl and better error checking if things go wrong
     x = @container.fetch(name)
 
-    value = x[:value]
+    has_value = x.key?(:value)
 
-    if !value.nil? || (x[:allow_nil] && value.nil?)
+    if has_value
       handle_path_values(name,x)
-      return value
+      return x[:value]
     end
 
     deriver = x[:derive_with]
     if deriver.nil?
-      raise "Something is seriously wrong. '#{name}' was stored in container without a derive_with value"
+      raise "Something is seriously wrong. '#{name}' was stored in container without a static value, but also without a derive_with key"
     end
 
     parameters = deriver.parameters(lambda: true)
@@ -218,6 +220,22 @@ class Brut::Framework::Container
     handle_path_values(name,x)
     x[:value]
   end
+
+  def reload
+    @container.each do |name, contained_value|
+      if contained_value.key?(:value) && contained_value[:type].to_s == "Class"
+        if contained_value.key?(:derive_with)
+          contained_value.delete(:value)
+        else
+          klass = contained_value[:value]
+          new_klass = klass.name.split(/::/).reduce(Module) { |mod,part|
+            mod.const_get(part)
+          }
+          contained_value[:value] = new_klass
+        end
+      end
+    end
+  end
 private
 
   def handle_path_values(name,contained_value)

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

@@ -2,4 +2,11 @@
 # 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(method_name=nil)
+    if method_name
+      super("The method `#{method_name}` must be implemented")
+    else
+      super("An abstract method must be implemented")
+    end
+  end
 end

data/lib/brut/framework/errors.rb

@@ -27,9 +27,11 @@ module Brut
       # a method that a subclass must implement, but for which there is no useful default
       # implementation.
       #
+      # @param [String|Symbol] method_name name of the method that must be implemented. If omitted, the value is guessed from `caller_locations`
       # @raise [Brut::Framework::Errors::AbstractMethod]
-      def abstract_method!
-        raise Brut::Framework::Errors::AbstractMethod
+      def abstract_method!(method_name=nil)
+        method_name ||= caller_locations(1,1)[0].label
+        raise Brut::Framework::Errors::AbstractMethod.new(method_name)
       end
     end
     # Base class for errors thrown by Brut classes. Generally, Brut will not create its own version

data/lib/brut/front_end/component.rb

@@ -1,6 +1,22 @@
 require "phlex"
 
-# Components holds Brut-provided components that are of general use to any web app
+# Namespace for Brut-provided components that are of general use to any web app.
+# Also extends [`Phlex:::Kit`](https://www.phlex.fun/components/kits.html), meaning
+# you can include this module in your pages and components to be able to 
+# create Brut's components without `.new` or without the full classname:
+#
+# @example
+#   class AppPage < Brut::FrontEnd::Page
+#     include Brut::FrontEnd::Components
+#   end
+#
+#   class HomePage < AppPage
+#     def page_template
+#     h1 do
+#       span { "It's }
+#       TimeTag(timestamp: Time.now)
+#     end
+#   end
 module Brut::FrontEnd::Components
   autoload(:FormTag,"brut/front_end/components/form_tag")
   autoload(:Input,"brut/front_end/components/input")
@@ -72,16 +88,24 @@ class Brut::FrontEnd::Component < Phlex::HTML
       }
     end
 
-    # Return a component that you would like Brut to instantiate.
-    # This will use keyword injection to create the component, which means that if the component
-    # doesn't require any data from this component, you do not need to pass through those values.
-    # For example, you may have a component that renders the flash message.  To avoid requiring your component to
-    # be passed the flash, a global component can be injected with it from Brut.
+    # Render (in Phlex parlance) a component that you would like Brut to
+    # instantiate.  This is useful when you want to use a component that
+    # only requires values from the {Brut::FrontEnd::RequestContext}. By
+    # using this method, *this* component does not have to receive
+    # data from the {Brut::FrontEnd::RequestContext} that only serves to pass
+    # to the component you use here.
+    #
+    # For example, you may have a component that renders the flash message.  To avoid requiring *this* component/page to be passed the flash, a global component can be injected with it from Brut.
+    #
+    # This component *will* be rendered into the Phlex context. Do not call
+    # `render` on the result, nor rely on the return value.
     #
-    # @return [Object] instance of `component_klass`, as created by Brut. This will
-    #         not render the component.
+    # @param [Class] component_klass the component class to use in the view.
+    #        This class's
+    #        initializer must only require information available from the 
+    #        {Brut::FrontEnd::RequestContext}.
     def global_component(component_klass)
-      Brut::FrontEnd::RequestContext.inject(component_klass)
+      render Brut::FrontEnd::RequestContext.inject(component_klass)
     end
   end
   include Helpers

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

@@ -27,14 +27,14 @@ class Brut::FrontEnd::Components::Inputs::SelectTagWithOptions < Brut::FrontEnd:
   #        to be used as the `value` attribute and option text content, respectively.
   #
   # @return [Brut::FrontEnd::Components::Inputs::SelectTagWithOptions] the select input ready to be placed into a view.
-  def self.for_form_input(form:,
-                          input_name:,
-                          options:,
-                          include_blank: false,
-                          value_attribute:,
-                          option_text_attribute:,
-                          index: nil,
-                          html_attributes: {})
+  def initialize(form:,
+                 input_name:,
+                 options:,
+                 include_blank: false,
+                 value_attribute:,
+                 option_text_attribute:,
+                 index: nil,
+                 html_attributes: {})
     html_attributes = html_attributes.map { |key,value| [ key.to_sym, value ] }.to_h
     default_html_attributes = {}
     index ||= 0
@@ -54,84 +54,26 @@ class Brut::FrontEnd::Components::Inputs::SelectTagWithOptions < Brut::FrontEnd:
              input.name
            end
 
-    Brut::FrontEnd::Components::Inputs::SelectTagWithOptions.new(
-      name: name,
-      options:,
-      selected_value: input.value,
-      value_attribute:,
-      option_text_attribute:,
-      include_blank:,
-      html_attributes: default_html_attributes.merge(html_attributes)
-    )
-  end
+    input_value = input.value
 
-  # Create the element.
-  #
-  # @param [String] name the name of the input
-  # @param [Array<Object>] options An array of objects represented what is being selected.
-  #        These can be any object and are ideally whatever domain object or
-  #        data type you want on the backend to represent this selection.
-  # @param [Symbol|String] value_attribute the name of an attribute to determine an option's value.
-  #        This will be called on each element of `options` to get the value used for the `<option>`'s
-  #        `value` attribute.  The value returned by `value_attribute` should be unique amongst the
-  #        `options` provided *and* be distinct from whatever `value` is used for `include_blank`.
-  # @param [String] selected_value the value of the selected option. Note that this is the *value*
-  #        of the selected option, not the selected option itself. To set the selected value
-  #        based on a selected option, omit this and use `selected_option`
-  # @param [String] selected_option the selected option. Note that `value_attribute` will be called
-  #        on this to determine the selected value to use when generating HTML. Also note that
-  #        this object must be in `options` or an exeception is raised.
-  # @param [Symbol|String] option_text_attribute the name of an attribute to determine the text for an option.
-  #        This will be called on each element of `options` to get the value used for the `<option>`'s
-  #        text content.  The value returned by `option_text_attribute` need not be unique, though if it
-  #        is not unique, it will certainly be confusing.
-  # @param [Hash] html_attributes any additional HTML attributes to include on the `<select>` element.
-  # @param [false|true|Hash] include_blank configure how and if to include a blank element in the select.
-  #        If this is false, there will be no blank element. If it's `true`, there will be one with
-  #        no value or text.  If this is a `Hash` it must contain a `value:` key and a `text_content:` key
-  #        to be used as the `value` attribute and option text content, respectively.
-  #
-  # @raise ArgumentError if `selected_option` is present, but not in `options` or if `selected_value` is
-  #        present, but no option's value for `value_attribute` is that value.
-  #
-  # XXX: Why does this not ask the form for the selected_value?
-  # XXX: This doesn't do well when values are strings
-  def initialize(name:,
-                 options:,
-                 value_attribute:,
-                 selected_value: nil,
-                 selected_option: nil,
-                 option_text_attribute:,
-                 include_blank: false,
-                 html_attributes:)
     @options                = options
     @include_blank          = IncludeBlank.from_param(include_blank)
     @value_attribute        = value_attribute
     @option_text_attribute  = option_text_attribute
-    @html_attributes        = html_attributes
+    @html_attributes        = default_html_attributes.merge(html_attributes)
     @html_attributes[:name] = name
 
-    if selected_value.nil?
-      if selected_option.nil?
-        @selected_value = nil # explicitly nothing is selected
-      else
-        option = options.detect { |option|
-          option.send(@value_attribute) == selected_option.send(@value_attribute)
-        }
-        if option.nil?
-          raise ArgumentError, "selected_option #{selected_option} (with #{value_attribute} '#{selected_option.send(value_attribute)}') was not found in options"
-        end
-        @selected_value = option.send(@value_attribute)
-      end
+    if input_value.nil?
+      @selected_value = nil # explicitly nothing is selected
     else
-      if selected_value.kind_of?(Array)
-        raise "WTF: #{name}"
+      if input_value.kind_of?(Array)
+        raise "WTF: #{name}" # XXX?
       end
       option = options.detect { |option|
-        selected_value == option.send(@value_attribute)
+        input_value == option.send(@value_attribute)
       }
       if option.nil?
-        raise ArgumentError, "selected_value #{selected_value} was not the value for #{value_attribute} on any of the options: #{options.map { |option| option.send(value_attribute) }.join(', ')}"
+        raise ArgumentError, "selected_value #{input_value} was not the value for #{value_attribute} on any of the options: #{options.map { |option| option.send(value_attribute) }.join(', ')}"
       end
       @selected_value = option.send(@value_attribute)
     end

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

@@ -2,22 +2,6 @@
 # form-related classes.
 class Brut::FrontEnd::Forms::ConstraintViolation
 
-  # These are underscorized versions of the attributes of the browser's `ValidityState`'s properties.
-  #
-  # @see https://developer.mozilla.org/en-US/docs/Web/API/ValidityState
-  CLIENT_SIDE_KEYS = [
-    "bad_input",
-    "custom_error",
-    "pattern_mismatch",
-    "range_overflow",
-    "range_underflow",
-    "step_mismatch",
-    "too_long",
-    "too_short",
-    "type_mismatch",
-    "value_missing",
-  ]
-
   # @return [String] the key fragment representing the violation
   attr_reader :key
   # @return [Hash] interpolated values useful in rendering the actual message
@@ -27,11 +11,11 @@ class Brut::FrontEnd::Forms::ConstraintViolation
   #
   # @param [String|Symbol] key I18n key fragment representing this violation.
   # @param [Hash|nil] context interpolated values useful in rendering the message
-  # @param [true|:based_on_key] server_side If `:based_on_key`, {#client_side?} will return true if `key` is in {.CLIENT_SIDE_KEYS}.
+  # @param [true|:based_on_key] server_side If `:based_on_key`, {#client_side?} will return true if `key` is in {ValidityState.KEYS}.
   # If `true`, {#client_side?} will return false no matter what.
   def initialize(key:,context:, server_side: :based_on_key)
     @key = key.to_s
-    @client_side = CLIENT_SIDE_KEYS.include?(@key) && server_side != true
+    @client_side = Brut::FrontEnd::Forms::ValidityState::KEYS.include?(@key) && server_side != true
     @context = context || {}
     if !@context.kind_of?(Hash)
       raise "#{self.class} created for key #{key} with an invalid context: '#{context}/#{context.class}'. Context must be nil or a hash"

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

@@ -82,14 +82,14 @@ class Brut::FrontEnd::Forms::Input
     step_mismatch = false
 
     @validity_state = Brut::FrontEnd::Forms::ValidityState.new(
-      value_missing: missing,
-      too_short: too_short,
-      too_long: too_short,
-      range_overflow: range_overflow,
-      range_underflow: range_underflow,
-      pattern_mismatch: pattern_mismatch,
-      step_mismatch: step_mismatch,
-      type_mismatch: type_mismatch,
+      valueMissing: missing,
+      tooShort: too_short,
+      tooLong: too_short,
+      rangeOverflow: range_overflow,
+      rangeUnderflow: range_underflow,
+      patternMismatch: pattern_mismatch,
+      stepMismatch: step_mismatch,
+      typeMismatch: type_mismatch,
     )
     @value = new_value
   end

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

@@ -12,8 +12,8 @@ module Brut::FrontEnd::Forms::InputDeclarations
   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
-  # {Brut::FrontEnd::Components::Inputs::Select.for_form_input}
+  # in the select.  That is done when the select is rendered, which you might do with a
+  # {Brut::FrontEnd::Components::Inputs::Select}
   #
   # @param [String] name The name of the input (used in the `name` attribute)
   # @param [Hash] attributes Attributes to be used on the tag that represent its contraints. See {Brut::FrontEnd::Forms::SelectInputDefinition}
@@ -28,7 +28,7 @@ module Brut::FrontEnd::Forms::InputDeclarations
   # input tags.
   #
   # Note that this is not where you would define the possible values for the group. That is done in
-  # {Brut::FrontEnd::Components::Inputs::RadioButton.for_form_input}.
+  # {Brut::FrontEnd::Components::Inputs::RadioButton}.
   #
   # @param [String] name The name of the group (used in the `name` attribute)
   # @param [Hash] attributes Attributes to be used on the tag that represent its contraints. See {Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition}