scarpe 0.2.0 → 0.2.2

data/{lib/scarpe → lacci/lib/shoes/widgets}/para.rb

@@ -1,15 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class Para < Scarpe::Widget
-    class << self
-      def inherited(subclass)
-        Scarpe::Widget.widget_classes ||= []
-        Scarpe::Widget.widget_classes << subclass
-        super
-      end
-    end
-
+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)
@@ -42,24 +34,10 @@ class Scarpe
       # This should signal the display widget to change
       self.text_items = text_children_to_items(@text_children)
     end
-
-    def hide
-      # idempotent
-      return unless @hidden_text_items.empty?
-
-      @hidden_text_items = self.text_items
-      self.text_items = []
-    end
-
-    def show
-      # idempotent
-      return unless self.text_items.empty?
-
-      self.text_items = @hidden_text_items
-      @hidden_text_items = []
-    end
   end
+end
 
+module Shoes
   class Widget
     def banner(*args, **kwargs)
       para(*args, **{ size: :banner }.merge(kwargs))

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

@@ -0,0 +1,35 @@
+# 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/shape.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Shoes
+  # A Shape acts as a sort of union type for drawn shapes. In Shoes you can use it to merge multiple
+  # ovals, arcs, stars, etc. into a single drawn shape.
+  #
+  # In Shoes3, a Shape isn't really a Slot. It's a kind of DSL with drawing commands that happen
+  # to have the same name as the Art widgets like star, arc, etc. Here we're treating it as
+  # a slot containing those widgets, which is wrong but not *too* wrong.
+  #
+  # @incompatibility A Shoes3 Shape is *not* a slot; Scarpe does *not* do union shapes
+  class Shape < Shoes::Slot
+    display_properties :left, :top, :shape_commands, :draw_context
+
+    def initialize(left: nil, top: nil, &block)
+      @left = left
+      @top = top
+      @shape_commands = []
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+      create_display_widget
+
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+
+    # The cmd should be an array of the form:
+    #
+    #     [cmd_name, *args]
+    #
+    # such as ["move_to", 50, 50]. Note that these must
+    # be JSON-serializable.
+    def add_shape_command(cmd)
+      @shape_commands << cmd
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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/{lib/scarpe → lacci/lib/shoes/widgets}/span.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class Span < Scarpe::Widget
+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)

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Stack < Shoes::Slot
+    include Shoes::Background
+    include Shoes::Border
+    include Shoes::Spacing
+
+    # TODO: sort out various margin and padding properties, including putting stuff into spacing
+    display_properties :width, :height, :scroll
+
+    def initialize(width: nil, height: nil, margin: nil, padding: nil, scroll: false, margin_top: nil, margin_bottom: nil, margin_left: nil,
+      margin_right: nil, **options, &block)
+
+      @options = options
+
+      super
+
+      create_display_widget
+      # Create the display-side widget *before* running the block, which will add child widgets with their display widgets
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+  end
+end

data/{lib/scarpe → lacci/lib/shoes/widgets}/star.rb

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "wv/shape_helper"
-class Scarpe
-  class InvalidAttributeValueError < Scarpe::Error; end
-
-  class Star < Scarpe::Widget
-    include ShapeHelper
-    display_properties :left, :top, :points, :outer, :inner, :color
+module Shoes
+  class Star < Shoes::Widget
+    display_properties :left, :top, :points, :outer, :inner, :draw_context
 
     def initialize(left, top, points = 10, outer = 100, inner = 50)
       @points = convert_to_integer(points, "points", 10)
       @outer = convert_to_float(outer, "outer", 100.0)
       @inner = convert_to_float(inner, "inner", 50.0)
-      @color = color_for_fill
 
-      super()
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
       create_display_widget
     end
 

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Certain Shoes calls like motion and keydown are basically an
+# event subscription, with no other visible presence. However,
+# they have a place in the widget tree and can be deleted.
+#
+# Depending on the display library they may not have any
+# direct visual (or similar) presence there either.
+#
+# Inheriting from Widget gives these a parent slot and a
+# linkable_id automatically.
+class Shoes::SubscriptionItem < Shoes::Widget
+  display_property :shoes_api_name
+
+  def initialize(shoes_api_name:, &block)
+    super
+
+    @callback = block
+
+    case shoes_api_name
+    when "hover"
+      # Hover passes the Shoes widget as the block param
+      @unsub_id = bind_self_event("hover") do
+        @callback&.call(self)
+      end
+    when "motion"
+      # Shoes sends back x, y, mods as the args.
+      # Shoes3 uses the strings "control" "shift" and
+      # "control_shift" as the mods arg.
+      @unsub_id = bind_self_event("motion") do |x, y, ctrl_key, shift_key, **_kwargs|
+        mods = [ctrl_key ? "control" : nil, shift_key ? "shift" : nil].compact.join("_")
+        @callback&.call(x, y, mods)
+      end
+    when "click"
+      # Click has block params button, left, top
+      # button is the button number, left and top are coords
+      @unsub_id = bind_self_event("click") do |button, x, y, **_kwargs|
+        @callback&.call(button, x, y)
+      end
+    else
+      raise "Unknown Shoes API call #{shoes_api_name.inspect} passed to SubscriptionItem!"
+    end
+
+    @unsub_id = bind_self_event(shoes_api_name) do |*args|
+      @callback&.call(*args)
+    end
+
+    # This won't create a visible display widget, but will turn into
+    # an invisible widget and a stream of events.
+    create_display_widget
+  end
+
+  def destroy
+    # TODO: we need a better way to do this automatically. See https://github.com/scarpe-team/scarpe/issues/291
+    unsub_shoes_event(@unsub_id) if @unsub_id
+    @unsub_id = nil
+
+    super
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Shoes::TextWidget
+
+module Shoes
+  class TextWidget < Shoes::Widget
+    class << self
+      # rubocop:disable Lint/MissingSuper
+      def inherited(subclass)
+        Shoes::Widget.widget_classes ||= []
+        Shoes::Widget.widget_classes << subclass
+      end
+      # rubocop:enable Lint/MissingSuper
+    end
+  end
+
+  class << self
+    def default_text_widget_with(element)
+      class_name = element.capitalize
+
+      widget_class = Class.new(Shoes::TextWidget) do
+        # Can we just change content to text to match the Shoes API?
+        display_property :content
+
+        def initialize(content)
+          @content = content
+
+          super
+
+          create_display_widget
+        end
+
+        def text
+          self.content
+        end
+
+        def text=(new_text)
+          self.content = new_text
+        end
+      end
+      Shoes.const_set class_name, widget_class
+      widget_class.class_eval do
+        display_property :content
+      end
+    end
+  end
+end
+
+Shoes.default_text_widget_with(:code)
+Shoes.default_text_widget_with(:em)
+Shoes.default_text_widget_with(:strong)

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Video < Shoes::Widget
+    display_properties :url
+
+    def initialize(url)
+      @url = url
+      super
+      create_display_widget
+    end
+
+    # other methods
+  end
+end

data/lacci/lib/shoes/widgets.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "shoes/widgets/slot"
+require "shoes/widgets/stack"
+require "shoes/widgets/flow"
+require "shoes/widgets/document_root"
+
+require "shoes/widgets/text_widget"
+
+require "shoes/widgets/font"
+require "shoes/widgets/subscription_item"
+
+require "shoes/widgets/arc"
+require "shoes/widgets/line"
+require "shoes/widgets/shape"
+require "shoes/widgets/star"
+
+require "shoes/widgets/alert"
+require "shoes/widgets/button"
+require "shoes/widgets/check"
+require "shoes/widgets/edit_box"
+require "shoes/widgets/edit_line"
+require "shoes/widgets/image"
+require "shoes/widgets/link"
+require "shoes/widgets/list_box"
+require "shoes/widgets/para"
+require "shoes/widgets/radio"
+require "shoes/widgets/span"
+require "shoes/widgets/video"

data/lacci/lib/shoes.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# We're separating Shoes from Scarpe, a little at a time. This should be requirable
+# without using Scarpe at all.
+#
+# The Lacci gem is like the old Shoes-core from Shoes4: a way
+# to handle the DSL and command-line parts of Shoes without knowing anything about how the
+# display side works at all.
+
+if RUBY_VERSION[0..2] < "3.2"
+  Shoes::Log.logger("Shoes").error("Lacci (Scarpe, Shoes) requires Ruby 3.2 or higher!")
+  exit(-1)
+end
+
+module Shoes; end
+class Shoes::Error < StandardError; end
+
+require_relative "shoes/constants"
+
+# Shoes adds some top-level methods and constants that can be used everywhere. Kernel is where they go.
+module Kernel
+  include Shoes::Constants
+end
+
+require_relative "shoes/log"
+require_relative "shoes/display_service"
+require_relative "shoes/colors"
+
+require_relative "shoes/background"
+require_relative "shoes/border"
+require_relative "shoes/spacing"
+
+require_relative "shoes/widget"
+require_relative "shoes/app"
+require_relative "shoes/widgets"
+
+require_relative "shoes/download"
+
+# The module containing Shoes in all its glory.
+# Shoes is a platform-independent GUI library, designed to create
+# small visual applications in Ruby.
+#
+module Shoes
+  class << self
+    # Creates a Shoes app with a new window. The block parameter is used to create
+    # widgets and set up handlers. Arguments are passed to Shoes::App.new internally.
+    #
+    # @incompatibility In Shoes3, this method will return normally.
+    #   In Scarpe, after the block is executed, the method will not return and Scarpe
+    #   will retain control of execution until the window is closed and the app quits.
+    #
+    # @incompatibility In Shoes3 the parameters were a hash of options, not keyword arguments.
+    #
+    # @example Simple one-button app
+    #   Shoes.app(title: "Button!", width: 200, height: 200) do
+    #     @p = para "Press it NOW!"
+    #     button("clicky") { @p.replace("You pressed it! CELEBRATION!") }
+    #   end
+    #
+    # @param title [String] The new app window title
+    # @param width [Integer] The new app window width
+    # @param height [Integer] The new app window height
+    # @param resizable [Boolean] Whether the app window should be resizeable
+    # @return [void]
+    # @see Shoes::App#new
+    def app(
+      title: "Shoes!",
+      width: 480,
+      height: 420,
+      resizable: true,
+      &app_code_body
+    )
+      app = Shoes::App.new(title:, width:, height:, resizable:, &app_code_body)
+      app.init
+      app.run
+      nil
+    end
+
+    # Load a Shoes app from a file. By default, this will load old-style Shoes apps
+    # from a .rb file with all the appropriate libraries loaded. By setting one or
+    # more loaders, a Lacci-based display library can accept new file formats as
+    # well, not just raw Shoes .rb files.
+    #
+    # @param path [String] The current-dir-relative path to the file
+    # @return [void]
+    # @see Shoes.add_file_loader
+    def run_app(relative_path)
+      path = File.expand_path relative_path
+      loaded = false
+      file_loaders.each do |loader|
+        if loader.call(path)
+          loaded = true
+          break
+        end
+      end
+      raise "Could not find a file loader for #{path.inspect}!" unless loaded
+
+      nil
+    end
+
+    def default_file_loaders
+      [
+        # By default we will always try to load any file, regardless of extension, as a Shoes Ruby file.
+        proc do |path|
+          load path
+          true
+        end,
+      ]
+    end
+
+    def file_loaders
+      @file_loaders ||= default_file_loaders
+    end
+
+    def add_file_loader(loader)
+      file_loaders.prepend(loader)
+    end
+
+    def reset_file_loaders
+      @file_loaders = default_file_loaders
+    end
+
+    def set_file_loaders(loaders)
+      @file_loaders = loaders
+    end
+  end
+end

data/lacci/test/test_colors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestColors < Minitest::Test
+  class Dummy
+    include Shoes::Colors
+  end
+
+  def test_default_colors_are_accessible_via_methods
+    assert_equal [0, 0, 0, 255], Dummy.new.black
+    assert_equal [255, 255, 255, 255], Dummy.new.white
+  end
+
+  def test_default_colors_can_accept_alpha
+    assert_equal [0, 0, 0, 0.5], Dummy.new.black(0.5)
+  end
+
+  def test_gray_accepts_single_value_for_darkness
+    assert_equal [0, 0, 0, 255], Dummy.new.gray(0)
+    assert_equal [255, 255, 255, 255], Dummy.new.gray(255)
+  end
+
+  def test_gray_accepts_darkness_and_alpha
+    assert_equal [0, 0, 0, 128], Dummy.new.gray(0, 128)
+  end
+
+  def test_gray_defaults_to_50_percent_darkness
+    assert_equal [128, 128, 128, 255], Dummy.new.gray
+  end
+
+  def test_rgb_accepts_three_values
+    assert_equal [255, 0, 0, 255], Dummy.new.rgb(255, 0, 0)
+  end
+
+  def test_rgb_accepts_alpha
+    assert_equal [255, 0, 0, 128], Dummy.new.rgb(255, 0, 0, 128)
+  end
+end

data/lacci/test/test_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "shoes"
+
+require "minitest/autorun"
+
+require "minitest/reporters"
+Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]

data/lacci/test/test_lacci.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestLacci < Minitest::Test
+  def test_truth
+    assert_equal true, true
+  end
+end