funicular 0.1.0 → 0.2.0

data/minitest/validations_test.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Load the mrblib runtime before defining model subclasses below, since their
+# class bodies reference Funicular::Model and call `validates` at load time.
+Funicular::SSR::Runtime.load_framework!
+
+# Exercises the client-side validation framework under CRuby (the same code
+# runs in the browser under PicoRuby; see test/validations_test.rb).
+class ValidationsTest < Minitest::Test
+  # A fresh, isolated model class with the given schema so validators declared
+  # in one test never leak into another.
+  def model_class(attributes = { "name" => false, "age" => false }, endpoints = {})
+    klass = Class.new(Funicular::Model)
+    attrs = {}
+    attributes.each { |name, readonly| attrs[name] = { "type" => "string", "readonly" => readonly } }
+    klass.load_schema("attributes" => attrs, "endpoints" => endpoints)
+    klass
+  end
+
+  # --- individual validators -------------------------------------------
+
+  def test_presence
+    k = model_class
+    k.class_eval { validates :name, presence: true }
+    blank = k.new("name" => "")
+    assert_equal false, blank.valid?
+    assert_equal ["can't be blank"], blank.errors[:name]
+    assert_equal true, k.new("name" => "Alice").valid?
+  end
+
+  def test_length_maximum_and_minimum
+    k = model_class
+    k.class_eval { validates :name, length: { minimum: 2, maximum: 5 } }
+
+    short = k.new("name" => "a"); short.valid?
+    assert_equal ["is too short (minimum is 2 characters)"], short.errors[:name]
+
+    long = k.new("name" => "abcdef"); long.valid?
+    assert_equal ["is too long (maximum is 5 characters)"], long.errors[:name]
+
+    assert_equal true, k.new("name" => "abc").valid?
+  end
+
+  def test_format
+    k = model_class
+    k.class_eval { validates :name, format: { with: /^[a-z]+$/ } }
+    assert_equal true, k.new("name" => "abc").valid?
+    bad = k.new("name" => "ABC"); bad.valid?
+    assert_equal ["is invalid"], bad.errors[:name]
+  end
+
+  def test_numericality
+    k = model_class
+    k.class_eval { validates :age, numericality: { only_integer: true, greater_than: 0 } }
+    nan = k.new("age" => "abc"); nan.valid?
+    assert_equal ["is not a number"], nan.errors[:age]
+    assert_equal true, k.new("age" => "10").valid?
+    low = k.new("age" => "0"); low.valid?
+    assert_equal ["must be greater than 0"], low.errors[:age]
+    frac = k.new("age" => "1.5"); frac.valid?
+    assert_equal ["must be an integer"], frac.errors[:age]
+  end
+
+  def test_inclusion_and_exclusion
+    inc = model_class
+    inc.class_eval { validates :name, inclusion: { in: ["a", "b"] } }
+    assert_equal true, inc.new("name" => "a").valid?
+    assert_equal false, inc.new("name" => "z").valid?
+
+    exc = model_class
+    exc.class_eval { validates :name, exclusion: { in: ["admin"] } }
+    assert_equal false, exc.new("name" => "admin").valid?
+    assert_equal true, exc.new("name" => "alice").valid?
+  end
+
+  def test_allow_blank_skips_validation
+    k = model_class
+    k.class_eval { validates :name, length: { minimum: 3 }, allow_blank: true }
+    assert_equal true, k.new("name" => "").valid?
+    assert_equal false, k.new("name" => "ab").valid?
+  end
+
+  def test_valid_clears_previous_errors
+    k = model_class
+    k.class_eval { validates :name, presence: true }
+    m = k.new("name" => "")
+    m.valid?
+    m.instance_variable_set("@name", "now set")
+    assert_equal true, m.valid?
+    assert_equal [], m.errors[:name]
+  end
+
+  # --- schema-derived validators + merge -------------------------------
+
+  def test_load_schema_merges_and_dedupes
+    k = Class.new(Funicular::Model)
+    k.class_eval { validates :name, presence: true } # client-declared
+    k.load_schema(
+      "attributes" => {
+        "name" => { "type" => "string", "readonly" => false },
+        "age" => { "type" => "string", "readonly" => false }
+      },
+      "endpoints" => {},
+      "validations" => {
+        "name" => { "presence" => true, "length" => { "maximum" => 3 } },
+        "age" => { "presence" => true }
+      }
+    )
+
+    name_kinds = k.validators_on(:name).map(&:kind).sort
+    # presence appears once (client wins, schema presence deduped) + length merged
+    assert_equal [:length, :presence], name_kinds
+    assert_equal [:presence], k.validators_on(:age).map(&:kind)
+  end
+
+  def test_inline_attribute_validations_are_registered
+    # The shape produced by Funicular::Schema.build: validations nested inside
+    # each attribute entry.
+    k = Class.new(Funicular::Model)
+    k.load_schema(
+      "attributes" => {
+        "name" => {
+          "type" => "string", "readonly" => false,
+          "validations" => { "presence" => true, "length" => { "maximum" => 3 } }
+        }
+      },
+      "endpoints" => {}
+    )
+    assert_equal [:length, :presence], k.validators_on(:name).map(&:kind).sort
+    assert_equal false, k.new("name" => "toolong").valid?
+    assert_equal true, k.new("name" => "ok").valid?
+  end
+
+  def test_format_from_schema_rebuilds_regexp
+    k = Class.new(Funicular::Model)
+    k.load_schema(
+      "attributes" => { "name" => { "type" => "string", "readonly" => false } },
+      "endpoints" => {},
+      "validations" => { "name" => { "format" => { "with" => "^[a-z]+$", "flags" => "i" } } }
+    )
+    assert_equal true, k.new("name" => "ABC").valid? # 'i' flag honored
+    assert_equal false, k.new("name" => "123").valid?
+  end
+
+  # --- create/update auto-validation -----------------------------------
+
+  def test_create_short_circuits_when_invalid
+    k = model_class({ "name" => false }, "create" => { "method" => "POST", "path" => "/things" })
+    k.class_eval { validates :name, presence: true }
+
+    got_instance = :unset
+    got_error = :unset
+    # Invalid -> returns before any HTTP call, yields the errors.
+    k.create({ "name" => "" }) do |instance, error|
+      got_instance = instance
+      got_error = error
+    end
+
+    assert_nil got_instance
+    assert_instance_of Funicular::Model::Errors, got_error
+    assert_equal ["can't be blank"], got_error[:name]
+  end
+
+  def test_update_short_circuits_when_invalid
+    k = model_class({ "name" => false }, "update" => { "method" => "PATCH", "path" => "/things/:id" })
+    k.class_eval { validates :name, presence: true }
+
+    m = k.new("name" => "ok")
+    m.instance_variable_set("@id", 1)
+
+    got_success = :unset
+    got_result = :unset
+    m.update("name" => "") do |success, result|
+      got_success = success
+      got_result = result
+    end
+
+    assert_equal false, got_success
+    assert_equal ["can't be blank"], got_result[:name]
+  end
+end

data/mrbgem.rake

@@ -6,6 +6,7 @@ MRuby::Gem::Specification.new('picoruby-funicular') do |spec|
   unless ENV['TEST_TASK']
     spec.add_dependency 'picoruby-wasm'
   end
+  spec.add_dependency 'picoruby-indexeddb'
   spec.add_dependency 'picoruby-json'
   spec.add_dependency 'mruby-object-ext', gemdir: "#{MRUBY_ROOT}/mrbgems/picoruby-mruby/lib/mruby/mrbgems/mruby-object-ext"
   spec.add_dependency 'mruby-hash-ext', gemdir: "#{MRUBY_ROOT}/mrbgems/picoruby-mruby/lib/mruby/mrbgems/mruby-hash-ext"

data/mrblib/0_validations.rb

@@ -0,0 +1,206 @@
+# Attribute validations for Funicular::Model, modeled on ActiveModel.
+#
+# This file is named with a "0_" prefix on purpose: the mruby build
+# concatenates mrblib/**/*.rb in alphabetical order, so this loads before
+# model.rb (which does `include Validations`) and before 1_validators.rb
+# (the concrete validators). Keep this file free of Ruby-only regexp features
+# (\A, \z, $1, ...): on the client, Regexp is a thin JS RegExp wrapper.
+module Funicular
+  class Model
+    # A small slice of ActiveModel::Errors: messages keyed by attribute.
+    # Consumed by FormBuilder, which reads errors[:field].
+    class Errors
+      def initialize
+        @messages = {}
+      end
+
+      def add(attribute, message)
+        key = attribute.to_sym
+        (@messages[key] ||= []) << message
+        message
+      end
+
+      # Always returns an array (possibly empty) for the attribute.
+      def [](attribute)
+        @messages[attribute.to_sym] || []
+      end
+
+      def added?(attribute)
+        !self[attribute].empty?
+      end
+
+      # { attribute_symbol => ["message", ...] }
+      def messages
+        @messages
+      end
+
+      def full_messages
+        result = [] #: Array[String]
+        @messages.each do |attribute, msgs|
+          human = humanize(attribute)
+          msgs.each { |m| result << "#{human} #{m}" }
+        end
+        result
+      end
+
+      def clear
+        @messages = {}
+      end
+
+      def empty?
+        @messages.all? { |_attr, msgs| msgs.empty? }
+      end
+
+      def any?
+        !empty?
+      end
+
+      private
+
+      def humanize(attribute)
+        words = attribute.to_s.split("_")
+        first = words[0].to_s
+        first = first[0].to_s.upcase + first[1..-1].to_s
+        ([first] + words[1..-1].to_a).join(" ")
+      end
+    end
+
+    module Validations
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Base class for attribute validators, mirroring
+      # ActiveModel::Validations::EachValidator.
+      class EachValidator
+        attr_reader :attributes, :options
+
+        def initialize(attributes:, **options)
+          @attributes = attributes
+          @options = options
+        end
+
+        # PresenceValidator -> :presence. Validator names are single words,
+        # so a plain downcase is enough (no regexp needed).
+        def kind
+          name = self.class.to_s.split("::").last.to_s
+          name = name[0...-9] if name.end_with?("Validator")
+          name.to_s.downcase.to_sym
+        end
+
+        def validate(record)
+          attributes.each do |attribute|
+            value = record.read_attribute_for_validation(attribute)
+            next if options[:allow_nil] && value.nil?
+            next if options[:allow_blank] && blank?(value)
+            validate_each(record, attribute, value)
+          end
+        end
+
+        def validate_each(record, attribute, value)
+          raise "#{self.class} must implement validate_each"
+        end
+
+        private
+
+        def blank?(value)
+          return true if value.nil?
+          return value.strip.empty? if value.is_a?(String)
+          return value.empty? if value.respond_to?(:empty?)
+          false
+        end
+
+        def present?(value)
+          !blank?(value)
+        end
+      end
+
+      module ClassMethods
+        # Validators declared on this model class.
+        def validators
+          @validators ||= []
+        end
+
+        def validators_on(attribute)
+          attr = attribute.to_sym
+          validators.select { |v| v.attributes.include?(attr) }
+        end
+
+        # Options that configure every validator in a `validates` call rather
+        # than naming a validator of their own (mirrors ActiveModel).
+        SHARED_OPTIONS = [:allow_nil, :allow_blank, :if, :unless, :on, :strict]
+
+        # validates :a, :b, presence: true, length: { maximum: 30 }, allow_blank: true
+        def validates(*attributes, **options)
+          return if attributes.empty?
+          attrs = attributes.map { |a| a.to_sym }
+
+          shared = {} #: Hash[Symbol, untyped]
+          SHARED_OPTIONS.each { |k| shared[k] = options[k] if options.key?(k) }
+
+          options.each do |key, opts|
+            next if SHARED_OPTIONS.include?(key)
+            klass = validator_class_for(key)
+            next unless klass
+            base = {} #: Hash[Symbol, untyped]
+            base = opts unless opts == true
+            validator_options = shared.merge(base) # per-validator options win
+            validators << klass.new(attributes: attrs, **validator_options)
+          end
+        end
+
+        # Append a single schema-derived validator (from load_schema), unless a
+        # validator of the same kind is already declared for the attribute in
+        # the subclass body. Frontend declarations win, avoiding duplicates.
+        def add_schema_validator(attribute, kind, opts)
+          attr = attribute.to_sym
+          k = kind.to_sym
+          return if validators.any? { |v| v.attributes.include?(attr) && v.kind == k }
+          klass = validator_class_for(kind)
+          return unless klass
+          validator_options = {} #: Hash[Symbol, untyped]
+          validator_options = symbolize_keys(opts) unless opts == true
+          validators << klass.new(attributes: [attr], **validator_options)
+        end
+
+        private
+
+        def validator_class_for(key)
+          class_name = "#{key.to_s.capitalize}Validator"
+          return nil unless Funicular::Model::Validations.const_defined?(class_name)
+          Funicular::Model::Validations.const_get(class_name)
+        end
+
+        def symbolize_keys(hash)
+          return hash unless hash.is_a?(Hash)
+          out = {} #: Hash[Symbol, untyped]
+          hash.each { |k, v| out[k.to_sym] = v }
+          out
+        end
+      end
+
+      # --- instance API ---
+
+      def errors
+        @errors ||= Funicular::Model::Errors.new
+      end
+
+      def read_attribute_for_validation(attribute)
+        send(attribute)
+      end
+
+      def valid?
+        errors.clear
+        # Steep does not know whether `self.class` extends ClassMethods
+        # @type var cls: untyped
+        cls = self.class
+        cls.validators.each { |validator| validator.validate(self) }
+        errors.empty?
+      end
+
+      def invalid?
+        !valid?
+      end
+    end
+  end
+end

data/mrblib/1_validators.rb

@@ -0,0 +1,180 @@
+# Concrete validators for Funicular::Model, mirroring the standard Rails set.
+#
+# Named "1_" so the mruby build loads it after 0_validations.rb (which defines
+# EachValidator) but before model.rb. Keep this free of Ruby-only regexp
+# features: on the client, Regexp is a JS RegExp wrapper.
+module Funicular
+  class Model
+    module Validations
+      class PresenceValidator < EachValidator
+        def validate_each(record, attribute, value)
+          record.errors.add(attribute, options[:message] || "can't be blank") if blank?(value)
+        end
+      end
+
+      class AbsenceValidator < EachValidator
+        def validate_each(record, attribute, value)
+          record.errors.add(attribute, options[:message] || "must be blank") if present?(value)
+        end
+      end
+
+      class LengthValidator < EachValidator
+        def validate_each(record, attribute, value)
+          length = value.nil? ? 0 : value.to_s.length
+
+          if (min = options[:minimum]) && length < min
+            record.errors.add(attribute, options[:message] ||
+              "is too short (minimum is #{min} characters)")
+          end
+          if (max = options[:maximum]) && length > max
+            record.errors.add(attribute, options[:message] ||
+              "is too long (maximum is #{max} characters)")
+          end
+          if (exact = options[:is]) && length != exact
+            record.errors.add(attribute, options[:message] ||
+              "is the wrong length (should be #{exact} characters)")
+          end
+          if (range = options[:in] || options[:within]) && !range_include?(range, length)
+            record.errors.add(attribute, options[:message] || "is the wrong length")
+          end
+        end
+
+        private
+
+        def range_include?(range, length)
+          if range.respond_to?(:include?)
+            range.include?(length)
+          else
+            false
+          end
+        end
+      end
+
+      class FormatValidator < EachValidator
+        def validate_each(record, attribute, value)
+          str = value.to_s
+          if (with = options[:with]) && !str.match?(with)
+            record.errors.add(attribute, options[:message] || "is invalid")
+          end
+          if (without = options[:without]) && str.match?(without)
+            record.errors.add(attribute, options[:message] || "is invalid")
+          end
+        end
+      end
+
+      class NumericalityValidator < EachValidator
+        CHECKS = {
+          greater_than: ">",
+          greater_than_or_equal_to: ">=",
+          equal_to: "==",
+          less_than: "<",
+          less_than_or_equal_to: "<=",
+          other_than: "!="
+        }
+
+        def validate_each(record, attribute, value)
+          number = to_number(value)
+          if number.nil?
+            record.errors.add(attribute, options[:message] || "is not a number")
+            return
+          end
+
+          if options[:only_integer] && !number.is_a?(Integer)
+            record.errors.add(attribute, options[:message] || "must be an integer")
+            return
+          end
+
+          CHECKS.each do |option, _operator|
+            next unless options.key?(option)
+            unless compare(number, option, options[option])
+              record.errors.add(attribute, options[:message] || message_for(option, options[option]))
+            end
+          end
+        end
+
+        private
+
+        def compare(number, option, target)
+          case option
+          when :greater_than then number > target
+          when :greater_than_or_equal_to then number >= target
+          when :equal_to then number == target
+          when :less_than then number < target
+          when :less_than_or_equal_to then number <= target
+          when :other_than then number != target
+          else true
+          end
+        end
+
+        def message_for(option, target)
+          case option
+          when :greater_than then "must be greater than #{target}"
+          when :greater_than_or_equal_to then "must be greater than or equal to #{target}"
+          when :equal_to then "must be equal to #{target}"
+          when :less_than then "must be less than #{target}"
+          when :less_than_or_equal_to then "must be less than or equal to #{target}"
+          when :other_than then "must be other than #{target}"
+          else "is invalid"
+          end
+        end
+
+        def to_number(value)
+          return value if value.is_a?(Numeric)
+          str = value.to_s.strip
+          return nil if str.empty?
+          begin
+            Integer(str)
+          rescue
+            begin
+              Float(str)
+            rescue
+              nil
+            end
+          end
+        end
+      end
+
+      class InclusionValidator < EachValidator
+        def validate_each(record, attribute, value)
+          list = options[:in] || options[:within]
+          return unless list.respond_to?(:include?)
+          unless list.include?(value)
+            record.errors.add(attribute, options[:message] || "is not included in the list")
+          end
+        end
+      end
+
+      class ExclusionValidator < EachValidator
+        def validate_each(record, attribute, value)
+          list = options[:in] || options[:within]
+          return unless list.respond_to?(:include?)
+          if list.include?(value)
+            record.errors.add(attribute, options[:message] || "is reserved")
+          end
+        end
+      end
+
+      class AcceptanceValidator < EachValidator
+        def validate_each(record, attribute, value)
+          accepted = options[:accept] || ["1", "true", true]
+          accepted = [accepted] unless accepted.is_a?(Array)
+          unless accepted.include?(value)
+            record.errors.add(attribute, options[:message] || "must be accepted")
+          end
+        end
+      end
+
+      class ConfirmationValidator < EachValidator
+        def validate_each(record, attribute, value)
+          confirmation_attr = "#{attribute}_confirmation"
+          return unless record.respond_to?(confirmation_attr)
+          confirmation = record.send(confirmation_attr)
+          return if confirmation.nil?
+          if value != confirmation
+            record.errors.add(attribute, options[:message] || "doesn't match confirmation")
+          end
+        end
+      end
+    end
+  end
+end

data/mrblib/cable.rb

@@ -38,12 +38,18 @@ module Funicular
         # puts "[Cable] WebSocket object created, setting up handlers"
 
         @websocket.onopen do |event|
+          was_reconnect = @reconnect_attempts > 0
           @connected = true
           @reconnect_attempts = 0
           # puts "[Cable] Connected to #{@url}"
           # Delay flush to ensure connection is stable
           JS.global.setTimeout(100) do
-            flush_pending_commands if @connected
+            next unless @connected
+            # On reconnect the server has forgotten our subscriptions; re-issue
+            # subscribe commands before flushing any pending perform/unsubscribe
+            # so the server knows about them when those messages arrive.
+            @subscriptions.resubscribe_all if was_reconnect
+            flush_pending_commands
           end
         end
 
@@ -233,7 +239,8 @@ module Funicular
         return if @pending_commands.empty?
         begin
           json = JSON.generate(@pending_commands)
-          JS.global[:localStorage]&.setItem(STORAGE_KEY, json)
+          storage = JS.global[:localStorage]
+          storage.setItem(STORAGE_KEY, json) if storage.is_a?(JS::Object)
         rescue => e
           puts "[Cable] Error saving to localStorage: #{e.message}"
         end
@@ -242,12 +249,10 @@ module Funicular
       # Load pending commands from localStorage
       def load_pending_from_storage
         begin
-          stored = JS.global[:localStorage]&.getItem(STORAGE_KEY)
-          if stored
-            JSON.parse(stored.to_s)
-          else
-            []
-          end
+          storage = JS.global[:localStorage]
+          return [] unless storage.is_a?(JS::Object)
+          stored = storage.getItem(STORAGE_KEY)
+          stored.is_a?(String) ? JSON.parse(stored) : []
         rescue => e
           puts "[Cable] Error loading from localStorage: #{e.message}"
           []
@@ -257,7 +262,8 @@ module Funicular
       # Clear pending commands from localStorage
       def clear_pending_storage
         begin
-          JS.global[:localStorage]&.removeItem(STORAGE_KEY)
+          storage = JS.global[:localStorage]
+          storage.removeItem(STORAGE_KEY) if storage.is_a?(JS::Object)
         rescue => e
           puts "[Cable] Error clearing localStorage: #{e.message}"
         end
@@ -316,6 +322,15 @@ module Funicular
         return unless subscription
         subscription.notify_received(message)
       end
+
+      # Re-issue subscribe for every active subscription. Used after a
+      # WebSocket reconnect, where the server has dropped its subscription
+      # state but the client-side Subscription objects are still valid.
+      def resubscribe_all
+        @subscriptions.each_value do |subscription|
+          subscription.subscribe
+        end
+      end
     end
 
     # Subscription represents a subscription to a specific channel