brut 0.0.27 → 0.0.29

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

@@ -1,12 +1,54 @@
+require "uri"
+
 # An Input is a stateful object representing a specific input and its value
 # during the course of a form submission process. In particular, it wraps a value
-# and a {Brut::FrontEnd::Forms::ValidityState}. These are mutable, whereas the wrapped {Brut::FrontEnd::Forms::InputDefinition} is not.
+# and a {Brut::FrontEnd::Forms::ValidityState}. These are mutable, whereas
+# the wrapped {Brut::FrontEnd::Forms::InputDefinition} is not.
+#
+# Of note, this class also initiates the server-execution of the
+# client-side validations.  When a form is posted, and you ask the form 
+# to validate itself, this class examines the value for the inputs
+# and determines if a client-side violation should've happened in the browser.
+#
+# It does its best to mimic the browser's behavior, however there will be
+# some subtle differences.
+#
+# An important considering is that everything is a string.  The browser wants
+# strings and its internal API is string-based.  So is this.  That said, 
+# this will convert strings into richer types in order to perform constraint
+# analysis.
+#
+# Where possible, standard library classes are used, but in some cases - 
+# colors and times - there is no standard library class.
+#
+# See {#typed_value}.
 class Brut::FrontEnd::Forms::Input
 
   extend Forwardable
 
-  # @return [String] the input's value
+  # @return [String] the input's value. **DO NOTE** this returns a string.  This is
+  #         because HTML stores these values as Strings.  When using a checkbox, in
+  #         particular, the value will *not* be a boolean. You cannot do `if
+  #         input.value` and expect that work. See {#typed_value} instead.
   attr_reader :value
+
+  # @return [Date|Time|BigDecimal|String|true|false|nil] the value of the input,
+  #         as coerced to the type used to evaluate constraints.
+  #         Returns `nil` if the value could not be coerced (which likely means
+  #         there is or will be a constraint violation), **or**
+  #         if it is a blank String.
+  #
+  #         Of note, `type=color` will return a String here, but that String
+  #         should be parseable into a hex code, i.e. #XXXXXX, where each "X"
+  #         is 0-9 or a-f.  Further, `type=time` will also return a string
+  #         in the format HH:MM or HH:MM:SS, where the time is in 24 hour
+  #         time.  Lastly, `type=datetime-local` will return a `Time`, even
+  #         though the control allows the visitor to choose an invalid time.
+  #         If there is no `valueMissing` constraint violation, but this
+  #         attribute returns `nil`, {#value} *will* return the string sent by 
+  #         the browser, even if it's not a real timestamp.
+  attr_reader :typed_value
+
   # @return [Brut::FrontEnd::Forms::ValidityState] Validity state that captures the current constraint violations, if any
   attr_reader :validity_state
 
@@ -20,6 +62,46 @@ class Brut::FrontEnd::Forms::Input
     self.value=(value)
   end
 
+  # @!method max
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method maxlength
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method min
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method minlength
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method name
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method pattern
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method required
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method step
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method type
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
+  # @!method array?
+  # @return [String|nil] the value from the `input_definition` given to the
+  #         initializer
+
   def_delegators :"@input_definition", :max,
                                        :maxlength,
                                        :min,
@@ -37,14 +119,52 @@ class Brut::FrontEnd::Forms::Input
   #
   # When this method completes, the value of {#validity_state} could change.
   #
-  # @param [String] new_value the value for the input.  Empty strings are coerced to `nil`
+  # @param [String] new_value the value for the input. Any non-String value will
+  #                 be coerced to a String via `to_s`.
   def value=(new_value)
-    if new_value.kind_of?(String) && new_value.strip == ""
-      new_value = nil
+    new_value = new_value.to_s
+    @typed_value = case self.type
+                  when "number"
+                    BigDecimal(new_value, exception: false)
+                  when "range"
+                    BigDecimal(new_value, exception: false)
+                  when "checkbox"
+                    new_value == "true"
+                  when "color"
+                    Color.from_hex_string(new_value)&.to_s
+                  when "date"
+                    begin
+                      Date.parse(new_value)
+                    rescue
+                      nil
+                    end
+                  when "time"
+                    TimeOfDay.from_string(new_value)
+                  when "datetime-local"
+                    begin
+                      Time.parse(new_value)
+                    rescue
+                      nil
+                    end
+                  when "url"
+                    begin
+                      URI(new_value)
+                    rescue
+                      nil
+                    end
+                  else
+                    new_value.strip == "" ? nil : new_value
+                  end
+
+    if type == "hidden" || type == "file"
+      @value = new_value
+      return
     end
-    value_missing = new_value.nil? || (new_value.kind_of?(String) && new_value.strip == "")
+
+    value_missing = new_value.strip == "" || @typed_value.nil?
+
     missing = if self.required
-                value_missing
+                value_missing || @typed_value == false
               else
                 false
               end
@@ -60,38 +180,81 @@ class Brut::FrontEnd::Forms::Input
                  false
                end
 
-    type_mismatch = false # TBD
-
-    range_overflow = if self.max && !value_missing && !type_mismatch
-                       new_value.to_i > self.max
+    range_overflow = if self.max && !value_missing
+                       if type == "date"
+                         max_date = Date.parse(self.max)
+                         @typed_value > max_date
+                       elsif type == "datetime-local"
+                         max_date = Time.parse(self.max)
+                         @typed_value > max_date
+                       elsif type == "time"
+                         max_time = TimeOfDay.from_string(self.max)
+                         @typed_value > max_time
+                       else
+                         new_value.to_i > self.max
+                       end
                      else
                        false
                      end
 
-    range_underflow = if self.min && !value_missing && !type_mismatch
-                       new_value.to_i < self.min
+    range_underflow = if self.min && !value_missing
+                        if type == "date"
+                          min_date = Date.parse(self.min)
+                          @typed_value < min_date
+                        elsif type == "datetime-local"
+                          min_date = Time.parse(self.min)
+                          @typed_value < min_date
+                        elsif type == "time"
+                          min_time = TimeOfDay.from_string(self.min)
+                          @typed_value < min_time
+                        else
+                          new_value.to_i < self.min
+                        end
                      else
                        false
                      end
 
-    pattern_mismatch = if self.pattern && !value_missing && !type_mismatch
+    pattern_mismatch = if self.pattern && !value_missing
                          !new_value.match?(Regexp.new(self.pattern))
-                       else
-                         false
+                       elsif type == "url" && !value_missing
+                         @typed_value.nil? || !@typed_value.absolute
                        end
-    step_mismatch = false
+    step_mismatch = if self.step && !value_missing
+                      step_big_decimal = BigDecimal(self.step.to_s)
+                      if type == "date"
+                        basis_date = self.min ? Date.parse(self.min) : Date.parse("1970-01-01")
+                        num_days = (@typed_value - basis_date)
+                        num_days % step_big_decimal != 0
+                      elsif type == "datetime-local"
+                        basis_time = self.min ? Time.parse(self.min) : Time.parse("1970-01-01T00:00:00")
+                        num_seconds = (@typed_value - basis_time)
+                        num_seconds % step_big_decimal != 0
+                      elsif type == "time"
+                        basis_time = self.min ? TimeOfDay.from_string(self.min) : TimeOfDay.new(hour: 0, minute: 0, second: 0)
+                        num_seconds = (@typed_value - basis_time)
+                        num_seconds % step_big_decimal != 0
+                      else
+                        @typed_value % step_big_decimal != 0
+                      end
+                    end
+
+    if type == "range" || type == "color"
+      missing = false
+    elsif type == "time"
+      @typed_value = @typed_value&.to_s
+    end
 
     @validity_state = Brut::FrontEnd::Forms::ValidityState.new(
       valueMissing: missing,
       tooShort: too_short,
-      tooLong: too_short,
+      tooLong: too_long,
       rangeOverflow: range_overflow,
       rangeUnderflow: range_underflow,
       patternMismatch: pattern_mismatch,
       stepMismatch: step_mismatch,
-      typeMismatch: type_mismatch,
+      typeMismatch: false,
     )
-    @value = new_value
+    @value = value_missing ? nil : new_value
   end
 
   # Set a server-side constraint violation on this input.  This is essentially arbitrary, but note
@@ -105,4 +268,74 @@ class Brut::FrontEnd::Forms::Input
 
   # @return [true|false] true if the underlying {#validity_state} has no constraint violations
   def valid? = @validity_state.valid?
+
+  class Color
+    def self.from_hex_string(string)
+      string = string.to_s
+      if string.match?(/\A#[0-9a-fA-F]{6}\z/)
+        string.downcase
+      else
+        nil
+      end
+    end
+  end
+
+  class TimeOfDay
+    include Comparable
+    def self.from_string(string)
+      match_data = string.match(/\A([01]?[0-9]|2[0-3]):([0-5][0-9])(:([0-5][0-9]))?\z/)
+      if match_data
+        hour = match_data[1].to_i
+        minute = match_data[2].to_i
+        second = match_data[4] ? match_data[4].to_i : nil
+        self.new(hour:, minute:, second:)
+      else
+        nil
+      end
+    end
+
+    def initialize(hour:, minute:, second:)
+      @hour   = in_range!(hour,   0, 23, "hour")
+      @minute = in_range!(minute, 0, 59, "minute")
+      @second = second.nil? ? nil : in_range!(second, 0, 59, "second")
+    end
+
+    def to_s
+      if @second.nil?
+        sprintf("%02d:%02d", @hour, @minute)
+      else
+        sprintf("%02d:%02d:%02d", @hour, @minute, @second)
+      end
+    end
+
+    def to_seconds
+      (@second ||    0) + 
+      (@minute  *   60) + 
+      (@hour    * 3600)
+    end
+
+    def -(other)
+      if other.kind_of?(self.class)
+        self.to_seconds - other.to_seconds
+      else
+        raise ArgumentError, "Cannot subtract #{other.class} from TimeOfDay"
+      end
+    end
+
+    def <=>(other)
+      return -1 if !other.kind_of?(self.class)
+      self.to_seconds <=> other.to_seconds
+    end
+
+  private
+
+    def in_range!(value, min, max, name)
+      if value < min || value > max
+        raise ArgumentError, "Invalid #{name} '#{value}' (must be between #{min} and #{max})"
+      end
+      value
+    rescue ArgumentError => e
+      raise ArgumentError, "Invalid TimeOfDay: #{e.message}"
+    end
+  end
 end

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

@@ -22,12 +22,11 @@ class Brut::FrontEnd::Forms::InputDefinition
   INPUT_TYPES_TO_CLASS = {
     "checkbox"       => String,
     "color"          => String,
-    "date"           => String,
-    "datetime-local" => String,
+    "date"           => Date,
+    "datetime-local" => Time,
     "email"          => String,
     "file"           => String,
     "hidden"         => String,
-    "month"          => String,
     "number"         => Numeric,
     "password"       => String,
     "radio"          => String,
@@ -35,9 +34,8 @@ class Brut::FrontEnd::Forms::InputDefinition
     "search"         => String,
     "tel"            => String,
     "text"           => String,
-    "time"           => String,
+    "time"           => Time, # XXX
     "url"            => String,
-    "week"           => String,
   }
 
   # Create an InputDefinition. This should very closely mirror
@@ -65,7 +63,7 @@ class Brut::FrontEnd::Forms::InputDefinition
     min: nil,
     minlength: nil,
     name: nil,
-    pattern: nil,
+    pattern: :based_on_type,
     required: :based_on_type,
     step: nil,
     type: nil,
@@ -89,20 +87,25 @@ class Brut::FrontEnd::Forms::InputDefinition
       required = type != "checkbox"
     end
 
-    @max       = type!( max       , Numeric                   , "max")
+    @max       = max
     @maxlength = type!( maxlength , Numeric                   , "maxlength")
-    @min       = type!( min       , Numeric                   , "min")
+    @min       = min
     @minlength = type!( minlength , Numeric                   , "minlength")
     @name      = type!( name      , String                    , "name", required: true)
-    @pattern   = type!( pattern   , String                    , "pattern")
     @required  = type!( required  , [true, false]             , "required", required: true)
     @step      = type!( step      , Numeric                   , "step")
     @type      = type!( type      , INPUT_TYPES_TO_CLASS.keys , "type", required: true)
     @array     = type!( array     , [true, false]             , "array", required: true)
 
-    if @pattern.nil? && type == "email"
-      @pattern = /^[^@]+@[^@]+\.[^@]+$/.source
-    end
+    @pattern = if pattern == :based_on_type 
+                 if type == "email"
+                   /^[^@]+@[^@]+\.[^@]+$/.source
+                 else
+                   nil
+                 end
+               else
+                 type!( pattern, String, "pattern" )
+               end
   end
 
   def array? = @array

data/lib/brut/front_end/middlewares/reload_app.rb

@@ -28,6 +28,8 @@ class Brut::FrontEnd::Middlewares::ReloadApp < Brut::FrontEnd::Middleware
             span.add_event("Routing reloaded")
             Brut.container.asset_path_resolver.reload
             span.add_event("Asset Path Resolver reloaded")
+            Brut.container.reload
+            span.add_event("Brut.container reloaded")
             ::I18n.reload!
             span.add_event("I18n reloaded")
           rescue => ex

data/lib/brut/front_end.rb

@@ -12,6 +12,7 @@ module Brut::FrontEnd
   autoload(:Download, "brut/front_end/download")
   autoload(:Flash, "brut/front_end/flash")
   autoload(:Form, "brut/front_end/form")
+  autoload(:Forms, "brut/front_end/form")
   autoload(:GenericResponse, "brut/front_end/generic_response")
   autoload(:Handler, "brut/front_end/handler")
   autoload(:Handlers, "brut/front_end/handler")

data/lib/brut/spec_support/rspec_setup.rb

@@ -43,8 +43,16 @@ class Brut::SpecSupport::RSpecSetup
   # Create the setup with the given RSpec configuration.
   #
   # @param [RSpec::Core::Configuration] rspec_config yielded from `RSpec.configure`
-  def initialize(rspec_config:)
-    @config = rspec_config
+  # @param [boolean] monkey_patch_summary_notification if true (the default),
+  # RSpec's Notifications::SumaryNotification will be monkey-patched to show
+  # `bin/test` in the summary instead of `./rspec`, as that is how you would
+  # re-run a test.  But, it's still monkey-patching.
+  def initialize(rspec_config:,
+                 monkey_patch_summary_notification: true)
+
+    @config                            = rspec_config
+    @monkey_patch_summary_notification = monkey_patch_summary_notification
+
     SemanticLogger.default_level = ENV.fetch("LOGGER_LEVEL_FOR_TESTS","warn")
   end
 
@@ -155,6 +163,9 @@ class Brut::SpecSupport::RSpecSetup
     @config.after(:suite) do
       Brut::SpecSupport::E2ETestServer.instance.stop
     end
+    if @monkey_patch_summary_notification
+      monkey_patch_summary_notification!
+    end
   end
 
   class OptionalSidekiqSupport
@@ -181,4 +192,33 @@ class Brut::SpecSupport::RSpecSetup
     end
   end
 
+private
+
+  def monkey_patch_summary_notification!
+    require "rspec/core/notifications"
+    klass = RSpec::Core::Notifications::SummaryNotification
+    if !klass.instance_variable_get("@_brut_has_monkeypatched")
+      klass.class_eval do
+        # Slightly reformatted, but the only line that's different
+        # is the one that said to use './rspec'. Now it says 'bin/test run'
+        def colorized_rerun_commands(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+          "\nFailed examples:\n\n" +
+            failed_examples.map do |example|
+              rerun_argument = rerun_argument_for(example)
+              colorizer.wrap(
+                "bin/test run #{rerun_argument}", # <--- this is the only difference
+                RSpec.configuration.failure_color
+              )   + 
+              " " +
+              colorizer.wrap(
+                "# #{example.full_description}",
+                RSpec.configuration.detail_color
+              )
+            end.join("\n")
+        end
+      end
+      klass.instance_variable_set("@_brut_has_monkeypatched",true)
+    end
+  end
 end
+

data/lib/brut/version.rb

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

data/lib/sequel/extensions/brut_instrumentation.rb

@@ -1,6 +1,10 @@
 module Sequel
   module Extensions
     # Instruments all SQL executions.
+    #
+    # *NOTE* this will include the actual SQL query text in the
+    # span, so any literal values in the query will be in the observability 
+    # platforms.
     module BrutInstrumentation
       # @!visibility private
       def log_connection_yield(sql,conn,args=nil)