lacci 0.2.1 → 0.3.0

data/lib/shoes/app.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Shoes
-  class App < Shoes::Widget
-    include Scarpe::Log
+class Shoes
+  class App < Shoes::Drawable
+    include Shoes::Log
 
     class << self
       attr_accessor :instance
@@ -10,42 +10,61 @@ module Shoes
 
     attr_reader :document_root
 
-    display_properties :title, :width, :height, :resizable, :debug
+    shoes_styles :title, :width, :height, :resizable
+
+    CUSTOM_EVENT_LOOP_TYPES = ["displaylib", "return", "wait"]
 
     def initialize(
-      title: "Scarpe!",
+      title: "Shoes!",
       width: 480,
       height: 420,
       resizable: true,
-      debug: ENV["SCARPE_DEBUG"] ? true : false,
       &app_code_body
     )
+      log_init("Shoes::App")
+
       if Shoes::App.instance
         @log.error("Trying to create a second Shoes::App in the same process! Fail!")
-        raise "Cannot create multiple Shoes::App objects!"
+        raise Shoes::Errors::TooManyInstancesError, "Cannot create multiple Shoes::App objects!"
       else
         Shoes::App.instance = self
       end
 
-      log_init("Shoes::App")
-
       @do_shutdown = false
+      @event_loop_type = "displaylib" # the default
 
       super
 
-      # This creates the DocumentRoot, including its corresponding display widget
-      @document_root = Scarpe::DocumentRoot.new
+      # The draw context tracks current settings like fill and stroke,
+      # plus potentially other current state that changes from drawable
+      # to drawable and slot to slot.
+      @draw_context = {
+        "fill" => "",
+        "stroke" => "",
+        "rotate" => 0,
+      }
+
+      # This creates the DocumentRoot, including its corresponding display drawable
+      @document_root = Shoes::DocumentRoot.new
 
       @slots = []
 
-      # Now create the App display widget
-      create_display_widget
+      # Now create the App display drawable
+      create_display_drawable
 
       # Set up testing events *after* Display Service basic objects exist
       if ENV["SCARPE_APP_TEST"]
         test_code = File.read ENV["SCARPE_APP_TEST"]
         if test_code != ""
-          self.instance_eval test_code
+          @test_obj = Object.new
+          @test_obj.instance_eval test_code
+        end
+      end
+
+      if ENV["SHOES_SPEC_TEST"]
+        test_code = File.read ENV["SHOES_SPEC_TEST"]
+        unless test_code.empty?
+          Shoes::Spec.instance.run_shoes_spec_test_code test_code
         end
       end
 
@@ -59,9 +78,15 @@ module Shoes
         self.destroy(send_event: false)
       end
 
+      @watch_for_event_loop = bind_shoes_event(event_name: "custom_event_loop") do |loop_type|
+        raise(Shoes::Errors::InvalidAttributeValueError, "Unknown event loop type: #{loop_type.inspect}!") unless CUSTOM_EVENT_LOOP_TYPES.include?(loop_type)
+
+        @event_loop_type = loop_type
+      end
+
       Signal.trap("INT") do
-        @log.warning("App interrupted by signal, stopping...")
-        puts "\nStopping Scarpe app..."
+        @log.warn("App interrupted by signal, stopping...")
+        puts "\nStopping Shoes app..."
         destroy
       end
     end
@@ -73,9 +98,9 @@ module Shoes
       ::Shoes::App.instance.with_slot(@document_root, &@app_code_body)
     end
 
-    # "Container" widgets like flows, stacks, masks and the document root
-    # are considered "slots" in Scarpe parlance. When a new slot is created,
-    # we push it here in order to track what widgets are found in that slot.
+    # "Container" drawables like flows, stacks, masks and the document root
+    # are considered "slots" in Shoes parlance. When a new slot is created,
+    # we push it here in order to track what drawables are found in that slot.
     def push_slot(slot)
       @slots.push(slot)
     end
@@ -99,14 +124,62 @@ module Shoes
       pop_slot
     end
 
-    # This isn't supposed to return. The display service should take control
+    # We use method_missing for drawable-creating methods like "button".
+    # The parent's method_missing will auto-create Shoes style getters and setters.
+    # This is similar to the method_missing in Shoes::Slot, but different in
+    # where the new drawable appears.
+    def method_missing(name, *args, **kwargs, &block)
+      klass = ::Shoes::Drawable.drawable_class_by_name(name)
+      return super unless klass
+
+      ::Shoes::App.define_method(name) do |*args, **kwargs, &block|
+        # Look up the Shoes drawable and create it...
+        drawable_instance = klass.new(*args, **kwargs, &block)
+
+        unless klass.ancestors.include?(::Shoes::TextDrawable)
+          # Create this drawable in the current app slot
+          drawable_instance.set_parent ::Shoes::App.instance.current_slot
+        end
+
+        drawable_instance
+      end
+
+      send(name, *args, **kwargs, &block)
+    end
+
+    def current_draw_context
+      @draw_context.dup
+    end
+
+    # This usually doesn't return. The display service may take control
     # of the main thread. Local Webview even stops any background threads.
+    # However, some display libraries don't want to shut down and don't
+    # want to (and/or can't) take control of the event loop.
     def run
       if @do_shutdown
         $stderr.puts "Destroy has already been signaled, but we just called Shoes::App.run!"
         return
       end
+
+      # The display lib can send us an event to customise the event loop handling.
+      # But it must do so before the "run" event returns.
       send_shoes_event(event_name: "run")
+
+      case @event_loop_type
+      when "wait"
+        # Display lib wants us to busy-wait instead of it.
+        until @do_shutdown
+          Shoes::DisplayService.dispatch_event("heartbeat", nil)
+        end
+      when "displaylib"
+        # If run event returned, that means we're done.
+        destroy
+      when "return"
+        # We can just return to the main event loop. But we shouldn't call destroy.
+        # Presumably some event loop *outside* our event loop is handling things.
+      else
+        raise Shoes::Errors::InvalidAttributeValueError, "Internal error! Incorrect event loop type: #{@event_loop_type.inspect}!"
+      end
     end
 
     def destroy(send_event: true)
@@ -114,55 +187,75 @@ module Shoes
       send_shoes_event(event_name: "destroy") if send_event
     end
 
-    def all_widgets
+    def all_drawables
       out = []
 
       to_add = @document_root.children
       until to_add.empty?
         out.concat(to_add)
-        to_add = to_add.flat_map(&:children).compact
+        to_add = to_add.flat_map { |w| w.respond_to?(:children) ? w.children : [] }.compact
       end
 
       out
     end
 
-    # We can add various ways to find widgets here.
+    # We can add various ways to find drawables here.
     # These are sort of like Shoes selectors, used for testing.
-    def find_widgets_by(*specs)
-      widgets = all_widgets
+    def find_drawables_by(*specs)
+      drawables = all_drawables
       specs.each do |spec|
-        if spec.is_a?(Class)
-          widgets.select! { |w| spec === w }
-        elsif spec.is_a?(Symbol)
+        if spec == Shoes::App
+          drawables = [Shoes::App.instance]
+        elsif spec.is_a?(Class)
+          drawables.select! { |w| spec === w }
+        elsif spec.is_a?(Symbol) || spec.is_a?(String)
           s = spec.to_s
           case s[0]
           when "$"
             begin
               # I'm not finding a global_variable_get or similar...
               global_value = eval s
-              widgets &= [global_value]
+              drawables &= [global_value]
             rescue
-              raise "Error getting global variable: #{spec.inspect}"
+              raise Shoes::Errors::InvalidAttributeValueError, "Error getting global variable: #{spec.inspect}"
             end
           when "@"
-            if app.instance_variables.include?(spec)
-              widgets &= [self.instance_variable_get(spec)]
+            if Shoes::App.instance.instance_variables.include?(spec.to_sym)
+              drawables &= [self.instance_variable_get(spec)]
             else
-              raise "Can't find top-level instance variable: #{spec.inspect}!"
+              raise Shoes::Errors::InvalidAttributeValueError, "Can't find top-level instance variable: #{spec.inspect}!"
             end
           else
+            if s.start_with?("id:")
+              find_id = Integer(s[3..-1])
+              drawable = Shoes::Drawable.drawable_by_id(find_id)
+              drawables &= [drawable]
+            else
+              raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to find drawables by #{spec.inspect}!"
+            end
           end
         else
-          raise("Don't know how to find widgets by #{spec.inspect}!")
+          raise(Shoes::Errors::InvalidAttributeValueError, "Don't know how to find drawables by #{spec.inspect}!")
         end
       end
-      widgets
+      drawables
     end
   end
 end
 
-# DSL methods
-class Shoes::App
+# Event handler DSLs get defined in both App and Slot - same code, slightly different results
+events = [:motion, :hover, :leave, :click, :release, :keypress, :animate, :every, :timer]
+events.each do |event|
+  Shoes::App.define_method(event) do |*args, &block|
+    subscription_item(args:, shoes_api_name: event.to_s, &block)
+  end
+  Shoes::Slot.define_method(event) do |*args, &block|
+    subscription_item(args:, shoes_api_name: event.to_s, &block)
+  end
+end
+
+# These methods will need to be defined on Slots too, but probably need a rework in general.
+class Shoes::App < Shoes::Drawable
   def background(...)
     current_slot.background(...)
   end
@@ -171,17 +264,46 @@ class Shoes::App
     current_slot.border(...)
   end
 
-  def motion(&block)
-    subscription_item(shoes_api_name: "motion", &block)
+  # Draw context methods
+
+  def fill(color)
+    @draw_context["fill"] = color
+  end
+
+  def nofill
+    @draw_context["fill"] = ""
   end
 
-  def hover(&block)
-    subscription_item(shoes_api_name: "hover", &block)
+  def stroke(color)
+    @draw_context["stroke"] = color
+  end
+
+  def nostroke
+    @draw_context["stroke"] = ""
+  end
+
+  # Shape DSL methods
+
+  def move_to(x, y)
+    raise(Shoes::Errors::InvalidAttributeValueError, "Pass only Numeric arguments to move_to!") unless x.is_a?(Numeric) && y.is_a?(Numeric)
+
+    if current_slot.is_a?(::Shoes::Shape)
+      current_slot.add_shape_command(["move_to", x, y])
+    end
+  end
+
+  def line_to(x, y)
+    raise(Shoes::Errors::InvalidAttributeValueError, "Pass only Numeric arguments to line_to!") unless x.is_a?(Numeric) && y.is_a?(Numeric)
+
+    if current_slot.is_a?(::Shoes::Shape)
+      current_slot.add_shape_command(["line_to", x, y])
+    end
   end
 
-  def click(&block)
-    subscription_item(shoes_api_name: "click", &block)
+  def rotate(angle)
+    @draw_context["rotate"] = angle
   end
+  # Not implemented yet: curve_to, arc_to
 
   alias_method :info, :puts
 end

data/lib/{scarpe → shoes}/background.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-class Scarpe
+class Shoes
   module Background
     def self.included(includer)
-      includer.display_property(:background_color)
+      includer.shoes_style(:background_color)
     end
 
     # NOTE: this needs to be passed through in order for the styling to work

data/lib/{scarpe → shoes}/border.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-class Scarpe
+class Shoes
   module Border
     def self.included(includer)
-      includer.display_properties :border_color, :options
+      includer.shoes_styles :border_color, :options
     end
 
     # Considering a signature like this:

data/lib/shoes/builtins.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Shoes has a number of built-in methods that are intended to be available everywhere,
+# in every Shoes and non-Shoes class, for every Shoes app.
+module Shoes::Builtins
+  # Register the given font with Shoes so that text that wants it can use it.
+  # Also add it to the FONTS constant.
+  #
+  # @param font_file_or_url [String] the filename or URL for the font
+  # @return [void]
+  def font(font_file_or_url)
+    shoes_builtin("font", font_file_or_url)
+
+    font_name = File.basename(font_file_or_url, ".*")
+    Shoes::FONTS << font_name
+  end
+
+  def ask(message_string)
+    shoes_builtin("ask", message_string)
+  end
+
+  def alert(message)
+    shoes_builtin("alert", message)
+  end
+
+  def ask_color(title_bar)
+    shoes_builtin("ask_color", title_bar)
+  end
+
+  def ask_open_file()
+    shoes_builtin("ask_open_file")
+  end
+
+  def ask_save_file()
+    shoes_builtin("ask_save_file")
+  end
+
+  def ask_open_folder()
+    shoes_builtin("ask_open_folder")
+  end
+
+  def ask_save_folder()
+    shoes_builtin("ask_save_folder")
+  end
+
+  def confirm(question)
+    shoes_builtin("confirm", question)
+  end
+
+  # TO ADD: debug, error, info, warn
+  # TO VERIFY OR ADD: gradient, gray, rgb
+
+  private
+
+  def shoes_builtin(cmd_name, *args)
+    Shoes::DisplayService.dispatch_event("builtin", nil, cmd_name, args)
+    nil
+  end
+end
+
+module Kernel
+  include Shoes::Builtins
+end

data/lib/shoes/changelog.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "log"
+# require "scarpe/components/modular_logger"
+
+class Shoes
+  class Changelog
+    # include Shoes::Log
+
+    def initialize
+      #TODO : refer to  https://github.com/scarpe-team/scarpe/pull/400
+      #       and figure out how to use scarpe logger here without getting duplicate or nil error
+      # Shoes::Log.instance = Scarpe::Components::ModularLogImpl.new
+      # log_init("Changelog")
+    end
+
+    def get_latest_release_info
+      root_dir = File.dirname(__FILE__, 4) # this duplicates constants.rb, but how to share?
+
+      git_dir = "#{root_dir}/.git"
+      revision = nil
+      if File.exist?(git_dir)
+        revision = `git rev-parse HEAD`.chomp
+      end
+
+      changelog_file = "#{root_dir}/CHANGELOG.md"
+      if File.exist?(changelog_file)
+        changelog_content = File.read(changelog_file)
+        release_name_pattern = /^## \[(\d+\.\d+\.\d+)\] - (\d{4}-\d{2}-\d{2}) - (\w+)$/m
+        release_matches = changelog_content.scan(release_name_pattern)
+        latest_release = release_matches.max_by { |version, _date, _name| Gem::Version.new(version) }
+
+        if latest_release
+          #puts "Found release #{latest_release[0]} in CHANGELOG.md"
+          # @log.debug("Found release #{latest_release[0]} in CHANGELOG.md") # Logger isn't initialized yet
+          version_parts = latest_release[0].split(".").map(&:to_i)
+          rel_id = ("%02d%02d%02d" % version_parts).to_i
+
+          return({
+            RELEASE_NAME: latest_release[2],
+            RELEASE_BUILD_DATE: latest_release[1],
+            RELEASE_ID: rel_id,
+            REVISION: revision,
+          })
+        end
+      end
+
+      puts "No release found in CHANGELOG.md"
+      { RELEASE_NAME: nil, RELEASE_BUILD_DATE: nil, RELEASE_ID: nil, REVISION: revision }
+    end
+  end
+end

data/lib/{scarpe → shoes}/colors.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-class Scarpe
+class Shoes
   module Colors
+    extend self
+
     COLORS = {
       aliceblue: [240, 248, 255],
       antiquewhite: [250, 235, 215],

data/lib/shoes/constants.rb

@@ -1,26 +1,47 @@
 # frozen_string_literal: true
 
-require "tmpdir"
-
-module Shoes
+require_relative "changelog"
+class Shoes
   module Constants
     def self.find_lib_dir
+      begin
+        require "tmpdir"
+      rescue LoadError
+        return nil
+      end
       homes = [
         [ENV["LOCALAPPDATA"], "Shoes"],
         [ENV["APPDATA"], "Shoes"],
         [ENV["HOME"], ".shoes"],
         [Dir.tmpdir, "shoes"],
       ]
+
       top, file = homes.detect { |home_top, _| home_top && File.exist?(home_top) }
       File.join(top, file)
     end
 
+    # A temp dir for Shoes app files
     LIB_DIR = find_lib_dir
 
+    # the Shoes library dir
+    DIR = File.dirname(__FILE__, 4)
+
     # Math constants from Shoes3
     RAD2PI = 0.01745329251994329577
     TWO_PI = 6.28318530717958647693
     HALF_PI = 1.57079632679489661923
     PI = 3.14159265358979323846
+
+    # This should be set up by the Display Service when it loads
+    FONTS = []
   end
+
+  # Access and assign the release constants
+  changelog_instance = Shoes::Changelog.new
+  RELEASE_INFO = changelog_instance.get_latest_release_info
+  RELEASE_NAME = RELEASE_INFO[:RELEASE_NAME]
+  RELEASE_ID = RELEASE_INFO[:RELEASE_ID]
+  RELEASE_BUILD_DATE = RELEASE_INFO[:RELEASE_BUILD_DATE]
+  RELEASE_TYPE = "LOOSE_SHOES" # This isn't really a thing any more
+  REVISION = RELEASE_INFO[:REVISION]
 end

data/lib/{scarpe → shoes}/display_service.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-# Scarpe Shoes apps operate in multiple layers. A Shoes widget tree exists as fairly
-# plain, simple Ruby objects. And then a display-service widget tree integrates with
-# the display technology, initially Webview. This lets us use Ruby as our API while
-# not tying it too closely to the limitations of Webview.
+# Lacci Shoes apps operate in multiple layers. A Shoes drawable tree exists as fairly
+# plain, simple Ruby objects. And then a display-service drawable tree integrates with
+# the display technology. This lets us use Ruby as our API while
+# not tying it too closely to the limitations of Webview, WASM, LibUI, etc.
 #
 # ## Choosing Display Services
 #
-# Before running a Scarpe app, you can set SCARPE_DISPLAY_SERVICE. If you
+# Before running a Lacci app, you can set SCARPE_DISPLAY_SERVICE. If you
 # set it to "whatever_service", Scarpe will require "scarpe/whatever_service",
 # which can be supplied by the Scarpe gem or another Scarpe-based gem.
 # Currently leaving the environment variable empty is equivalent to requesting
@@ -15,24 +15,22 @@
 #
 # ## Events
 #
-# Events are a lot of what tie the Shoes widgets and the display service together.
+# Events are a lot of what tie the Shoes drawables and the display service together.
 #
-# Scarpe widgets *expect* to operate in a fairly "hands off" mode where they record
+# Shoes drawables *expect* to operate in a fairly "hands off" mode where they record
 # to an event queue to send to the display service, and the display service records
 # events to send back.
 #
 # When a Shoes handler takes an action (e.g. some_para.replace(),) the relevant
 # call will be dispatched as a :display event, to be sent to the display service.
 # And when a display-side event occurs (e.g. user pushes a button,) it will be
-# dispatched as a :shoes event, to be sent to the Shoes tree of widgets.
+# dispatched as a :shoes event, to be sent to the Shoes tree of drawables.
 #
-module Shoes
+class Shoes
   class DisplayService
     class << self
       # This is in the eigenclass/metaclass, *not* instances of DisplayService
-      include Scarpe::Log
-
-      attr_accessor :json_debug_serialize
+      include Shoes::Log
 
       # An event_target may be nil, to indicate there is no target.
       def dispatch_event(event_name, event_target, *args, **kwargs)
@@ -46,7 +44,8 @@ module Shoes
 
         @log.debug("Dispatch event: #{event_name.inspect} T: #{event_target.inspect} A: #{args.inspect} KW: #{kwargs.inspect}")
 
-        if DisplayService.json_debug_serialize
+        # When true, this makes sure all events and properties are 100% strings, no symbols.
+        if ENV["SCARPE_DEBUG"]
           args = JSON.parse JSON.dump(args)
           new_kw = {}
           kwargs.each do |k, v|
@@ -129,22 +128,32 @@ module Shoes
 
     # These methods are an interface to DisplayService objects.
 
-    def create_display_widget_for(widget_class_name, widget_id, properties)
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties, is_widget:)
       raise "Override in DisplayService implementation!"
     end
 
-    def set_widget_pairing(id, display_widget)
-      @display_widget_for ||= {}
-      @display_widget_for[id] = display_widget
+    def set_drawable_pairing(id, display_drawable)
+      if id.nil?
+        raise Shoes::Errors::BadLinkableIdError, "Linkable ID may not be nil!"
+      end
+
+      @display_drawable_for ||= {}
+      if @display_drawable_for[id]
+        raise Shoes::Errors::DuplicateCreateDrawableError, "There is already a drawable for #{id.inspect}! Not setting a new one."
+      end
+
+      @display_drawable_for[id] = display_drawable
+      nil
     end
 
-    def query_display_widget_for(id, nil_ok: false)
-      display_widget = @display_widget_for[id]
-      unless display_widget || nil_ok
-        raise "Could not find display widget for linkable ID #{id.inspect}!"
+    def query_display_drawable_for(id, nil_ok: false)
+      @display_drawable_for ||= {}
+      display_drawable = @display_drawable_for[id]
+      unless display_drawable || nil_ok
+        raise "Could not find display drawable for linkable ID #{id.inspect}!"
       end
 
-      display_widget
+      display_drawable
     end
 
     def destroy
@@ -164,6 +173,8 @@ module Shoes
 
     def initialize(linkable_id: object_id)
       @linkable_id = linkable_id
+      @subscriptions = {}
+      @display_drawable_for ||= {}
     end
 
     def send_self_event(*args, event_name:, **kwargs)
@@ -175,11 +186,22 @@ module Shoes
     end
 
     def bind_shoes_event(event_name:, target: nil, &handler)
-      DisplayService.subscribe_to_event(event_name, target, &handler)
+      sub = DisplayService.subscribe_to_event(event_name, target, &handler)
+      @subscriptions[sub] = true
+      sub
     end
 
     def unsub_shoes_event(unsub_id)
+      unless @subscriptions[unsub_id]
+        $stderr.puts "Unsubscribing from event that isn't in subscriptions! #{unsub_id.inspect}"
+      end
       DisplayService.unsub_from_events(unsub_id)
+      @subscriptions.delete unsub_id
+    end
+
+    def unsub_all_shoes_events
+      @subscriptions.keys.each { |k| DisplayService.unsub_from_events(k) }
+      @subscriptions.clear
     end
   end
 end