ruflet_core 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82d5d751f2b92b2b740414e315e1b1f9e88389eb0423ec0ce7a040710e191d59
-  data.tar.gz: 728109060a0cff6ca564e2bfa5d7620e5f8182dc05cf82b571ae3280e7e0a015
+  metadata.gz: c28a07c8c32f3e0eca58c3d1400f06453275690b4e9f75d3a868a4507e78c74a
+  data.tar.gz: 71f044a3c2f0464571e4d16f779e1f751c42f4e16ea3aeeecb3036b596269022
 SHA512:
-  metadata.gz: bf40cdafd48b625d189f9625945350873b4936c0668916ce8556e9d07f47368584892b29e57e4fe2e4583230d7ce5c87297848b90c5d01ab1d7ddac0b60df4d2
-  data.tar.gz: 2d229699ad359fcbc5dc5640dd176227bd0dad3f01d641b9f44ea569b26ccea61926b16c465284bda7e2fb786b514215922b8fdda5aa0a6b5f6baca36c0303fe
+  metadata.gz: 38de8d3745bbdf5b217e91de9a6dab2a194757964fa39f7a78bb89c83586fb4f0acee955ae7457221b12a15c4ab7fd18465e2a74af58627c8da25d6c75b62463
+  data.tar.gz: 476528dec0a5b55ca3e2a3622d4cf2691162434794a498d544a9da165efb249bca5e612f6ba8f49da52387223441ec34ebe64769f162a78916db0f27bee3dce9

data/README.md

@@ -1,31 +1,3 @@
-# ruflet_core
+# ruflet
 
-`ruflet_core` provides Ruflet's Ruby UI API: controls, control builders, page
-operations, events, services, and application lifecycle behavior.
-
-Applications normally receive this package through a generated Ruflet project
-or through `ruflet_rails`; it is not a standalone application server.
-
-```ruby
-require "ruflet"
-
-Ruflet.run do |page|
-  page.title = "Hello"
-  page.add(
-    container(
-      bgcolor: :surface_container_high,
-      padding: 24,
-      content: text("Hello Ruflet", color: "DeepOrange500")
-    )
-  )
-end
-```
-
-Color properties accept named colors and hex values. Use Ruby-style symbols
-like `:deep_orange_500`, compact strings like `"DeepOrange500"`, spaced names
-like `"Deep Orange 500"`, semantic theme names like `:primary_container`, or
-hex strings like `"#ff6d00"`. Ruflet normalizes named colors before sending
-them to the client.
-
-Use `ruflet_server` to run a standalone server-driven application. Use
-`ruflet_rails` when the UI is hosted by Rails.
+Part of Ruflet monorepo.

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.17" unless const_defined?(:VERSION)
+  VERSION = "0.0.18" unless const_defined?(:VERSION)
 end

data/lib/ruflet_core.rb

@@ -11,9 +11,9 @@ module Ruflet
   module_function
 
   def run(entrypoint = nil, host: "0.0.0.0", port: nil, &block)
-    port = normalize_run_port(port || ENV["RUFLET_PORT"] || 8550)
     callback = entrypoint || block
     raise ArgumentError, "Ruflet.run requires a callable entrypoint or block" unless callback.respond_to?(:call)
+    port = resolved_run_port(port)
 
     interceptor = @run_interceptors_mutex.synchronize { @run_interceptors.last }
     if interceptor
@@ -32,16 +32,18 @@ module Ruflet
     end.start
   end
 
+  def resolved_run_port(port)
+    raw = port.nil? ? ENV["RUFLET_PORT"] : port
+    return 8550 if raw.nil? || raw.to_s.strip.empty?
+
+    value = raw.to_i
+    value >= 0 ? value : 8550
+  end
+
   def with_run_interceptor(interceptor)
     @run_interceptors_mutex.synchronize { @run_interceptors << interceptor }
     yield
   ensure
     @run_interceptors_mutex.synchronize { @run_interceptors.delete(interceptor) }
   end
-
-  def normalize_run_port(value)
-    Integer(value)
-  rescue ArgumentError, TypeError
-    8550
-  end
 end

data/lib/ruflet_protocol/ruflet/protocol.rb

@@ -2,6 +2,13 @@
 
 module Ruflet
   module Protocol
+    # Flet transports these values as MessagePack extension objects. String
+    # subclasses preserve Ruflet's existing, convenient Ruby API while giving
+    # the wire codec the type information required by the Flutter client.
+    class DateTimeValue < String; end
+    class TimeOfDayValue < String; end
+    class DurationValue < String; end
+
     ACTIONS = {
       register_client: 1,
       patch_control: 2,
@@ -19,14 +26,26 @@ module Ruflet
 
     module_function
 
-    def pack_message(action:, payload:)
-      [action_code(action), payload]
+    def date_time(value)
+      return value if value.nil? || value.is_a?(DateTimeValue)
+
+      DateTimeValue.new(value.to_s)
+    end
+
+    def time_of_day(value)
+      return value if value.nil? || value.is_a?(TimeOfDayValue)
+
+      TimeOfDayValue.new(value.to_s)
     end
 
-    def action_code(action)
-      return action if action.is_a?(Integer) || action.is_a?(String)
+    def duration(value)
+      return value if value.nil? || value.is_a?(DurationValue)
 
-      ACTIONS.fetch(action)
+      DurationValue.new(value.to_s)
+    end
+
+    def pack_message(action:, payload:)
+      [action, payload]
     end
 
     def normalize_register_payload(payload)
@@ -39,12 +58,7 @@ module Ruflet
         "height" => page["height"],
         "platform" => page["platform"],
         "platform_brightness" => page["platform_brightness"],
-        # The Flutter client reports the host OS in "platform" even inside a
-        # browser, so "web" is the only reliable way to tell a web client from a
-        # native one. (pwa/wasm passed through for completeness.)
-        "web" => page["web"],
-        "pwa" => page["pwa"],
-        "wasm" => page["wasm"],
+        "window" => page["window"] || {},
         "media" => page["media"] || {}
       }
     end
@@ -64,51 +78,11 @@ module Ruflet
       }
     end
 
-    def normalize_patch_control_payload(payload)
-      {
-        "id" => payload["id"] || payload[:id],
-        "patch" => Array(payload["patch"] || payload[:patch])
-      }
-    end
-
-    def normalize_invoke_method_payload(payload)
-      {
-        "control_id" => payload["control_id"] || payload[:control_id],
-        "call_id" => payload["call_id"] || payload[:call_id],
-        "name" => payload["name"] || payload[:name],
-        "args" => payload.key?("args") ? payload["args"] : payload[:args],
-        "timeout" => payload.key?("timeout") || payload.key?(:timeout) ? (payload["timeout"] || payload[:timeout]) : 10
-      }
-    end
-
-    def normalize_invoke_method_result_payload(payload)
-      {
-        "control_id" => payload["control_id"] || payload[:control_id],
-        "call_id" => payload["call_id"] || payload[:call_id],
-        "result" => payload.key?("result") ? payload["result"] : payload[:result],
-        "error" => payload.key?("error") ? payload["error"] : payload[:error]
-      }
-    end
-
-    def normalize_session_crashed_payload(payload)
-      {
-        "message" => payload["message"] || payload[:message].to_s
-      }
-    end
-
-    def normalize_python_output_payload(payload)
-      {
-        "text" => payload["text"] || payload[:text].to_s,
-        "is_stderr" => payload.key?("is_stderr") || payload.key?(:is_stderr) ? !!(payload["is_stderr"] || payload[:is_stderr]) : false
-      }
-    end
-
-    def register_response(session_id:, page_patch: nil, error: nil)
-      page_patch ||= {}
+    def register_response(session_id:)
       {
         "session_id" => session_id,
-        "page_patch" => page_patch,
-        "error" => error
+        "page_patch" => {},
+        "error" => ""
       }
     end
   end

data/lib/ruflet_ui/ruflet/app.rb

@@ -21,7 +21,7 @@ module Ruflet
 
     def normalize_port(value)
       port = value.to_i
-      port > 0 ? port : 8550
+      port >= 0 ? port : 8550
     end
   end
 end

data/lib/ruflet_ui/ruflet/colors.rb

@@ -151,57 +151,11 @@ module Ruflet
     end
 
     def self.normalize_color(color)
-      return canonicalize(color.to_s) if color.is_a?(Symbol)
-      return canonicalize(color) if color.is_a?(String)
-      return canonicalize(color.to_s) unless color.respond_to?(:to_s)
+      return color.to_s if color.is_a?(Symbol)
+      return color if color.is_a?(String)
+      return color.to_s unless color.respond_to?(:to_s)
 
-      canonicalize(color.to_s)
-    end
-
-    def self.normalize_property(key, value)
-      normalize_value(value, color_key?(key))
-    end
-
-    def self.color_key?(key)
-      name = key.to_s
-      name == "color" ||
-        name == "colors" ||
-        name.end_with?("bgcolor") ||
-        name.end_with?("_color") ||
-        name.end_with?("_colors") ||
-        name == "color_scheme_seed"
-    end
-
-    def self.normalize_value(value, color_context = false)
-      case value
-      when String
-        color_context ? canonicalize(value) : value
-      when Symbol
-        color_context ? canonicalize(value.to_s) : value
-      when Array
-        value.map { |nested| normalize_value(nested, color_context) }
-      when Hash
-        value.each_with_object({}) do |(nested_key, nested_value), result|
-          result[nested_key] = normalize_value(nested_value, color_context || color_key?(nested_key))
-        end
-      else
-        value
-      end
-    end
-
-    # Canonicalizes a named color into flet's wire format. Flet color names are
-    # lowercase with no separators ("bluegrey", "deeporange", "red500"), so we
-    # strip underscores, hyphens, and whitespace before downcasing. Hex values
-    # (#... / 0x...) are downcased without separator stripping; the optional
-    # ",opacity" suffix is preserved untouched.
-    def self.canonicalize(value)
-      return value unless value.is_a?(String)
-
-      color, separator, opacity = value.partition(",")
-      color = color.strip.downcase
-      color = color.gsub(/[_\-\s]+/, "") unless color.start_with?("#") || color.start_with?("0x")
-
-      "#{color}#{separator}#{opacity}"
+      color.to_s
     end
 
     BASE_PREFIX = {

data/lib/ruflet_ui/ruflet/control.rb

@@ -5,7 +5,6 @@ require "securerandom"
 rescue LoadError
   nil
 end
-require_relative "colors"
 require_relative "icon_data"
 require_relative "icons/material_icon_lookup"
 require_relative "icons/cupertino_icon_lookup"
@@ -14,6 +13,7 @@ require "set"
 module Ruflet
   class Control
     HOST_EXPANDED_TYPES = %w[view row column].freeze
+    SCHEMA_METADATA_CACHE = {}
 
     attr_reader :type, :id, :props, :children
     attr_accessor :wire_id, :runtime_page
@@ -30,7 +30,13 @@ module Ruflet
     def on(event_name, &block)
       name = normalized_event_name(event_name)
       validate_event_name!(name)
-      @handlers[name] = block
+      attach_handler(name, block)
+      self
+    end
+
+    def attach_handler(event_name, handler)
+      name = normalized_event_name(event_name)
+      @handlers[name] = handler if handler.respond_to?(:call)
       @props["on_#{name}"] = true
       runtime_page&.update(self, "on_#{name}": true) if wire_id
       self
@@ -48,35 +54,13 @@ module Ruflet
       @handlers.key?(normalized_event_name(event_name))
     end
 
-    # Read a prop by name: control["value"] or control[:value].
-    def [](key)
-      @props[key.to_s]
-    end
-
-    # Write a prop by name: control["value"] = "x".
-    def []=(key, value)
-      @props[key.to_s] = value
-    end
-
-    # Convenience dot access to props, mirroring Flet-style controls:
-    #   control.value            # => @props["value"] (reads an existing prop)
-    #   control.value = "hello"  # => sets @props["value"]
-    # Reads only resolve props that exist, so typos still raise NoMethodError
-    # instead of silently returning nil. Defined methods (type, id, props,
-    # children, on, emit, to_patch, …) are never shadowed.
-    def method_missing(name, *args, &block)
-      key = name.to_s
-      if key.end_with?("=")
-        return @props[key[0..-2]] = args.first
-      end
-      return @props[key] if args.empty? && @props.key?(key)
-
-      super
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      key = name.to_s
-      key.end_with?("=") || @props.key?(key) || super
+    # Refresh an existing control without replacing its identity. Page services
+    # are long-lived in Flet's ServiceRegistry, so revisiting a view must update
+    # both their configuration and their Ruby event handlers.
+    def merge_props(values = {})
+      normalized = normalize_props(extract_handlers(preprocess_props(values)))
+      @props.merge!(normalized)
+      self
     end
 
     def to_patch
@@ -84,8 +68,8 @@ module Ruflet
       if wire_type.nil?
         compact_type_key = type.delete("_")
         wire_type = type_map[type] || type_map[compact_type_key]
+        wire_type ||= type.split("_").map { |part| part[0].to_s.upcase + part[1..].to_s }.join
       end
-      raise ArgumentError, "Unknown control type: #{type}" unless wire_type
       patch = {
         "_c" => wire_type,
         "_i" => wire_id
@@ -108,10 +92,10 @@ module Ruflet
 
     class << self
       def generate_id
-        if defined?(SecureRandom) && SecureRandom.respond_to?(:hex)
+        if Object.const_defined?(:SecureRandom) && SecureRandom.respond_to?(:hex)
           SecureRandom.hex(4)
         else
-          format("%08x", rand(0..0xffff_ffff))
+          format("%04x%04x", rand(0..0xffff), rand(0..0xffff))
         end
       end
     end
@@ -134,7 +118,7 @@ module Ruflet
     def extract_handlers(input)
       output = input.dup
       allowed_events = event_names
-      allowed_events_set = allowed_events.to_set
+      allowed_event_lookup = event_name_lookup
 
       output.keys.each do |key|
         key_string = key.to_s
@@ -143,7 +127,7 @@ module Ruflet
         next if key_string == "on_label_color"
 
         event_name = normalized_event_name(key_string)
-        if allowed_events.any? && !allowed_events_set.include?(event_name)
+        if allowed_events.any? && !allowed_event_lookup.key?(event_name)
           raise ArgumentError, "Unknown event `#{key_string}` for control type `#{type}`"
         end
 
@@ -152,22 +136,12 @@ module Ruflet
         output["on_#{event_name}"] = true
       end
 
-      event_props.each do |prop, event_name|
-        string_prop = prop.to_s
-        next unless output.key?(prop) || output.key?(string_prop)
-        next if allowed_events.any? && !allowed_events_set.include?(event_name)
-
-        handler = output.key?(prop) ? output.delete(prop) : output.delete(string_prop)
-        @handlers[event_name] = handler if handler.respond_to?(:call)
-        output["on_#{event_name}"] = true
-      end
-
       output
     end
 
     def normalize_props(hash)
       allowed_props = property_names
-      normalized_allowed = allowed_props.to_set
+      allowed_prop_lookup = property_name_lookup
 
       hash.each_with_object({}) do |(k, v), result|
         key = k.to_s
@@ -175,7 +149,7 @@ module Ruflet
         if strict_schema_enforced?(allowed_props) &&
             !mapped_key.start_with?("_") &&
             !mapped_key.start_with?("on_") &&
-            !normalized_allowed.include?(mapped_key)
+            !allowed_prop_lookup.key?(mapped_key)
           raise ArgumentError, "Unknown attribute `#{mapped_key}` for control type `#{type}`"
         end
 
@@ -198,11 +172,14 @@ module Ruflet
     end
 
     def normalize_color_prop(key, value)
-      Ruflet::Colors.normalize_property(key, value)
+      return value unless value.is_a?(String)
+      return value.downcase if color_prop_key?(key)
+
+      value
     end
 
     def color_prop_key?(key)
-      Ruflet::Colors.color_key?(key)
+      key == "color" || key.end_with?("bgcolor") || key.end_with?("_color")
     end
 
     def normalize_icon_prop(key, value)
@@ -232,7 +209,8 @@ module Ruflet
     end
 
     def normalized_event_name(event_name)
-      event_name.to_s.sub(/\Aon_/, "")
+      name = event_name.to_s
+      name.start_with?("on_") ? name[3..-1] : name
     end
 
     def validate_event_name!(event_name)
@@ -247,16 +225,39 @@ module Ruflet
     end
 
     def property_names
-      constructor_keywords_for_schema_class
-        .reject { |name| name.to_s.start_with?("on_") && name != :on_label_color }
-        .map(&:to_s)
+      schema_metadata[0]
     end
 
     def event_names
-      constructor_keywords_for_schema_class
+      schema_metadata[1]
+    end
+
+    def property_name_lookup
+      schema_metadata[2]
+    end
+
+    def event_name_lookup
+      schema_metadata[3]
+    end
+
+    def schema_metadata
+      cache_key = type
+      cached = SCHEMA_METADATA_CACHE[cache_key]
+      return cached if cached
+
+      keywords = constructor_keywords_for_schema_class
+      properties = keywords
+        .reject { |name| name.to_s.start_with?("on_") && name != :on_label_color }
+        .map(&:to_s)
+        .freeze
+      events = keywords
         .select { |name| name.to_s.start_with?("on_") }
         .reject { |name| name == :on_label_color }
-        .map { |name| name.to_s.sub(/\Aon_/, "") }
+        .map { |name| name.to_s[3..-1] }
+        .freeze
+      property_lookup = properties.each_with_object({}) { |name, lookup| lookup[name] = true }.freeze
+      event_lookup = events.each_with_object({}) { |name, lookup| lookup[name] = true }.freeze
+      SCHEMA_METADATA_CACHE[cache_key] = [properties, events, property_lookup, event_lookup].freeze
     end
 
     def schema_wire_type_for_class
@@ -291,16 +292,24 @@ module Ruflet
     def constructor_keywords_for_schema_class
       schema_class = schema_class_for_validation
       return [] unless schema_class
+      return schema_class::KEYWORDS if schema_class.const_defined?(:KEYWORDS)
 
-      schema_class.instance_method(:initialize).parameters
-                 .select { |kind, _| kind == :key || kind == :keyreq }
-                 .map { |_, name| name }
-                 .reject { |name| name == :id }
+      keyword_parameters = schema_class.instance_method(:initialize).parameters
+                                       .select { |kind, _| kind == :key || kind == :keyreq }
+      # mruby can omit keyword names that are not present in its presymbol
+      # table. A partial schema is unsafe because it rejects valid application
+      # properties. Explicit KEYWORDS metadata remains strict; otherwise the
+      # constructor itself performs initial keyword validation.
+      return [] if keyword_parameters.any? { |_, name| name.nil? }
+
+      keyword_parameters.map { |_, name| name }.reject { |name| name == :id }
     rescue StandardError
       []
     end
 
     def has_explicit_initialize_keywords?(klass)
+      return true if klass.const_defined?(:KEYWORDS)
+
       params = klass.instance_method(:initialize).parameters
       params.any? { |kind, _| kind == :key || kind == :keyreq }
     rescue StandardError
@@ -312,9 +321,5 @@ module Ruflet
       UI::ControlRegistry::TYPE_MAP
     end
 
-    def event_props
-      require_relative "ui/control_registry"
-      UI::ControlRegistry::EVENT_PROPS
-    end
   end
 end

data/lib/ruflet_ui/ruflet/dsl.rb

@@ -22,8 +22,10 @@ module Ruflet
 
     def default_port
       raw = ENV["RUFLET_PORT"].to_s
+      return 8550 if raw.strip.empty?
+
       value = raw.to_i
-      value > 0 ? value : 8550
+      value >= 0 ? value : 8550
     end
 
     def _pending_app
@@ -176,6 +178,7 @@ module Ruflet
     def pageview(children = nil, **props) = _pending_app.pageview(children, **props)
     def progress_ring(**props) = _pending_app.progress_ring(**props)
     def progressring(**props) = _pending_app.progressring(**props)
+    def spinkit(**props) = _pending_app.spinkit(**props)
     def range_slider(**props) = _pending_app.range_slider(**props)
     def rangeslider(**props) = _pending_app.rangeslider(**props)
     def responsive_row(children = nil, **props, &block) = _pending_app.responsive_row(children, **props, &block)
@@ -240,6 +243,9 @@ module Ruflet
     def slider(**props) = _pending_app.slider(**props)
     def transparent_pointer(content = nil, **props) = _pending_app.transparent_pointer(content, **props)
     def transparentpointer(content = nil, **props) = _pending_app.transparentpointer(content, **props)
+    def rotated_box(content = nil, **props) = _pending_app.rotated_box(content, **props)
+    def rotatedbox(content = nil, **props) = _pending_app.rotatedbox(content, **props)
+    def screenshot(content = nil, **props) = _pending_app.screenshot(content, **props)
     def radio(**props) = _pending_app.radio(**props)
     def radio_group(content = nil, **props) = _pending_app.radio_group(content, **props)
     def radiogroup(content = nil, **props) = _pending_app.radiogroup(content, **props)
@@ -247,6 +253,8 @@ module Ruflet
     def alertdialog(**props) = _pending_app.alertdialog(**props)
     def snack_bar(content = nil, **props) = _pending_app.snack_bar(content, **props)
     def snackbar(content = nil, **props) = _pending_app.snackbar(content, **props)
+    def snack_bar_action(label = nil, **props) = _pending_app.snack_bar_action(label, **props)
+    def snackbaraction(label = nil, **props) = _pending_app.snackbaraction(label, **props)
     def bottom_sheet(content = nil, **props) = _pending_app.bottom_sheet(content, **props)
     def bottomsheet(content = nil, **props) = _pending_app.bottomsheet(content, **props)
     def markdown(value = nil, **props) = _pending_app.markdown(value, **props)
@@ -311,7 +319,6 @@ module Ruflet
     def web_view(**props) = _pending_app.web_view(**props)
     def webview(**props) = _pending_app.webview(**props)
     def video(**props) = _pending_app.video(**props)
-    def spinkit(**variant) = _pending_app.spinkit(**variant)
     def code_editor(value = nil, **props) = _pending_app.code_editor(value, **props)
     def codeeditor(value = nil, **props) = _pending_app.codeeditor(value, **props)
     def rive(src = nil, **props) = _pending_app.rive(src, **props)
@@ -437,7 +444,7 @@ module Ruflet
         Ruflet::Server.new(host: host, port: port) do |runtime_page|
           runtime_page.set_view_props(page_props)
           runtime_page.add_service(*app_services) if app_services.any?
-          runtime_page.add(*app_roots)
+          app_roots.each { |control| runtime_page.add(control) }
         end.start
       end
 

data/lib/ruflet_ui/ruflet/icons/cupertino/cupertino_icons.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../icon_data"
+require_relative "../icon_constant_names"
 require_relative "../cupertino_icon_lookup"
 
 module Ruflet
@@ -19,8 +20,7 @@ module Ruflet
         }
       else
         source.keys.each_with_object({}) do |name, result|
-          text = name.to_s.gsub(/[^a-zA-Z0-9]/, "_").gsub(/_+/, "_").sub(/\A_/, "").sub(/_\z/, "")
-          text = "ICON_#{text}" if text.match?(/\A\d/)
+          text = Ruflet::IconNames.constant_for(name)
           result[text.upcase.to_sym] = name
         end
       end.freeze

data/lib/ruflet_ui/ruflet/icons/cupertino_icon_lookup.rb

@@ -67,6 +67,7 @@ module Ruflet
     end
 
     def load_icon_map
+      return COMPILED_ICON_MAP if const_defined?(:COMPILED_ICON_MAP, false)
       return {} unless File.file?(LOCAL_ICONS_JSON)
 
       parse_icons_json(LOCAL_ICONS_JSON)

data/lib/ruflet_ui/ruflet/icons/icon_constant_names.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ruflet
+  # Derives Ruby constant names from icon identifiers. Implemented byte-wise
+  # rather than with regexps: the tables are built for thousands of icons at
+  # load time, and this path must stay fast on every supported runtime.
+  module IconNames
+    module_function
+
+    def constant_for(name)
+      text = +""
+      prev_underscore = false
+      name.to_s.each_byte do |byte|
+        if (byte >= 48 && byte <= 57) || (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
+          text << byte.chr
+          prev_underscore = false
+        elsif !prev_underscore
+          text << "_"
+          prev_underscore = true
+        end
+      end
+      text = text[1..-1] while text.start_with?("_")
+      text = text[0...-1] while text.end_with?("_")
+      first = text.getbyte(0)
+      text = "ICON_#{text}" if first && first >= 48 && first <= 57
+      text
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/icons/material/material_icons.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../icon_data"
+require_relative "../icon_constant_names"
 require_relative "../material_icon_lookup"
 
 module Ruflet
@@ -19,8 +20,7 @@ module Ruflet
         }
       else
         source.keys.each_with_object({}) do |name, result|
-          text = name.to_s.gsub(/[^a-zA-Z0-9]/, "_").gsub(/_+/, "_").sub(/\A_/, "").sub(/_\z/, "")
-          text = "ICON_#{text}" if text.match?(/\A\d/)
+          text = Ruflet::IconNames.constant_for(name)
           result[text.upcase.to_sym] = name
         end
       end.freeze

data/lib/ruflet_ui/ruflet/icons/material_icon_lookup.rb

@@ -67,6 +67,7 @@ module Ruflet
     end
 
     def load_icon_map
+      return COMPILED_ICON_MAP if const_defined?(:COMPILED_ICON_MAP, false)
       return {} unless File.file?(LOCAL_ICONS_JSON)
 
       parse_icons_json(LOCAL_ICONS_JSON)