ruflet_core 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 261081fe6de16011831ffa9ccce2ce123ea5c0b078177b9450800df70780cc62
+  data.tar.gz: 76d310dd1e0464545ce6172c2ddf8529c24543e1a34b346f02161542e56cb48f
+SHA512:
+  metadata.gz: 705e39c75cd934fde6e282ebbf6f8ca26c93f0f96f85dcdae6f227c1343af92a78435b725c6c9d32930a815348875ccf228377cccda569cb96a24f218e9e38f7
+  data.tar.gz: 4c24b89490f9cb4a18f198163796b9a156ac9a24dec897c0267c52e6812ab072b0c8889cc5fb4018c2c77ec40d8ed0f7bd79b638050bd76ad1706d3a33885916

data/README.md

@@ -0,0 +1,3 @@
+# ruflet
+
+Part of Ruflet monorepo.

data/lib/ruflet/version.rb

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

data/lib/ruflet.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "ruflet_core"

data/lib/ruflet_core.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "thread"
+require "ruflet_protocol"
+require "ruflet_ui"
+
+module Ruflet
+  @run_interceptors = []
+  @run_interceptors_mutex = Mutex.new
+
+  module_function
+
+  def run(entrypoint = nil, host: "0.0.0.0", port: 8550, &block)
+    callback = entrypoint || block
+    raise ArgumentError, "Ruflet.run requires a callable entrypoint or block" unless callback.respond_to?(:call)
+
+    interceptor = @run_interceptors_mutex.synchronize { @run_interceptors.last }
+    if interceptor
+      result = interceptor.call(entrypoint: callback, host: host, port: port)
+      return result unless result == :pass
+    end
+
+    begin
+      require "ruflet_server"
+    rescue LoadError => e
+      raise LoadError, "Ruflet.run requires the 'ruflet_server' gem unless a run interceptor handles execution.", e.backtrace
+    end
+
+    Server.new(host: host, port: port) do |page|
+      callback.call(page)
+    end.start
+  end
+
+  def with_run_interceptor(interceptor)
+    @run_interceptors_mutex.synchronize { @run_interceptors << interceptor }
+    yield
+  ensure
+    @run_interceptors_mutex.synchronize { @run_interceptors.delete(interceptor) }
+  end
+end

data/lib/ruflet_protocol/ruflet/protocol.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Protocol
+    ACTIONS = {
+      register_client: 1,
+      patch_control: 2,
+      control_event: 3,
+      update_control: 4,
+      invoke_control_method: 5,
+      session_crashed: 6,
+
+      # Legacy JSON protocol aliases kept for compatibility.
+      register_web_client: "registerWebClient",
+      page_event_from_web: "pageEventFromWeb",
+      update_control_props: "updateControlProps"
+    }.freeze
+
+    module_function
+
+    def pack_message(action:, payload:)
+      [action, payload]
+    end
+
+    def normalize_register_payload(payload)
+      page = payload["page"] || {}
+      {
+        "session_id" => payload["session_id"],
+        "page_name" => payload["page_name"] || "",
+        "route" => page["route"] || "/",
+        "width" => page["width"],
+        "height" => page["height"],
+        "platform" => page["platform"],
+        "platform_brightness" => page["platform_brightness"],
+        "media" => page["media"] || {}
+      }
+    end
+
+    def normalize_control_event_payload(payload)
+      {
+        "target" => payload["target"] || payload["eventTarget"],
+        "name" => payload["name"] || payload["eventName"],
+        "data" => payload["data"] || payload["eventData"]
+      }
+    end
+
+    def normalize_update_control_payload(payload)
+      {
+        "id" => payload["id"] || payload["target"] || payload["eventTarget"],
+        "props" => payload["props"].is_a?(Hash) ? payload["props"] : {}
+      }
+    end
+
+    def register_response(session_id:)
+      {
+        "session_id" => session_id,
+        "page_patch" => {},
+        "error" => nil
+      }
+    end
+  end
+end

data/lib/ruflet_protocol.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "ruflet/version"
+require_relative "ruflet_protocol/ruflet/protocol"

data/lib/ruflet_ui/ruflet/app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ruflet
+  class App
+    def initialize(host: nil, port: nil)
+      @host = (host || ENV["RUFLET_HOST"] || "0.0.0.0")
+      @port = normalize_port(port || ENV["RUFLET_PORT"] || 8550)
+    end
+
+    def run
+      Ruflet.run(host: @host, port: @port) do |page|
+        view(page)
+      end
+    end
+
+    def view(_page)
+      raise NotImplementedError, "#{self.class} must implement #view(page)"
+    end
+
+    private
+
+    def normalize_port(value)
+      port = value.to_i
+      port > 0 ? port : 8550
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/colors.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Colors
+    SEMANTIC_COLORS = {
+      PRIMARY: "primary",
+      ON_PRIMARY: "onprimary",
+      PRIMARY_CONTAINER: "primarycontainer",
+      ON_PRIMARY_CONTAINER: "onprimarycontainer",
+      PRIMARY_FIXED: "primaryfixed",
+      PRIMARY_FIXED_DIM: "primaryfixeddim",
+      ON_PRIMARY_FIXED: "onprimaryfixed",
+      ON_PRIMARY_FIXED_VARIANT: "onprimaryfixedvariant",
+      SECONDARY: "secondary",
+      ON_SECONDARY: "onsecondary",
+      SECONDARY_CONTAINER: "secondarycontainer",
+      ON_SECONDARY_CONTAINER: "onsecondarycontainer",
+      SECONDARY_FIXED: "secondaryfixed",
+      SECONDARY_FIXED_DIM: "secondaryfixeddim",
+      ON_SECONDARY_FIXED: "onsecondaryfixed",
+      ON_SECONDARY_FIXED_VARIANT: "onsecondaryfixedvariant",
+      TERTIARY: "tertiary",
+      ON_TERTIARY: "ontertiary",
+      TERTIARY_CONTAINER: "tertiarycontainer",
+      ON_TERTIARY_CONTAINER: "ontertiarycontainer",
+      TERTIARY_FIXED: "tertiaryfixed",
+      TERTIARY_FIXED_DIM: "tertiaryfixeddim",
+      ON_TERTIARY_FIXED: "ontertiaryfixed",
+      ON_TERTIARY_FIXED_VARIANT: "ontertiaryfixedvariant",
+      ERROR: "error",
+      ON_ERROR: "onerror",
+      ERROR_CONTAINER: "errorcontainer",
+      ON_ERROR_CONTAINER: "onerrorcontainer",
+      SURFACE: "surface",
+      ON_SURFACE: "onsurface",
+      ON_SURFACE_VARIANT: "onsurfacevariant",
+      SURFACE_TINT: "surfacetint",
+      SURFACE_DIM: "surfacedim",
+      SURFACE_BRIGHT: "surfacebright",
+      SURFACE_CONTAINER: "surfacecontainer",
+      SURFACE_CONTAINER_LOW: "surfacecontainerlow",
+      SURFACE_CONTAINER_LOWEST: "surfacecontainerlowest",
+      SURFACE_CONTAINER_HIGH: "surfacecontainerhigh",
+      SURFACE_CONTAINER_HIGHEST: "surfacecontainerhighest",
+      OUTLINE: "outline",
+      OUTLINE_VARIANT: "outlinevariant",
+      SHADOW: "shadow",
+      SCRIM: "scrim",
+      INVERSE_SURFACE: "inversesurface",
+      ON_INVERSE_SURFACE: "oninversesurface",
+      INVERSE_PRIMARY: "inverseprimary"
+    }.freeze
+
+    BASE_PRIMARY = %w[
+      amber blue bluegrey brown cyan deeporange deeppurple green grey indigo lightblue
+      lightgreen lime orange pink purple red teal yellow
+    ].freeze
+    BASE_ACCENT = %w[
+      amber blue cyan deeporange deeppurple green indigo lightblue lightgreen lime
+      orange pink purple red teal yellow
+    ].freeze
+    PRIMARY_SHADES = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900].freeze
+    ACCENT_SHADES = [100, 200, 400, 700].freeze
+
+    FIXED_COLORS = {
+      BLACK: "black",
+      BLACK_12: "black12",
+      BLACK_26: "black26",
+      BLACK_38: "black38",
+      BLACK_45: "black45",
+      BLACK_54: "black54",
+      BLACK_87: "black87",
+      WHITE: "white",
+      WHITE_10: "white10",
+      WHITE_12: "white12",
+      WHITE_24: "white24",
+      WHITE_30: "white30",
+      WHITE_38: "white38",
+      WHITE_54: "white54",
+      WHITE_60: "white60",
+      WHITE_70: "white70",
+      TRANSPARENT: "transparent"
+    }.freeze
+
+    DEPRECATED_ALIASES = {
+      BLACK12: :BLACK_12,
+      BLACK26: :BLACK_26,
+      BLACK38: :BLACK_38,
+      BLACK45: :BLACK_45,
+      BLACK54: :BLACK_54,
+      BLACK87: :BLACK_87,
+      WHITE10: :WHITE_10,
+      WHITE12: :WHITE_12,
+      WHITE24: :WHITE_24,
+      WHITE30: :WHITE_30,
+      WHITE38: :WHITE_38,
+      WHITE54: :WHITE_54,
+      WHITE60: :WHITE_60,
+      WHITE70: :WHITE_70
+    }.freeze
+
+    def with_opacity(opacity, color)
+      value = Float(opacity)
+      raise ArgumentError, "opacity must be between 0.0 and 1.0 inclusive, got #{opacity}" unless value.between?(0.0, 1.0)
+
+      "#{normalize_color(color)},#{value}"
+    end
+
+    def random(exclude: nil, weights: nil)
+      choices = all_values.dup
+      excluded = Array(exclude).map { |c| normalize_color(c) }
+      choices.reject! { |c| excluded.include?(c) }
+      return nil if choices.empty?
+
+      if weights && !weights.empty?
+        expanded = choices.flat_map do |color|
+          weight = weights.fetch(color, weights.fetch(color.to_sym, 1)).to_i rescue 1
+          weight = 1 if weight <= 0
+          [color] * weight
+        end
+        return expanded.sample
+      end
+
+      choices.sample
+    end
+
+    def all_values
+      return @all_values if @all_values
+
+      values = []
+      SEMANTIC_COLORS.each_value { |v| values << v }
+      FIXED_COLORS.each_value { |v| values << v }
+
+      BASE_PRIMARY.each do |base|
+        values << base
+        PRIMARY_SHADES.each do |shade|
+          values << "#{base}#{shade}"
+        end
+      end
+
+      BASE_ACCENT.each do |base|
+        values << "#{base}accent"
+        ACCENT_SHADES.each do |shade|
+          values << "#{base}accent#{shade}"
+        end
+      end
+
+      uniq_map = {}
+      values.each { |v| uniq_map[v] = true }
+      @all_values = uniq_map.keys.freeze
+    end
+
+    def self.normalize_color(color)
+      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)
+
+      color.to_s
+    end
+
+    BASE_PREFIX = {
+      "amber" => "AMBER",
+      "blue" => "BLUE",
+      "bluegrey" => "BLUE_GREY",
+      "brown" => "BROWN",
+      "cyan" => "CYAN",
+      "deeporange" => "DEEP_ORANGE",
+      "deeppurple" => "DEEP_PURPLE",
+      "green" => "GREEN",
+      "grey" => "GREY",
+      "indigo" => "INDIGO",
+      "lightblue" => "LIGHT_BLUE",
+      "lightgreen" => "LIGHT_GREEN",
+      "lime" => "LIME",
+      "orange" => "ORANGE",
+      "pink" => "PINK",
+      "purple" => "PURPLE",
+      "red" => "RED",
+      "teal" => "TEAL",
+      "yellow" => "YELLOW"
+    }.freeze
+
+    def self.constant_prefix_for(base_name)
+      key = base_name.to_s
+      return BASE_PREFIX[key] if BASE_PREFIX.key?(key)
+      key.upcase
+    end
+
+    SEMANTIC_COLORS.each { |k, v| const_set(k, v) }
+    FIXED_COLORS.each { |k, v| const_set(k, v) }
+
+    BASE_PRIMARY.each do |base|
+      prefix = self.constant_prefix_for(base)
+      const_set(prefix, base)
+      PRIMARY_SHADES.each do |shade|
+        const_set("#{prefix}_#{shade}", "#{base}#{shade}")
+      end
+    end
+
+    BASE_ACCENT.each do |base|
+      prefix = "#{self.constant_prefix_for(base)}_ACCENT"
+      const_set(prefix, "#{base}accent")
+      ACCENT_SHADES.each do |shade|
+        const_set("#{prefix}_#{shade}", "#{base}accent#{shade}")
+      end
+    end
+
+    DEPRECATED_ALIASES.each do |alias_name, target|
+      const_set(alias_name, const_get(target))
+    end
+
+    constant_names = []
+    SEMANTIC_COLORS.each_key { |k| constant_names << k }
+    FIXED_COLORS.each_key { |k| constant_names << k }
+    BASE_PRIMARY.each do |base|
+      constant_names << constant_prefix_for(base).to_sym
+      PRIMARY_SHADES.each { |shade| constant_names << "#{constant_prefix_for(base)}_#{shade}".to_sym }
+    end
+    BASE_ACCENT.each do |base|
+      constant_names << "#{constant_prefix_for(base)}_ACCENT".to_sym
+      ACCENT_SHADES.each { |shade| constant_names << "#{constant_prefix_for(base)}_ACCENT_#{shade}".to_sym }
+    end
+    DEPRECATED_ALIASES.each_key { |k| constant_names << k }
+
+    uniq_constants = {}
+    constant_names.each { |n| uniq_constants[n] = true }
+    if respond_to?(:define_singleton_method)
+      uniq_constants.keys.each do |name|
+        next if respond_to?(name)
+        define_singleton_method(name) { const_get(name) }
+      end
+    end
+  end
+end

data/lib/ruflet_ui/ruflet/control.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+begin
+require "securerandom"
+rescue LoadError
+  nil
+end
+require_relative "icon_data"
+require_relative "icons/material_icon_lookup"
+require_relative "icons/cupertino_icon_lookup"
+require "set"
+
+module Ruflet
+  class Control
+    HOST_EXPANDED_TYPES = %w[view row column].freeze
+
+    attr_reader :type, :id, :props, :children
+    attr_accessor :wire_id, :runtime_page
+
+    def initialize(type:, id: nil, **props)
+      @type = type.to_s.downcase
+      @id = (id || props.delete(:id) || "ctrl_#{self.class.generate_id}").to_s
+      @children = []
+      @handlers = {}
+      @wire_id = nil
+      @props = normalize_props(extract_handlers(preprocess_props(props)))
+    end
+
+    def on(event_name, &block)
+      name = normalized_event_name(event_name)
+      validate_event_name!(name)
+      @handlers[name] = block
+      @props["on_#{name}"] = true
+      runtime_page&.update(self, "on_#{name}": true) if wire_id
+      self
+    end
+
+    def emit(event_name, event)
+      handler = @handlers[normalized_event_name(event_name)]
+      return false unless handler
+
+      handler.call(event)
+      true
+    end
+
+    def has_handler?(event_name)
+      @handlers.key?(normalized_event_name(event_name))
+    end
+
+    def to_patch
+      wire_type = schema_wire_type_for_class
+      if wire_type.nil?
+        compact_type_key = type.delete("_")
+        wire_type = type_map[type] || type_map[compact_type_key]
+      end
+      raise ArgumentError, "Unknown control type: #{type}" unless wire_type
+      patch = {
+        "_c" => wire_type,
+        "_i" => wire_id
+      }
+
+      internals = {}
+      internals["host_positioned"] = true if type == "stack"
+      internals["host_expanded"] = true if HOST_EXPANDED_TYPES.include?(type)
+      patch["_internals"] = internals unless internals.empty?
+
+      props.each { |k, v| patch[k] = serialize_value(v) }
+      patch["controls"] = children.map(&:to_patch) unless children.empty?
+      patch
+    end
+
+    private
+
+    class << self
+      def generate_id
+        if defined?(SecureRandom) && SecureRandom.respond_to?(:hex)
+          SecureRandom.hex(4)
+        else
+          format("%08x", rand(0..0xffff_ffff))
+        end
+      end
+    end
+
+    def serialize_value(value)
+      case value
+      when Control
+        value.to_patch
+      when Ruflet::IconData
+        value.value
+      when Array
+        value.map { |v| serialize_value(v) }
+      when Hash
+        value.transform_values { |v| serialize_value(v) }
+      else
+        value.respond_to?(:to_h) ? serialize_value(value.to_h) : value
+      end
+    end
+
+    def extract_handlers(input)
+      output = input.dup
+      allowed_events = event_names
+      allowed_events_set = allowed_events.to_set
+
+      output.keys.each do |key|
+        key_string = key.to_s
+        next unless key_string.start_with?("on_")
+
+        event_name = normalized_event_name(key_string)
+        if allowed_events.any? && !allowed_events_set.include?(event_name)
+          raise ArgumentError, "Unknown event `#{key_string}` for control type `#{type}`"
+        end
+
+        handler = output.delete(key)
+        @handlers[event_name] = handler if handler.respond_to?(:call)
+        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
+
+      hash.each_with_object({}) do |(k, v), result|
+        key = k.to_s
+        mapped_key = key
+        if strict_schema_enforced?(allowed_props) &&
+            !mapped_key.start_with?("_") &&
+            !mapped_key.start_with?("on_") &&
+            !normalized_allowed.include?(mapped_key)
+          raise ArgumentError, "Unknown attribute `#{mapped_key}` for control type `#{type}`"
+        end
+
+        value =
+          if v.is_a?(Symbol)
+            v.to_s
+          elsif v.is_a?(Ruflet::IconData)
+            v.value
+          else
+            v
+          end
+        value = normalize_icon_prop(mapped_key, value)
+        value = normalize_color_prop(mapped_key, value)
+
+        result[mapped_key] = value
+      end
+    end
+
+    def preprocess_props(props)
+      props
+    end
+
+    def normalize_color_prop(key, value)
+      return value unless value.is_a?(String)
+      return value.downcase if color_prop_key?(key)
+
+      value
+    end
+
+    def color_prop_key?(key)
+      key == "color" || key == "bgcolor" || key.end_with?("_color")
+    end
+
+    def normalize_icon_prop(key, value)
+      return value unless icon_prop_key?(key)
+      codepoint = resolve_icon_codepoint(value)
+      codepoint.nil? ? value : codepoint
+    end
+
+    def icon_prop_key?(key)
+      key == "icon" || key.end_with?("_icon")
+    end
+
+    def resolve_icon_codepoint(value)
+      return nil unless value.is_a?(Integer) || value.is_a?(Symbol) || value.is_a?(String)
+
+      codepoint = Ruflet::MaterialIconLookup.codepoint_for(value)
+      if codepoint.nil? || (value.is_a?(Integer) && codepoint == value)
+        cupertino = Ruflet::CupertinoIconLookup.codepoint_for(value)
+        codepoint = cupertino unless cupertino.nil?
+      end
+      codepoint
+    end
+
+    def normalized_event_name(event_name)
+      event_name.to_s.sub(/\Aon_/, "")
+    end
+
+    def validate_event_name!(event_name)
+      events = event_names
+      return if events.empty? || events.include?(event_name)
+
+      raise ArgumentError, "Unknown event `on_#{event_name}` for control type `#{type}`"
+    end
+
+    def strict_schema_enforced?(allowed_props)
+      !allowed_props.empty?
+    end
+
+    def property_names
+      constructor_keywords_for_schema_class
+        .reject { |name| name.to_s.start_with?("on_") }
+        .map(&:to_s)
+    end
+
+    def event_names
+      constructor_keywords_for_schema_class
+        .select { |name| name.to_s.start_with?("on_") }
+        .map { |name| name.to_s.sub(/\Aon_/, "") }
+    end
+
+    def schema_wire_type_for_class
+      return nil unless self.class.const_defined?(:WIRE)
+
+      self.class::WIRE.to_s
+    end
+
+    def schema_class_for_validation
+      if self.class != Ruflet::Control && has_explicit_initialize_keywords?(self.class)
+        return self.class
+      end
+      begin
+        require_relative "ui/control_factory"
+        mapped = UI::ControlFactory::CLASS_MAP[type]
+        return mapped if mapped && has_explicit_initialize_keywords?(mapped)
+      rescue LoadError
+        nil
+      end
+
+      begin
+        require_relative "ui/controls/ruflet_controls"
+        mapped = UI::Controls::RufletControls::CLASS_MAP[type]
+        return mapped if mapped && has_explicit_initialize_keywords?(mapped)
+      rescue LoadError
+        nil
+      end
+
+      nil
+    end
+
+    def constructor_keywords_for_schema_class
+      schema_class = schema_class_for_validation
+      return [] unless schema_class
+
+      schema_class.instance_method(:initialize).parameters
+                 .select { |kind, _| kind == :key || kind == :keyreq }
+                 .map { |_, name| name }
+                 .reject { |name| name == :id }
+    rescue StandardError
+      []
+    end
+
+    def has_explicit_initialize_keywords?(klass)
+      params = klass.instance_method(:initialize).parameters
+      params.any? { |kind, _| kind == :key || kind == :keyreq }
+    rescue StandardError
+      false
+    end
+
+    def type_map
+      require_relative "ui/control_registry"
+      UI::ControlRegistry::TYPE_MAP
+    end
+
+    def event_props
+      require_relative "ui/control_registry"
+      UI::ControlRegistry::EVENT_PROPS
+    end
+  end
+end