ruflet 0.0.8 → 0.0.9

data/lib/ruflet_protocol.rb

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

data/lib/ruflet_ui/ruflet/app.rb

@@ -1,27 +0,0 @@
-# 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

@@ -1,234 +0,0 @@
-# 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

@@ -1,281 +0,0 @@
-# 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