scarpe 0.2.2 → 0.4.0

data/lacci/lib/shoes/spacing.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  module Spacing
-    def self.included(includer)
-      includer.display_properties :margin, :padding, :margin_top, :margin_left, :margin_right, :margin_bottom, :options
-    end
-  end
-end

data/lacci/lib/shoes/widget.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  # Shoes::Widget
-  #
-  # This is the display-service portable Shoes Widget interface. Visible Shoes
-  # widgets like buttons inherit from this. Compound widgets made of multiple
-  # different smaller Widgets inherit from it in their various apps or libraries.
-  # The Shoes Widget helps build a Shoes-side widget tree, with parents and
-  # children. Any API that applies to all widgets (e.g. remove) should be
-  # defined here.
-  #
-  class Widget < Shoes::Linkable
-    include Shoes::Log
-    include Shoes::Colors
-
-    class << self
-      attr_accessor :widget_classes
-
-      def inherited(subclass)
-        Shoes::Widget.widget_classes ||= []
-        Shoes::Widget.widget_classes << subclass
-        super
-      end
-
-      def dsl_name
-        n = name.split("::").last.chomp("Widget")
-        n.gsub(/(.)([A-Z])/, '\1_\2').downcase
-      end
-
-      def widget_class_by_name(name)
-        widget_classes.detect { |k| k.dsl_name == name.to_s }
-      end
-
-      private
-
-      def linkable_properties
-        @linkable_properties ||= []
-      end
-
-      def linkable_properties_hash
-        @linkable_properties_hash ||= {}
-      end
-
-      public
-
-      # Display properties in Shoes Linkables are automatically sync'd with the display side objects.
-      # TODO: do we want types or other modifiers on specific properties?
-      def display_property(name)
-        name = name.to_s
-
-        return if linkable_properties_hash[name]
-
-        linkable_properties << { name: name }
-        linkable_properties_hash[name] = true
-      end
-
-      # Add these names as display properties
-      def display_properties(*names)
-        names.each { |n| display_property(n) }
-      end
-
-      def display_property_names
-        parent_prop_names = self != Shoes::Widget ? self.superclass.display_property_names : []
-
-        parent_prop_names | linkable_properties.map { |prop| prop[:name] }
-      end
-
-      def display_property_name?(name)
-        linkable_properties_hash[name.to_s] ||
-          (self != Shoes::Widget && superclass.display_property_name?(name))
-      end
-    end
-
-    # Shoes uses a "hidden" style property for hide/show
-    display_property :hidden
-
-    def initialize(*args, **kwargs)
-      log_init("Widget")
-
-      self.class.display_property_names.each do |prop|
-        if kwargs[prop.to_sym]
-          instance_variable_set("@" + prop, kwargs[prop.to_sym])
-        end
-      end
-
-      super() # linkable_id defaults to object_id
-    end
-
-    def inspect
-      "#<#{self.class}:#{self.object_id} " +
-        "@linkable_id=#{@linkable_id.inspect} @parent=#{@parent.inspect} " +
-        "@children=#{@children.inspect} properties=#{display_property_values.inspect}>"
-    end
-
-    private
-
-    def bind_self_event(event_name, &block)
-      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
-
-      bind_shoes_event(event_name: event_name, target: linkable_id, &block)
-    end
-
-    def bind_no_target_event(event_name, &block)
-      bind_shoes_event(event_name:, &block)
-    end
-
-    public
-
-    def display_property_values
-      all_property_names = self.class.display_property_names
-
-      properties = {}
-      all_property_names.each do |prop|
-        properties[prop] = instance_variable_get("@" + prop)
-      end
-      properties["shoes_linkable_id"] = self.linkable_id
-      properties
-    end
-
-    private
-
-    def create_display_widget
-      klass_name = self.class.name.delete_prefix("Scarpe::").delete_prefix("Shoes::")
-
-      # Should we save a reference to widget for later reference?
-      ::Shoes::DisplayService.display_service.create_display_widget_for(klass_name, self.linkable_id, display_property_values)
-    end
-
-    public
-
-    attr_reader :parent
-
-    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::Widget tree
-    def destroy
-      @parent&.remove_child(self)
-      send_shoes_event(event_name: "destroy", target: linkable_id)
-    end
-    alias_method :remove, :destroy
-
-    # Hide the widget.
-    def hide
-      self.hidden = true
-    end
-
-    # Show the widget.
-    def show
-      self.hidden = false
-    end
-
-    # Hide the widget if it is currently shown. Show it if it is currently hidden.
-    def toggle
-      self.hidden = !self.hidden
-    end
-
-    # We use method_missing for widget-creating methods like "button",
-    # and also to auto-create display-property 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.display_property_name?(prop_name)
-          self.class.define_method(name) do |new_value|
-            raise "Trying to set display properties in an object with no linkable ID!" unless linkable_id
-
-            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.display_property_name?(name_s)
-        self.class.define_method(name) do
-          raise "Trying to get display properties in an object with no linkable ID!" unless linkable_id
-
-          instance_variable_get("@" + name_s)
-        end
-
-        return self.send(name, *args, **kwargs, &block)
-      end
-
-      klass = Widget.widget_class_by_name(name)
-      return super unless klass
-
-      ::Shoes::Widget.define_method(name) do |*args, **kwargs, &block|
-        # Look up the Shoes widget and create it...
-        widget_instance = klass.new(*args, **kwargs, &block)
-
-        unless klass.ancestors.include?(Shoes::TextWidget)
-          widget_instance.set_parent Shoes::App.instance.current_slot
-        end
-
-        widget_instance
-      end
-
-      send(name, *args, **kwargs, &block)
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      name_s = name.to_s
-      return true if self.class.display_property_name?(name_s)
-      return true if self.class.display_property_name?(name_s[0..-2]) && name_s[-1] == "="
-      return true if Widget.widget_class_by_name(name_s)
-
-      super
-    end
-  end
-end

data/lacci/lib/shoes/widgets/alert.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Alert < Shoes::Widget
-    display_property :text
-
-    def initialize(text)
-      @text = text
-
-      super
-
-      bind_self_event("click") do
-        remove
-      end
-
-      create_display_widget
-    end
-  end
-end

data/lacci/lib/shoes/widgets/arc.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class InvalidAttributeValueError < Shoes::Error; end
-
-  class Arc < Shoes::Widget
-    display_properties :left, :top, :width, :height, :angle1, :angle2, :draw_context
-
-    def initialize(*args)
-      @left, @top, @width, @height, @angle1, @angle2 = args
-
-      @left = convert_to_integer(@left, "left")
-      @top = convert_to_integer(@top, "top")
-      @width = convert_to_integer(@width, "width")
-      @height = convert_to_integer(@height, "height")
-      @angle1 = convert_to_float(@angle1, "angle1")
-      @angle2 = convert_to_float(@angle2, "angle2")
-
-      @draw_context = Shoes::App.instance.current_draw_context
-
-      super
-      create_display_widget
-    end
-
-    private
-
-    def convert_to_integer(value, attribute_name)
-      begin
-        value = Integer(value)
-        raise 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 InvalidAttributeValueError, error_message
-      end
-    end
-
-    def convert_to_float(value, attribute_name)
-      begin
-        value = Float(value)
-        raise 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 InvalidAttributeValueError, error_message
-      end
-    end
-  end
-end

data/lacci/lib/shoes/widgets/button.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Button < Shoes::Widget
-    include Shoes::Log
-    display_properties :text, :width, :height, :top, :left, :color, :padding_top, :padding_bottom, :text_color, :size, :font_size
-
-    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, & block)
-
-      log_init("Button")
-
-      # Properties passed as positional args, not keywords, don't get auto-set
-      @text = text
-      @color = color
-
-      @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
-
-      create_display_widget
-    end
-
-    # Set the click handler
-    def click(&block)
-      @block = block
-    end
-  end
-end

data/lacci/lib/shoes/widgets/check.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Check < Shoes::Widget
-    display_properties :checked
-
-    def initialize(checked = nil, &block)
-      @block = block
-      super
-
-      bind_self_event("click") { click }
-      create_display_widget
-    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/lacci/lib/shoes/widgets/document_root.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class DocumentRoot < Shoes::Flow
-    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
-      "<Shoes::DocumentRoot>"
-    end
-  end
-end

data/lacci/lib/shoes/widgets/flow.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Flow < Shoes::Slot
-    include Shoes::Background
-    include Shoes::Border
-    include Shoes::Spacing
-
-    display_properties :width, :height, :margin, :padding
-
-    def initialize(width: "100%", height: nil, margin: nil, padding: nil, **options, &block)
-      @options = options
-
-      super
-
-      # Create the display-side widget *before* instance_eval, which will add child widgets with their display widgets
-      create_display_widget
-
-      Shoes::App.instance.with_slot(self, &block) if block_given?
-    end
-  end
-end

data/lacci/lib/shoes/widgets/font.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Font < Shoes::Widget
-    display_properties :font
-
-    def initialize(font)
-      @font = font
-      super
-
-      create_display_widget
-    end
-  end
-end

data/lacci/lib/shoes/widgets/line.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Line < Shoes::Widget
-    display_properties :left, :top, :x2, :y2, :draw_context
-
-    def initialize(left, top, x2, y2)
-      @left = left
-      @top = top
-      @x2 = x2
-      @y2 = y2
-      @draw_context = Shoes::App.instance.current_draw_context
-
-      super
-      create_display_widget
-    end
-  end
-end

data/lacci/lib/shoes/widgets/link.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Link < Shoes::TextWidget
-    display_properties :text, :click, :has_block
-
-    def initialize(text, click: nil, &block)
-      @text = text
-      @block = block
-      # We can't send a block to the display widget, but we can send a boolean
-      @has_block = !block.nil?
-
-      super
-
-      # The click property should be changed before it gets sent to the display widget
-      @click ||= "#"
-
-      bind_self_event("click") do
-        @block&.call
-      end
-
-      create_display_widget
-    end
-  end
-end

data/lacci/lib/shoes/widgets/list_box.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class ListBox < Shoes::Widget
-    display_properties :selected_item, :items, :height, :width
-
-    def initialize(args = {}, &block)
-      @items = args[:items] || []
-      @selected_item = args[:selected_item]
-      super()
-
-      bind_self_event("change") do |new_item|
-        self.selected_item = new_item
-        @callback&.call(new_item)
-      end
-
-      create_display_widget
-    end
-
-    def change(&block)
-      @callback = block
-      self # Allow chaining calls
-    end
-  end
-end

data/lacci/lib/shoes/widgets/para.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Para < Shoes::Widget
-    display_properties :text_items, :stroke, :size, :font, :html_attributes, :hidden
-
-    def initialize(*args, stroke: nil, size: :para, font: nil, hidden: false, **html_attributes)
-      @text_children = args || []
-      if hidden
-        @hidden_text_items = text_children_to_items(@text_children)
-        @text_items = []
-      else
-        # Text_children alternates strings and TextWidgets, so we can't just pass
-        # it as a display property. It won't serialize.
-        @text_items = text_children_to_items(@text_children)
-        @hidden_text_items = []
-      end
-      stroke = to_rgb(stroke)
-
-      @html_attributes = html_attributes || {}
-
-      super
-
-      create_display_widget
-    end
-
-    def text_children_to_items(text_children)
-      text_children.map { |arg| arg.is_a?(String) ? arg : arg.linkable_id }
-    end
-
-    def replace(*children)
-      @text_children = children
-
-      # This should signal the display widget to change
-      self.text_items = text_children_to_items(@text_children)
-    end
-  end
-end
-
-module Shoes
-  class Widget
-    def banner(*args, **kwargs)
-      para(*args, **{ size: :banner }.merge(kwargs))
-    end
-
-    def title(*args, **kwargs)
-      para(*args, **{ size: :title }.merge(kwargs))
-    end
-
-    def subtitle(*args, **kwargs)
-      para(*args, **{ size: :subtitle }.merge(kwargs))
-    end
-
-    def tagline(*args, **kwargs)
-      para(*args, **{ size: :tagline }.merge(kwargs))
-    end
-
-    def caption(*args, **kwargs)
-      para(*args, **{ size: :caption }.merge(kwargs))
-    end
-
-    def inscription(*args, **kwargs)
-      para(*args, **{ size: :inscription }.merge(kwargs))
-    end
-
-    alias_method :ins, :inscription
-  end
-end

data/lacci/lib/shoes/widgets/radio.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Radio < Shoes::Widget
-    display_properties :group, :checked
-
-    def initialize(group = nil, checked = nil, &block)
-      @group = group
-      @block = block
-      super
-
-      bind_self_event("click") { click }
-      create_display_widget
-    end
-
-    def click(&block)
-      @block = block
-      self.checked = !checked?
-    end
-
-    def checked?
-      @checked ? true : false
-    end
-
-    def checked(value)
-      self.checked = value
-    end
-
-    private
-
-    def group_name
-      @group || @parent
-    end
-  end
-end

data/lacci/lib/shoes/widgets/slot.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-class Shoes::Slot < Shoes::Widget
-  # @incompatibility Shoes uses #content, not #children, for this
-  attr_reader :children
-
-  # Do not call directly, use set_parent
-  def remove_child(child)
-    @children ||= []
-    unless @children.include?(child)
-      @log.warn("remove_child: no such child(#{child.inspect}) for parent(#{parent.inspect})!")
-    end
-    @children.delete(child)
-  end
-
-  # Do not call directly, use set_parent
-  def add_child(child)
-    @children ||= []
-    @children << child
-  end
-
-  # Get a list of child widgets
-  def contents
-    @children ||= []
-    @children.dup
-  end
-
-  # Calling stack.app or flow.app will execute the block
-  # with the Shoes::App as self, and with that stack or
-  # flow as the current slot.
-  #
-  # @incompatibility Shoes Classic will only change self
-  #   via this method, 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
-
-  # Remove all children from this widget. If a block
-  # is given, call the block to replace the children with
-  # new contents from that block.
-  #
-  # Should only be called on Slots, which can
-  # have children.
-  #
-  # @incompatibility Shoes Classic calls the clear block with current self, while Scarpe uses the Shoes::App as self
-  #
-  # @yield The block to call to replace the contents of the widget (optional)
-  # @return [void]
-  def clear(&block)
-    @children.dup.each(&:destroy)
-    append(&block) if block_given?
-    nil
-  end
-
-  # Call the block to append new children to a Slot.
-  #
-  # Should only be called on a Slot, since only Slots can have children.
-  #
-  # @incompatibility Shoes Classic calls the append block with current self, while Scarpe uses the Shoes::App as self
-  #
-  # @yield the block to call to replace children; will be called on the Shoes::App, appending to the called Slot as the current slot
-  # @return [void]
-  def append(&block)
-    raise("append requires a block!") unless block_given?
-    raise("Don't append to something that isn't a slot!") unless self.is_a?(Shoes::Slot)
-
-    Shoes::App.instance.with_slot(self, &block)
-  end
-end

data/lacci/lib/shoes/widgets/span.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Span < Shoes::Widget
-    display_properties :text, :stroke, :size, :font, :html_attributes
-
-    def initialize(text, stroke: nil, size: :span, font: nil, **html_attributes)
-      @text = text
-      @stroke = stroke
-      @size = size
-      @font = font
-      @html_attributes = html_attributes
-
-      super
-
-      create_display_widget
-    end
-
-    def replace(text)
-      @text = text
-
-      # This should signal the display widget to change
-      self.text = @text
-    end
-  end
-end