lacci 0.2.2 → 0.3.0

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/shoes/colors.rb

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

data/lib/shoes/constants.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-module Shoes
+require_relative "changelog"
+class Shoes
   module Constants
     def self.find_lib_dir
       begin
@@ -14,16 +15,33 @@ module 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/shoes/display_service.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Lacci 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
+# 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.
 #
@@ -15,18 +15,18 @@
 #
 # ## 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.
 #
-# Shoes 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
@@ -128,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
@@ -163,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)
@@ -174,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

data/lib/shoes/download.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Shoes
-  class Widget
+class Shoes
+  class Drawable
     class ResponseWrapper
       attr_reader :response
 

data/lib/shoes/drawable.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+class Shoes
+  # Shoes::Drawable
+  #
+  # This is the display-service portable Shoes Drawable interface. Visible Shoes
+  # drawables like buttons inherit from this. Compound drawables made of multiple
+  # different smaller Drawables inherit from it in their various apps or libraries.
+  # The Shoes Drawable helps build a Shoes-side drawable tree, with parents and
+  # children. Any API that applies to all drawables (e.g. remove) should be
+  # defined here.
+  #
+  class Drawable < Shoes::Linkable
+    include Shoes::Log
+    include Shoes::Colors
+
+    # All Drawables have these so they go in Shoes::Drawable and are inherited
+    @shoes_events = ["parent", "destroy", "prop_change"]
+
+    class << self
+      attr_accessor :drawable_classes
+      attr_accessor :drawable_default_styles
+      attr_accessor :widget_classes
+
+      def inherited(subclass)
+        Shoes::Drawable.drawable_classes ||= []
+        Shoes::Drawable.drawable_classes << subclass
+
+        Shoes::Drawable.drawable_default_styles ||= {}
+        Shoes::Drawable.drawable_default_styles[subclass] = {}
+
+        Shoes::Drawable.widget_classes ||= []
+        if subclass < Shoes::Widget
+          Shoes::Drawable.widget_classes << subclass.name
+        end
+
+        super
+      end
+
+      def dsl_name
+        n = name.split("::").last.chomp("Drawable")
+        n.gsub(/(.)([A-Z])/, '\1_\2').downcase
+      end
+
+      def drawable_class_by_name(name)
+        drawable_classes.detect { |k| k.dsl_name == name.to_s }
+      end
+
+      def is_widget_class?(name)
+        !!Shoes::Drawable.widget_classes.intersect?([name.to_s])
+      end
+
+      def validate_as(prop_name, value)
+        prop_name = prop_name.to_s
+        hashes = shoes_style_hashes
+
+        h = hashes.detect { |hash| hash[:name] == prop_name }
+        raise(Shoes::Errors::NoSuchStyleError, "Can't find property #{prop_name.inspect} in #{self} property list: #{hashes.inspect}!") unless h
+
+        return value if h[:validator].nil?
+
+        h[:validator].call(value)
+      end
+
+      # Return a list of Shoes events for this class.
+      #
+      # @return Array[String] the list of event names
+      def get_shoes_events
+        if @shoes_events.nil?
+          raise UnknownEventsForClass, "Drawable type #{self.class} hasn't defined its list of Shoes events!"
+        end
+
+        @shoes_events
+      end
+
+      # Set the list of Shoes event names that are allowed for this class.
+      #
+      # @param args [Array] an array of event names, which will be coerced to Strings
+      # @return [void]
+      def shoes_events(*args)
+        @shoes_events ||= args.map(&:to_s) + self.superclass.get_shoes_events
+      end
+
+      # Assign a new Shoes Drawable ID number, starting from 1.
+      # This allows non-overlapping small integer IDs for Shoes
+      # linkable IDs - the number part of making it clear what
+      # widget you're talking about.
+      def allocate_drawable_id
+        @drawable_id_counter ||= 0
+        @drawable_id_counter += 1
+        @drawable_id_counter
+      end
+
+      def register_drawable_id(id, drawable)
+        @drawables_by_id ||= {}
+        @drawables_by_id[id] = drawable
+      end
+
+      def unregister_drawable_id(id)
+        @drawables_by_id ||= {}
+        @drawables_by_id.delete(id)
+      end
+
+      def drawable_by_id(id, none_ok: false)
+        val = @drawables_by_id[id]
+        unless val || none_ok
+          raise "No Drawable Found! #{@drawables_by_id.inspect}"
+        end
+
+        val
+      end
+
+      private
+
+      def linkable_properties
+        @linkable_properties ||= []
+      end
+
+      def linkable_properties_hash
+        @linkable_properties_hash ||= {}
+      end
+
+      public
+
+      # Shoes styles in Shoes Linkables are automatically sync'd with the display side objects.
+      # If a block is passed to shoes_style, that's the validation for the property. It should
+      # convert a given value to a valid value for the property or throw an exception.
+      def shoes_style(name, &validator)
+        name = name.to_s
+
+        return if linkable_properties_hash[name]
+
+        linkable_properties << { name: name, validator: }
+        linkable_properties_hash[name] = true
+      end
+
+      # Add these names as Shoes styles
+      def shoes_styles(*names)
+        names.each { |n| shoes_style(n) }
+      end
+
+      def shoes_style_names
+        parent_prop_names = self != Shoes::Drawable ? self.superclass.shoes_style_names : []
+
+        parent_prop_names | linkable_properties.map { |prop| prop[:name] }
+      end
+
+      def shoes_style_hashes
+        parent_hashes = self != Shoes::Drawable ? self.superclass.shoes_style_hashes : []
+
+        parent_hashes + linkable_properties
+      end
+
+      def shoes_style_name?(name)
+        linkable_properties_hash[name.to_s] ||
+          (self != Shoes::Drawable && superclass.shoes_style_name?(name))
+      end
+    end
+
+    # Shoes uses a "hidden" style property for hide/show
+    shoes_style :hidden
+
+    attr_reader :debug_id
+
+    def initialize(*args, **kwargs)
+      log_init("Shoes::#{self.class.name}")
+
+      default_styles = Shoes::Drawable.drawable_default_styles[self.class]
+
+      self.class.shoes_style_names.each do |prop|
+        prop_sym = prop.to_sym
+        if kwargs.key?(prop_sym)
+          val = self.class.validate_as(prop, kwargs[prop_sym])
+          instance_variable_set("@" + prop, val)
+        elsif default_styles.key?(prop_sym)
+          val = self.class.validate_as(prop, default_styles[prop_sym])
+          instance_variable_set("@" + prop, val)
+        end
+      end
+
+      super(linkable_id: Shoes::Drawable.allocate_drawable_id)
+      Shoes::Drawable.register_drawable_id(self.linkable_id, self)
+
+      generate_debug_id
+    end
+
+    # Calling stack.app or drawable.app will execute the block
+    # with the Shoes::App as self, and with that stack or
+    # flow as the current slot.
+    #
+    # @incompatibility In Shoes Classic this is the only way
+    #   to change self, while Scarpe will also change self
+    #   with the other Slot Manipulation methods: #clear,
+    #   #append, #prepend, #before and #after.
+    #
+    # @return [Shoes::App] the Shoes app
+    # @yield the block to call with the Shoes App as self
+    def app(&block)
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+      Shoes::App.instance
+    end
+
+    private
+
+    def generate_debug_id
+      cl = caller_locations(3)
+      da = cl.detect { |loc| !loc.path.include?("lacci/lib/shoes") }
+      @drawable_defined_at = "#{File.basename(da.path)}:#{da.lineno}"
+
+      class_name = self.class.name.split("::")[-1]
+
+      @debug_id = "#{class_name}##{@linkable_id}(#{@drawable_defined_at})"
+    end
+
+    public
+
+    def inspect
+      "#<#{debug_id} " +
+        " @parent=#{@parent ? @parent.debug_id : "(none)"} " +
+        "@children=#{@children ? @children.map(&:debug_id) : "(none)"} properties=#{shoes_style_values.inspect}>"
+    end
+
+    private
+
+    def validate_event_name(event_name)
+      unless self.class.get_shoes_events.include?(event_name.to_s)
+        raise Shoes::UnregisteredShoesEvent, "Drawable #{self.inspect} tried to bind Shoes event #{event_name}, which is not in #{evetns.inspect}!"
+      end
+    end
+
+    def bind_self_event(event_name, &block)
+      raise(Shoes::Errors::NoLinkableIdError, "Drawable has no linkable_id! #{inspect}") unless linkable_id
+
+      validate_event_name(event_name)
+
+      bind_shoes_event(event_name: event_name, target: linkable_id, &block)
+    end
+
+    def bind_no_target_event(event_name, &block)
+      validate_event_name(event_name)
+
+      bind_shoes_event(event_name:, &block)
+    end
+
+    public
+
+    def event(event_name, *args, **kwargs)
+      validate_event_name(event_name)
+
+      send_shoes_event(*args, **kwargs, event_name:, target: linkable_id)
+    end
+
+    def shoes_style_values
+      all_property_names = self.class.shoes_style_names
+
+      properties = {}
+      all_property_names.each do |prop|
+        properties[prop] = instance_variable_get("@" + prop)
+      end
+      properties["shoes_linkable_id"] = self.linkable_id
+      properties
+    end
+
+    def style(*args, **kwargs)
+      if args.empty? && kwargs.empty?
+        # Just called as .style()
+        shoes_style_values
+      elsif args.empty?
+        # This is called to set one or more Shoes styles
+        prop_names = self.class.shoes_style_names
+        unknown_styles = kwargs.keys.select { |k| !prop_names.include?(k.to_s) }
+        unless unknown_styles.empty?
+          raise Shoes::Errors::NoSuchStyleError, "Unknown styles for drawable type #{self.class.name}: #{unknown_styles.join(", ")}"
+        end
+
+        kwargs.each do |name, val|
+          instance_variable_set("@#{name}", val)
+        end
+      elsif args.length == 1 && args[0] < Shoes::Drawable
+        # Shoes supports calling .style with a Shoes class, e.g. .style(Shoes::Button, displace_left: 5)
+        kwargs.each do |name, val|
+          Shoes::Drawable.drawable_default_styles[args[0]][name.to_sym] = val
+        end
+      else
+        raise Shoes::Errors::InvalidAttributeValueError, "Unexpected arguments to style! args: #{args.inspect}, keyword args: #{kwargs.inspect}"
+      end
+    end
+
+    private
+
+    def create_display_drawable
+      klass_name = self.class.name.delete_prefix("Scarpe::").delete_prefix("Shoes::")
+
+      is_widget = Shoes::Drawable.is_widget_class?(klass_name)
+
+      # Should we send an event so this can be discovered from someplace other than
+      # the DisplayService?
+      ::Shoes::DisplayService.display_service.create_display_drawable_for(klass_name, self.linkable_id, shoes_style_values, is_widget:)
+    end
+
+    public
+
+    attr_reader :parent
+    attr_reader :destroyed
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+      send_shoes_event(new_parent.linkable_id, event_name: "parent", target: linkable_id)
+    end
+
+    # Removes the element from the Shoes::Drawable tree and removes all event subscriptions
+    def destroy
+      @parent&.remove_child(self)
+      @parent = nil
+      @destroyed = true
+      unsub_all_shoes_events
+      send_shoes_event(event_name: "destroy", target: linkable_id)
+      Shoes::Drawable.unregister_drawable_id(linkable_id)
+    end
+    alias_method :remove, :destroy
+
+    # Hide the drawable.
+    def hide
+      self.hidden = true
+    end
+
+    # Show the drawable.
+    def show
+      self.hidden = false
+    end
+
+    # Hide the drawable if it is currently shown. Show it if it is currently hidden.
+    def toggle
+      self.hidden = !self.hidden
+    end
+
+    # We use method_missing to auto-create Shoes style getters and setters.
+    def method_missing(name, *args, **kwargs, &block)
+      name_s = name.to_s
+
+      if name_s[-1] == "="
+        prop_name = name_s[0..-2]
+        if self.class.shoes_style_name?(prop_name)
+          self.class.define_method(name) do |new_value|
+            raise(Shoes::Errors::NoLinkableIdError, "Trying to set Shoes styles in an object with no linkable ID! #{inspect}") unless linkable_id
+
+            new_value = self.class.validate_as(prop_name, new_value)
+            instance_variable_set("@" + prop_name, new_value)
+            send_shoes_event({ prop_name => new_value }, event_name: "prop_change", target: linkable_id)
+          end
+
+          return self.send(name, *args, **kwargs, &block)
+        end
+      end
+
+      if self.class.shoes_style_name?(name_s)
+        self.class.define_method(name) do
+          raise(Shoes::Errors::NoLinkableIdError, "Trying to get Shoes styles in an object with no linkable ID! #{inspect}") unless linkable_id
+
+          instance_variable_get("@" + name_s)
+        end
+
+        return self.send(name, *args, **kwargs, &block)
+      end
+
+      super(name, *args, **kwargs, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name_s = name.to_s
+      return true if self.class.shoes_style_name?(name_s)
+      return true if self.class.shoes_style_name?(name_s[0..-2]) && name_s[-1] == "="
+      return true if Drawable.drawable_class_by_name(name_s)
+
+      super
+    end
+  end
+end