phlex-reactive 0.15.3 → 0.15.4

data/lib/phlex/reactive/show_conditions/compare_terms.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    module ShowConditions
+      # The Hash-valued terms that are not a count: `same:` (issue #395) — a
+      # field equal to ANOTHER owned field — and `digits:` (issue #396) — a
+      # closed format: ASCII digits only, an exact count or an Integer Range,
+      # and an optional digit prefix (`starts_with:`). Compiled and evaluated
+      # here; the client mirrors both in features/bindings.js, and the shared
+      # fixture (spec/fixtures/show_predicate_vectors.json) holds them to
+      # agreement.
+      #
+      # A negated term (under unless:) keeps its shape and carries
+      # "negate" => true, the way unless: turns equals into not.
+      module CompareTerms
+        # The digit-count wire keys: the count suffixes length: uses.
+        DIGITS_KEYS = %w[digits_eq digits_gte digits_lt digits_lte].freeze
+        DIGIT_STRING = /\A[0-9]*\z/
+        PREFIX = /\A[0-9]+\z/
+
+        # { digits: 10, starts_with: "9" } -> ONE term (a Range's bounds sit in
+        # the same term, so unless: can negate the whole format at once).
+        def digits_term(name, hash, negate:)
+          options = option_keys(hash)
+          if (extra = options.keys - %i[digits starts_with]).any?
+            raise ArgumentError, "reactive_show: #{name.inspect} digits: takes only starts_with: (got #{extra.inspect})"
+          end
+          unless options.key?(:digits)
+            raise ArgumentError, "reactive_show: #{name.inspect} starts_with: needs digits: (e.g. digits: 10)"
+          end
+
+          term = { "field" => name }.merge(digits_bounds(name, options[:digits]))
+          term["prefix"] = digits_prefix!(name, options[:starts_with]) if options.key?(:starts_with)
+          term["negate"] = true if negate
+          term
+        end
+
+        # digits: — every character is 0-9, the count fits every bound, and the
+        # value starts with the prefix; negate flips it. A malformed literal
+        # (a hand-built term) is false either way, like the client's skip.
+        def digits_matches?(term, value)
+          keys = DIGITS_KEYS.select { term.key?(it) }
+          return false unless keys.all? { term[it].is_a?(Integer) } && (term["prefix"].nil? || term["prefix"].is_a?(String))
+
+          text = value.to_s
+          ok = text.match?(DIGIT_STRING) &&
+               keys.all? { count_matches?(it, term[it], text.length) } &&
+               (term["prefix"].nil? || text.start_with?(term["prefix"]))
+          ok != (term["negate"] == true)
+        end
+
+        # Symbol/String keys as Symbols; any other key stays as it is, so the
+        # unknown-key check names it in an ArgumentError.
+        def option_keys(hash)
+          hash.transform_keys { it.is_a?(String) || it.is_a?(Symbol) ? it.to_sym : it }
+        end
+
+        # { same: :other, case: :fold } -> one term comparing this field's
+        # value with another owned field's, both read as strings. The other
+        # name is a bare field like any show field (the client applies
+        # reactive_scope).
+        def same_term(name, hash, negate:)
+          options = option_keys(hash)
+          if (extra = options.keys - %i[same case]).any?
+            raise ArgumentError, "reactive_show: #{name.inspect} same: takes only case: (got #{extra.inspect})"
+          end
+
+          term = { "field" => name, "same" => same_field!(name, options[:same]) }
+          term["fold"] = true if same_case!(name, options[:case])
+          term["negate"] = true if negate
+          term
+        end
+
+        # same: — this field's value against the other field's (an absent
+        # field is ""), folded when the term says so; negate flips it.
+        def same_matches?(term, value, values)
+          left = value.to_s
+          right = values.fetch(term["same"], "").to_s
+          if term["fold"] == true
+            left = ascii_fold(left)
+            right = ascii_fold(right)
+          end
+          (left == right) != (term["negate"] == true)
+        end
+
+        # The ASCII-only fold both evaluators apply: A-Z to a-z and nothing
+        # else (never downcase, which folds letters the client would not).
+        def ascii_fold(value)
+          value.tr("A-Z", "a-z")
+        end
+
+        private
+
+        def digits_bounds(name, digits)
+          case digits
+          when Integer
+            return { "digits_eq" => digits } if digits >= 0
+          when Range
+            first = digits.begin
+            last = digits.end
+            if [first, last].compact.any? && [first, last].compact.all? { it.is_a?(Integer) && it >= 0 }
+              bounds = {}
+              bounds["digits_gte"] = first unless first.nil?
+              bounds[digits.exclude_end? ? "digits_lt" : "digits_lte"] = last unless last.nil?
+              return bounds
+            end
+          end
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} digits: takes a non-negative Integer or an Integer Range " \
+            "(a digit count), got #{digits.inspect}"
+        end
+
+        def digits_prefix!(name, prefix)
+          return prefix if prefix.is_a?(String) && prefix.match?(PREFIX)
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} starts_with: takes a String of digits (0-9), got #{prefix.inspect}"
+        end
+
+        def same_field!(name, other)
+          field = other.to_s if other.is_a?(Symbol) || other.is_a?(String)
+          return field unless field.nil? || field.strip.empty?
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} same: needs the other field's name (e.g. same: :email), " \
+            "got #{other.inspect}"
+        end
+
+        # case: is absent (an exact compare) or :fold. Anything else raises:
+        # there is no locale-aware fold to ask for.
+        def same_case!(name, value)
+          return false if value.nil?
+          return true if (value.is_a?(Symbol) || value.is_a?(String)) && value.to_s == "fold"
+
+          raise ArgumentError, "reactive_show: #{name.inspect} case: takes only :fold, got #{value.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/phlex/reactive/show_conditions.rb

@@ -23,6 +23,9 @@ module Phlex
     #   { checked: 1.. } / { checked: 0 } -> checked_* (issue #319 — how many
     #                                   owned boxes of a checkbox GROUP are
     #                                   ticked; same Integer/Range shapes)
+    #   { same: :email }             -> same "email" (issue #395 — equal to
+    #   { same: :email, case: :fold }   ANOTHER owned field; fold lowercases
+    #                                   ASCII A-Z only, on both sides)
     # Under unless: each term is NEGATED (De Morgan):
     #   scalar -> not; Array -> ∉ (AND of nots); Range -> the complement
     #   predicate (¬gte→lt, ¬lte→gt, ¬lt→gte), and a BOUNDED range complements
@@ -49,6 +52,8 @@ module Phlex
       # A Hash value's one key -> its wire-key prefix.
       COUNT_PREFIXES = { "length" => "len", "checked" => "checked" }.freeze
 
+      extend CompareTerms
+
       module_function
 
       # Compile if:/if_any:/unless: into DNF groups. Loud validation at render
@@ -83,7 +88,7 @@ module Phlex
       # Every field named across all groups/terms — drives reactive_values
       # coverage (server first paint only fires when every field is provided).
       def fields(groups)
-        groups.flat_map { |group| group.map { |term| term.fetch("field") } }.uniq
+        groups.flat_map { |group| group.flat_map { |term| [term.fetch("field"), term["same"]].compact } }.uniq
       end
       # rubocop:enable Style/ItBlockParameter
 
@@ -147,7 +152,7 @@ module Phlex
         case value
         when Range then range_terms(name, value)
         when Array then [membership_term(name, value)]
-        when Hash then count_terms(name, value)
+        when Hash then hash_terms(name, value)
         else [{ "field" => name, "equals" => equals_literal(value) }]
         end
       end
@@ -191,6 +196,32 @@ module Phlex
         end
       end
 
+      # --- Hash values: same: (#395, in CompareTerms) or a count -------------
+
+      def hash_terms(name, hash)
+        case hash_kind(hash)
+        when :same then [same_term(name, hash, negate: false)]
+        when :digits then [digits_term(name, hash, negate: false)]
+        else count_terms(name, hash)
+        end
+      end
+
+      # The complement under unless: — a list of alternative term-lists.
+      def hash_complement(name, hash)
+        case hash_kind(hash)
+        when :same then [[same_term(name, hash, negate: true)]]
+        when :digits then [[digits_term(name, hash, negate: true)]]
+        else count_complement(name, hash)
+        end
+      end
+
+      def hash_kind(hash)
+        keys = hash.keys.map(&:to_s)
+        if keys.include?("same") then :same
+        elsif keys.include?("digits") || keys.include?("starts_with") then :digits
+        end
+      end
+
       # --- the count predicates: length: (#226) and checked: (#319) ---------
 
       # A Hash value names a STRUCTURAL predicate over a COUNT — length: (the
@@ -262,7 +293,7 @@ module Phlex
         kind = hash.keys.first.to_s if hash.size == 1
         unless COUNT_PREFIXES.key?(kind)
           raise ArgumentError,
-            "reactive_show: #{name.inspect} Hash value supports only length: or checked: " \
+            "reactive_show: #{name.inspect} Hash value supports only same:, digits:, or one of length: or checked: " \
             "(got #{hash.keys.inspect})"
         end
 
@@ -294,7 +325,7 @@ module Phlex
         name = field.to_s
         case value
         when Range then range_complement(name, value)
-        when Hash then count_complement(name, value)
+        when Hash then hash_complement(name, value)
         when Array
           list = value.map(&:to_s)
           raise ArgumentError, "reactive_show: #{name.inspect} Array needs at least one value" if list.empty?
@@ -333,7 +364,9 @@ module Phlex
         field = term.fetch("field")
         value = values.fetch(field, "")
 
-        if term.key?("equals") then value == term["equals"]
+        if term.key?("same") then same_matches?(term, value, values)
+        elsif CompareTerms::DIGITS_KEYS.any? { term.key?(it) } then digits_matches?(term, value)
+        elsif term.key?("equals") then value == term["equals"]
         elsif term.key?("not") then value != term["not"]
         elsif term.key?("in") then term["in"].include?(value)
         elsif (key = LENGTH_KEYS.find { term.key?(it) }) then count_matches?(key, term[key], value.to_s.length)
@@ -350,7 +383,7 @@ module Phlex
       def count_matches?(key, literal, count)
         return false unless literal.is_a?(Integer)
 
-        case key.delete_prefix("len_").delete_prefix("checked_")
+        case key.split("_", 2).last
         when "eq" then count == literal
         when "gte" then count >= literal
         when "gt" then count > literal

data/lib/phlex/reactive/streamable.rb

@@ -34,7 +34,9 @@ module Phlex
       ThreadViewContext = Struct.new(:view_context, :builder, :renderer, :generation)
 
       # Actor-only ops: a js broadcast rejects a broadcast that carries one.
-      # Focus ops steal focus in every subscriber's tab (issue #96); submit
+      # Focus ops steal focus in every subscriber's tab (issue #96); blur (issue
+      # #399) would drop focus in every subscriber whose focused element sits
+      # inside the target; submit
       # (issue #226) would force-submit every subscriber's form; paste_into
       # (issue #228) would read every subscriber's clipboard; check_group
       # (issue #342) would tick or clear every subscriber's selection; presence
@@ -46,7 +48,7 @@ module Phlex
       # belong to the actor's own reply (reply.js) or gesture (on_client / a
       # reducer's $ops), never a broadcast. Names mirror Phlex::Reactive::JS's verbs.
       BROADCAST_REFUSED_OPS = %w[
-        focus focus_first submit paste_into persist_state persist_clear check_group presence
+        focus focus_first blur submit paste_into persist_state persist_clear check_group presence
         show_modal close_dialog
         preview_file
         set_value
@@ -205,7 +207,8 @@ module Phlex
           unless refused.empty?
             raise ArgumentError,
               "broadcast_to(js:) refuses actor-only op(s) #{refused.join(", ")} — broadcasting focus " \
-              "steals it in every subscriber's tab; broadcasting submit force-submits every " \
+              "steals it in every subscriber's tab; broadcasting blur drops focus in every subscriber " \
+              "whose focused element is inside the target; broadcasting submit force-submits every " \
               "subscriber's form; broadcasting paste_into reads every subscriber's clipboard; " \
               "broadcasting check_group ticks or clears every subscriber's selection; " \
               "broadcasting presence writes every subscriber's presence state; " \

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.15.3"
+    VERSION = "0.15.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.15.4
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -140,6 +140,9 @@ files:
 - app/javascript/phlex/reactive/features/compute.js
 - app/javascript/phlex/reactive/features/compute.min.js
 - app/javascript/phlex/reactive/features/compute.min.js.map
+- app/javascript/phlex/reactive/features/countdown.js
+- app/javascript/phlex/reactive/features/countdown.min.js
+- app/javascript/phlex/reactive/features/countdown.min.js.map
 - app/javascript/phlex/reactive/features/defer.js
 - app/javascript/phlex/reactive/features/defer.min.js
 - app/javascript/phlex/reactive/features/defer.min.js.map
@@ -193,8 +196,10 @@ files:
 - lib/phlex/reactive/client_bindings.rb
 - lib/phlex/reactive/collections.rb
 - lib/phlex/reactive/component.rb
+- lib/phlex/reactive/component/countdown_binding.rb
 - lib/phlex/reactive/component/dsl.rb
 - lib/phlex/reactive/component/editable.rb
+- lib/phlex/reactive/component/field_references.rb
 - lib/phlex/reactive/component/helpers.rb
 - lib/phlex/reactive/component/identity.rb
 - lib/phlex/reactive/component/image_fallback_binding.rb
@@ -204,6 +209,7 @@ files:
 - lib/phlex/reactive/component/presence_declaration.rb
 - lib/phlex/reactive/component/registry.rb
 - lib/phlex/reactive/component/selection.rb
+- lib/phlex/reactive/component/show_options.rb
 - lib/phlex/reactive/component/sortable.rb
 - lib/phlex/reactive/defer.rb
 - lib/phlex/reactive/deferred_render_job.rb
@@ -241,6 +247,7 @@ files:
 - lib/phlex/reactive/settles.rb
 - lib/phlex/reactive/shortcut.rb
 - lib/phlex/reactive/show_conditions.rb
+- lib/phlex/reactive/show_conditions/compare_terms.rb
 - lib/phlex/reactive/stream.rb
 - lib/phlex/reactive/streamable.rb
 - lib/phlex/reactive/test_helpers.rb