ruflet 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71ccb066d48adaf26ea46834bd630001c3a144aca86d5891f1f5c4646755029c
-  data.tar.gz: 133976a5d04e617e8faefba38b42d802d308df2d6c920c23d04d906508f0a040
+  metadata.gz: 383b294c6573d456634109721dbf8b8ba8394f45fa869e57e3114a6d74c883fe
+  data.tar.gz: b17888f9fe0d083f0ca0a008de04d486bbe483ef74213e09ab1cdbc626ceeba1
 SHA512:
-  metadata.gz: e26a8c097c5f85de3fa2e56655503b19a2f54da7b1a285d0b5e7c5094c6d4cc4b6ce3f452460531a958ae915c2408f6a8ccc185d773a4d148e4f3c2b9356e70f
-  data.tar.gz: 2fb16bbdd819e73446492e188dc371383387b26a37306512256a431722dabce9695b88d6d66f0f02852e59918e5e7e75e5b4b6a776637718ff0f326eca3d6a4d
+  metadata.gz: b1960be12808dcc6b7d36335e4fe1e59496017392efeb59af8135d2a25558f6b1c5dfedd31bd0b594a3cd445483ca5ba64fa7d59a250da8070e2401763c561fb
+  data.tar.gz: c0c09817075879c5ac9c767cdf5c9a6ef1725340961cc0488fb72bc76a8a405152c5b6e836e215a01063731c67740ba27cd769fe0145c17d5935b56386b927af

data/lib/ruflet/version.rb

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

data/lib/ruflet_ui/ruflet/app.rb

@@ -1,24 +1,13 @@
 # frozen_string_literal: true
-require_relative "../../ruflet/manifest_compiler"
 
 module Ruflet
   class App
-    def initialize(host: "0.0.0.0", port: 8550)
-      @host = host
-      @port = port
+    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
-      manifest_out = ENV["RUFLET_MANIFEST_OUT"].to_s
-      unless manifest_out.empty?
-        route = ENV["RUFLET_MANIFEST_ROUTE"].to_s
-        route = "/" if route.empty?
-        manifest = Ruflet::ManifestCompiler.compile_app(self, route: route)
-        Ruflet::ManifestCompiler.write_file(manifest_out, manifest)
-        puts manifest_out
-        return manifest_out
-      end
-
       Ruflet.run(host: @host, port: @port) do |page|
         view(page)
       end
@@ -27,5 +16,12 @@ module Ruflet
     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/control.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
 begin
-  require "securerandom"
+require "securerandom"
 rescue LoadError
   nil
 end
-require_relative "ui/control_registry"
 require_relative "icon_data"
 require_relative "icons/material_icon_lookup"
 require_relative "icons/cupertino_icon_lookup"
+require "set"
 
 module Ruflet
   class Control
-    TYPE_MAP = UI::ControlRegistry::TYPE_MAP
-    EVENT_PROPS = UI::ControlRegistry::EVENT_PROPS
     HOST_EXPANDED_TYPES = %w[view row column].freeze
 
     attr_reader :type, :id, :props, :children
@@ -30,6 +28,7 @@ module Ruflet
 
     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
@@ -49,8 +48,14 @@ module Ruflet
     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" => TYPE_MAP.fetch(type, type.split("_").map(&:capitalize).join),
+        "_c" => wire_type,
         "_i" => wire_id
       }
 
@@ -87,16 +92,33 @@ module Ruflet
       when Hash
         value.transform_values { |v| serialize_value(v) }
       else
-        value
+        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|
+      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)
@@ -107,9 +129,19 @@ module Ruflet
     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
@@ -164,5 +196,86 @@ module Ruflet
     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

data/lib/ruflet_ui/ruflet/dsl.rb

@@ -16,15 +16,27 @@ module Ruflet
 
     module_function
 
+    def default_host
+      ENV["RUFLET_HOST"].to_s.strip.empty? ? "0.0.0.0" : ENV["RUFLET_HOST"].to_s
+    end
+
+    def default_port
+      raw = ENV["RUFLET_PORT"].to_s
+      value = raw.to_i
+      value > 0 ? value : 8550
+    end
+
     def _pending_app
-      @_pending_app ||= App.new(host: "0.0.0.0", port: 8550)
+      @_pending_app ||= App.new(host: default_host, port: default_port)
     end
 
     def _reset_pending_app!
-      @_pending_app = App.new(host: "0.0.0.0", port: 8550)
+      @_pending_app = App.new(host: default_host, port: default_port)
     end
 
-    def app(host: "0.0.0.0", port: 8550, &block)
+    def app(host: nil, port: nil, &block)
+      host ||= default_host
+      port ||= default_port
       return App.new(host: host, port: port).tap { |a| a.instance_eval(&block) } if block
 
       pending = _pending_app
@@ -36,6 +48,7 @@ module Ruflet
     def page(**props, &block) = _pending_app.page(**props, &block)
     def control(type, **props, &block) = _pending_app.control(type, **props, &block)
     def widget(type, **props, &block) = _pending_app.widget(type, **props, &block)
+    def service(type, **props, &block) = _pending_app.service(type, **props, &block)
     def column(**props, &block) = _pending_app.column(**props, &block)
     def center(**props, &block) = _pending_app.center(**props, &block)
     def row(**props, &block) = _pending_app.row(**props, &block)
@@ -51,7 +64,6 @@ module Ruflet
     def text(value = nil, **props) = _pending_app.text(value, **props)
     def button(**props) = _pending_app.button(**props)
     def elevated_button(**props) = _pending_app.elevated_button(**props)
-    def elevatedbutton(**props) = _pending_app.elevatedbutton(**props)
     def text_field(**props) = _pending_app.text_field(**props)
     def textfield(**props) = _pending_app.textfield(**props)
     def icon(**props) = _pending_app.icon(**props)
@@ -88,6 +100,46 @@ module Ruflet
     def navigationbar(**props, &block) = _pending_app.navigationbar(**props, &block)
     def navigation_bar_destination(**props, &block) = _pending_app.navigation_bar_destination(**props, &block)
     def navigationbardestination(**props, &block) = _pending_app.navigationbardestination(**props, &block)
+    def bar_chart(**props) = _pending_app.bar_chart(**props)
+    def barchart(**props) = _pending_app.barchart(**props)
+    def bar_chart_group(**props) = _pending_app.bar_chart_group(**props)
+    def barchartgroup(**props) = _pending_app.barchartgroup(**props)
+    def bar_chart_rod(**props) = _pending_app.bar_chart_rod(**props)
+    def barchartrod(**props) = _pending_app.barchartrod(**props)
+    def bar_chart_rod_stack_item(**props) = _pending_app.bar_chart_rod_stack_item(**props)
+    def barchartrodstackitem(**props) = _pending_app.barchartrodstackitem(**props)
+    def line_chart(**props) = _pending_app.line_chart(**props)
+    def linechart(**props) = _pending_app.linechart(**props)
+    def line_chart_data(**props) = _pending_app.line_chart_data(**props)
+    def linechartdata(**props) = _pending_app.linechartdata(**props)
+    def line_chart_data_point(**props) = _pending_app.line_chart_data_point(**props)
+    def linechartdatapoint(**props) = _pending_app.linechartdatapoint(**props)
+    def pie_chart(**props) = _pending_app.pie_chart(**props)
+    def piechart(**props) = _pending_app.piechart(**props)
+    def pie_chart_section(**props) = _pending_app.pie_chart_section(**props)
+    def piechartsection(**props) = _pending_app.piechartsection(**props)
+    def candlestick_chart(**props) = _pending_app.candlestick_chart(**props)
+    def candlestickchart(**props) = _pending_app.candlestickchart(**props)
+    def candlestick_chart_spot(**props) = _pending_app.candlestick_chart_spot(**props)
+    def candlestickchartspot(**props) = _pending_app.candlestickchartspot(**props)
+    def radar_chart(**props) = _pending_app.radar_chart(**props)
+    def radarchart(**props) = _pending_app.radarchart(**props)
+    def radar_chart_title(**props) = _pending_app.radar_chart_title(**props)
+    def radarcharttitle(**props) = _pending_app.radarcharttitle(**props)
+    def radar_data_set(**props) = _pending_app.radar_data_set(**props)
+    def radardataset(**props) = _pending_app.radardataset(**props)
+    def radar_data_set_entry(**props) = _pending_app.radar_data_set_entry(**props)
+    def radardatasetentry(**props) = _pending_app.radardatasetentry(**props)
+    def scatter_chart(**props) = _pending_app.scatter_chart(**props)
+    def scatterchart(**props) = _pending_app.scatterchart(**props)
+    def scatter_chart_spot(**props) = _pending_app.scatter_chart_spot(**props)
+    def scatterchartspot(**props) = _pending_app.scatterchartspot(**props)
+    def chart_axis(**props) = _pending_app.chart_axis(**props)
+    def chartaxis(**props) = _pending_app.chartaxis(**props)
+    def chart_axis_label(**props) = _pending_app.chart_axis_label(**props)
+    def chartaxislabel(**props) = _pending_app.chartaxislabel(**props)
+    def web_view(**props) = _pending_app.web_view(**props)
+    def webview(**props) = _pending_app.webview(**props)
     def fab(content = nil, **props) = _pending_app.fab(content, **props)
     def cupertino_button(**props) = _pending_app.cupertino_button(**props)
     def cupertinobutton(**props) = _pending_app.cupertinobutton(**props)
@@ -118,6 +170,7 @@ module Ruflet
         @host = host
         @port = port
         @roots = []
+        @services = []
         @stack = []
         @page_props = { "route" => "/" }
         @seq = 0
@@ -159,16 +212,26 @@ module Ruflet
         c
       end
 
+      def service(type, **props, &block)
+        mapped_props = props.dup
+        id = mapped_props.delete(:id)&.to_s || next_id(type)
+        svc = Ruflet::UI::ControlFactory.build(type.to_s, id: id, **normalize_props(mapped_props))
+        @services << svc unless @services.include?(svc)
+        svc
+      end
+
       def duration(**parts)
         DSL.duration(**parts)
       end
 
       def run
         app_roots = @roots
+        app_services = @services
         page_props = @page_props.dup
 
         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)
         end.start
       end
@@ -176,6 +239,7 @@ module Ruflet
       private
 
       def build_widget(type, **props, &block) = control(type.to_s, **props, &block)
+      def build_service(type, **props, &block) = service(type.to_s, **props, &block)
 
       def attach(control)
         if @stack.empty?

data/lib/ruflet_ui/ruflet/event.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "events/gesture_events"
 
 module Ruflet
   class Event
-    attr_reader :name, :target, :raw_data, :data, :page, :control
+    attr_reader :name, :target, :raw_data, :data, :typed_data, :page, :control
 
     def initialize(name:, target:, raw_data:, page:, control:)
       @name = name
       @target = target
       @raw_data = raw_data
       @data = parse_data(raw_data)
+      @typed_data = Events::GestureEventFactory.build(name, @data)
       @page = page
       @control = control
     end
@@ -24,5 +26,17 @@ module Ruflet
     rescue JSON::ParserError
       raw
     end
+
+    public
+
+    def method_missing(name, *args, &block)
+      return typed_data.public_send(name, *args, &block) if typed_data && typed_data.respond_to?(name)
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      (typed_data && typed_data.respond_to?(name, include_private)) || super
+    end
   end
 end