lacci 0.2.1 → 0.3.0

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

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "openssl"
-require "nokogiri"
-
-module Shoes
-  class Widget
+class Shoes
+  class Drawable
     class ResponseWrapper
       attr_reader :response
 
@@ -23,10 +19,14 @@ module Shoes
     end
 
     def download(url, method: "GET", save: nil, styles: {}, &block)
+      require "net/http"
+      require "openssl"
+      require "nokogiri"
+
       @block = block
 
       Thread.new do
-        logger = Scarpe::Logger.logger("Shoes::App#download")
+        logger = Shoes::Log.logger("Shoes::App#download")
         begin
           uri = URI(url)
           response = perform_request(uri, method, styles)

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

data/lib/shoes/drawables/arc.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Arc < Shoes::Drawable
+    shoes_style :draw_context
+    shoes_events # No Arc-specific events yet
+
+    [:left, :top, :width, :height].each do |prop|
+      shoes_style(prop) { |val| convert_to_integer(val, prop) }
+    end
+
+    [:angle1, :angle2].each do |prop|
+      shoes_style(prop) { |val| convert_to_float(val, prop) }
+    end
+
+    def initialize(*args)
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+      self.left, self.top, self.width, self.height, self.angle1, self.angle2 = args
+
+      create_display_drawable
+    end
+
+    def self.convert_to_integer(value, attribute_name)
+      begin
+        value = Integer(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
+
+    def self.convert_to_float(value, attribute_name)
+      begin
+        value = Float(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
+  end
+end

data/lib/shoes/drawables/arrow.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Arrow < Shoes::Drawable
+    shoes_style :draw_context
+    shoes_events # No Arrow-specific events yet
+
+    [:left, :top, :width].each do |prop|
+      shoes_style(prop) { |val| val.is_a?(Hash) ? val : convert_to_integer(val, prop) }
+    end
+
+    def initialize(*args)
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+
+      if args.length == 1 && args[0].is_a?(Hash)
+        options = args[0]
+        self.left = options[:left]
+        self.top = options[:top]
+        self.width = options[:width]
+      else
+        self.left, self.top, self.width = args
+      end
+
+      create_display_drawable
+    end
+
+    def self.convert_to_integer(value, attribute_name)
+      begin
+        value = Integer(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
+  end
+end

data/lib/shoes/drawables/button.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Button < Shoes::Drawable
+    include Shoes::Log
+    shoes_styles :text, :width, :height, :top, :left, :color, :padding_top, :padding_bottom, :text_color, :size, :font_size, :tooltip
+    shoes_events :click, :hover
+
+    # Creates a new Button object.
+    #
+    # @param text [String] The text displayed on the button.
+    # @param width [Integer] The requested width of the button in pixels.
+    # @param height [Integer] The requested height of the button in pixels.
+    # @param top [Integer] The position of the top edge of the button relative to its parent widget.
+    # @param left [Integer] The position of the left edge of the button relative to its parent widget.
+    # @param size [Integer] The font size of the button text.
+    # @param color [String] The background color of the button.
+    # @param padding_top [Integer] The padding above the button text.
+    # @param padding_bottom [Integer] The padding below the button text.
+    # @param text_color [String] The color of the button text.
+    # @yield A block of code to be executed when the button is clicked.
+    # @return [Shoes::Button] the button object
+    #
+    # @example
+    #   Shoes.app do
+    #     @push = button "Push me"
+    #     @note = para "Nothing pushed so far"
+    #     @push.click {
+    #       @note.replace(
+    #         "Aha! Click! ",
+    #         link("Go back") { @note.replace("Nothing pushed so far") }
+    #       )
+    #     }
+    #   end
+    def initialize(text, width: nil, height: nil, top: nil, left: nil, color: nil, padding_top: nil, padding_bottom: nil, size: 12, text_color: nil,
+      font_size: nil, tooltip: nil, &block)
+
+      log_init("Button")
+
+      # Properties passed as positional args, not keywords, don't get auto-set
+      @text = text
+      @block = block
+
+      super
+
+      # Bind to a handler named "click"
+      bind_self_event("click") do
+        @log.debug("Button clicked, calling handler") if @block
+        @block&.call
+      end
+
+      bind_self_event("hover") do
+        @hover&.call
+      end
+
+      create_display_drawable
+    end
+
+    # Set the click handler
+    #
+    # @yield A block to be called when the button is clicked.
+    def click(&block)
+      @block = block
+    end
+
+    # Set the hover handler
+    #
+    # @yield A block to be called when the cursor moves to be over the button.
+    def hover(&block)
+      @hover = block
+    end
+  end
+end

data/lib/shoes/drawables/check.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Check < Shoes::Drawable
+    shoes_styles :checked
+    shoes_events :click
+
+    def initialize(checked = nil, &block)
+      @block = block
+      super
+
+      bind_self_event("click") { click }
+      create_display_drawable
+    end
+
+    def click(&block)
+      @block = block
+      self.checked = !checked?
+    end
+
+    def checked?
+      @checked ? true : false
+    end
+
+    def checked(value)
+      self.checked = value
+    end
+  end
+end

data/lib/{scarpe → shoes/drawables}/document_root.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class DocumentRoot < Scarpe::Flow
+class Shoes
+  class DocumentRoot < Shoes::Flow
+    shoes_events # No DocumentRoot-specific events yet
+
     def initialize
       @height = "100%"
       @width = @margin = @padding = nil
       @options = {}
 
       super
-
-      create_display_widget
     end
 
     # The default inspect string can be absolutely huge in console output, and it's frequently printed.
     def inspect
-      "<Scarpe::DocumentRoot>"
+      "<Shoes::DocumentRoot>"
     end
   end
 end

data/lib/{scarpe → shoes/drawables}/edit_box.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class EditBox < Shoes::Widget
-    display_properties :text, :height, :width
+class Shoes
+  class EditBox < Shoes::Drawable
+    shoes_styles :text, :height, :width
+    shoes_events :change
 
     def initialize(text = "", height: nil, width: nil, &block)
+      super
       @text = text
       @callback = block
 
-      super
-
       bind_self_event("change") do |new_text|
         self.text = new_text
         @callback&.call(self)
       end
 
-      create_display_widget
+      create_display_drawable
     end
 
     def change(&block)

data/lib/{scarpe → shoes/drawables}/edit_line.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class EditLine < Shoes::Widget
-    display_properties :text, :width
+class Shoes
+  class EditLine < Shoes::Drawable
+    shoes_styles :text, :width
+    shoes_events :change
 
     def initialize(text = "", width: nil, &block)
+      super
       @block = block
       @text = text
 
-      super
-
       bind_self_event("change") do |new_text|
         self.text = new_text
         @block&.call(new_text)
       end
 
-      create_display_widget
+      create_display_drawable
     end
 
     def change(&block)