scarpe 0.2.1 → 0.3.0

data/lacci/lib/shoes/drawables/text_drawable.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Shoes
+  # TextDrawable is the parent class of various classes of
+  # text that can go inside a para. This includes normal
+  # text, but also links, italic text, bold text, etc.
+  class TextDrawable < Shoes::Drawable
+    class << self
+      # rubocop:disable Lint/MissingSuper
+      def inherited(subclass)
+        Shoes::Drawable.drawable_classes ||= []
+        Shoes::Drawable.drawable_classes << subclass
+
+        Shoes::Drawable.drawable_default_styles ||= {}
+        Shoes::Drawable.drawable_default_styles[subclass] = {}
+      end
+      # rubocop:enable Lint/MissingSuper
+    end
+
+    shoes_events # No TextDrawable-specific events yet
+  end
+
+  class << self
+    def default_text_drawable_with(element)
+      class_name = element.capitalize
+
+      drawable_class = Class.new(Shoes::TextDrawable) do
+        # Can we just change content to text to match the Shoes API?
+        shoes_style :content
+
+        def initialize(content)
+          super
+
+          @content = content
+
+          create_display_drawable
+        end
+
+        def text
+          self.content
+        end
+
+        def to_s
+          self.content
+        end
+
+        def text=(new_text)
+          self.content = new_text
+        end
+      end
+      Shoes.const_set class_name, drawable_class
+      drawable_class.class_eval do
+        shoes_style :content
+
+        shoes_events # No specific events
+      end
+    end
+  end
+end
+
+Shoes.default_text_drawable_with(:code)
+Shoes.default_text_drawable_with(:em)
+Shoes.default_text_drawable_with(:strong)

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Video < Shoes::Drawable
+    shoes_styles :url
+    shoes_events # No specific events yet
+
+    def initialize(url)
+      super
+      @url = url
+      create_display_drawable
+    end
+
+    # other methods
+  end
+end

data/lacci/lib/shoes/drawables/widget.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# A Shoes::Widget is mostly a Slot (related to the
+# old Shoes concepts of Canvas) that creates drawables
+# inside itself. When a subclass of Widget is created,
+# it adds a method to create new objects of that type
+# on Shoes::App and all Shoes slots.
+#
+# The hardest part with a Shoes::Widget is that it
+# should work fine even if initialize() doesn't call
+# super, which would make it hard to set up a Shoes
+# linkable_id, create a display widget, etc.
+#
+# It would be possible to add an extra method to set
+# these up and call it on every created drawable
+# in case a Widget's initialize method doesn't call
+# super, which happens quite often. But then we wouldn't
+# support automatic setting of styles (e.g. padding)
+# for the widget object itself, which is mostly a Flow.
+# We also couldn't support default styles -- I can't tell
+# whether Shoes supports these things either.
+#
+# But there's another way to do all of this. When a
+# subclass of Widget defines an initialize method,
+# we can catch the method_added hook, save a copy of
+# that initialize method, and substitute our own
+# initialize that calls super. We have to be a little
+# careful -- if the widget's initialize *does* call
+# super that shouldn't be an error. But that's
+# workable by defining an extra method with the
+# copied-method name that does nothing.
+
+##### TODO: when this is subclassed, grab :initialize out
+# of the subclass, put it into :initialize_widget, and
+# replace with an initialize that creates the display
+# widget propertly, sets the linkable_id, etc.
+
+class Shoes::Widget < Shoes::Slot
+  include Shoes::Background
+  include Shoes::Border
+  include Shoes::Spacing
+
+  shoes_events
+
+  def self.method_added(name)
+    # We're only looking for the initialize() method, and only on subclasses
+    # of Shoes::Widget, not Shoes::Widget itself.
+    return if self == ::Shoes::Widget || name != :initialize
+
+    # Need to avoid infinite adding of initialize() if we're re-adding the default initialize
+    return if @midway_through_adding_initialize
+
+    # Take the user-provided initialize method and save a copy named __widget_initialize
+    alias_method :__widget_initialize, :initialize
+
+    # And add the default initialize back where it belongs
+    @midway_through_adding_initialize = true
+    define_method(:initialize) do |*args, **kwargs, &block|
+      super(*args, **kwargs, &block)
+      @options = kwargs
+      create_display_drawable
+      __widget_initialize(*args, **kwargs, &block)
+
+      # Do Widgets do this?
+      Shoes::App.instance.with_slot(self, &block) if block
+    end
+    @midway_through_adding_initialize = false
+  end
+end

data/lacci/lib/shoes/drawables.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "shoes/drawables/slot"
+require "shoes/drawables/stack"
+require "shoes/drawables/flow"
+require "shoes/drawables/widget"
+require "shoes/drawables/document_root"
+
+require "shoes/drawables/text_drawable"
+
+require "shoes/drawables/subscription_item"
+
+require "shoes/drawables/arc"
+require "shoes/drawables/line"
+require "shoes/drawables/rect"
+require "shoes/drawables/shape"
+require "shoes/drawables/star"
+require "shoes/drawables/arrow"
+
+require "shoes/drawables/button"
+require "shoes/drawables/check"
+require "shoes/drawables/edit_box"
+require "shoes/drawables/edit_line"
+require "shoes/drawables/image"
+require "shoes/drawables/link"
+require "shoes/drawables/list_box"
+require "shoes/drawables/para"
+require "shoes/drawables/radio"
+require "shoes/drawables/span"
+require "shoes/drawables/video"
+require "shoes/drawables/progress"

data/lacci/lib/shoes/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Shoes; end
+class Shoes::Errors
+  class InvalidAttributeValueError < Shoes::Error; end
+
+  class TooManyInstancesError < Shoes::Error; end
+
+  class NoSuchListItemError < Shoes::Error; end
+
+  class DuplicateCreateDrawableError < Shoes::Error; end
+
+  class MultipleDrawablesFoundError < Shoes::Error; end
+
+  class NoDrawablesFoundError < Shoes::Error; end
+
+  class NoSuchStyleError < Shoes::Error; end
+
+  class NoLinkableIdError < Shoes::Error; end
+
+  class BadLinkableIdError < Shoes::Error; end
+
+  class UnregisteredShoesEvent < Shoes::Error; end
+
+  class SingletonError < Shoes::Error; end
+
+  class MultipleShoesSpecRunsError < Shoes::Error; end
+end

data/lacci/lib/shoes/log.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Old-style Shoes logging is really simple. We need more logging for our
+# framework, so we add a not-included-in-old-Shoes module for it. This adds
+# the *possibility* of logging, but Scarpe includes a much more
+# comprehensive solution that plugs into this one.
+
+# If used alone, this will fail because the @instance is nil. It needs
+# an implementation to be plugged in.
+
+class Shoes
+  LOG_LEVELS = [:debug, :info, :warn, :error, :fatal].freeze
+
+  # Include this module to get a @log instance variable to log as your
+  # configured component.
+  module Log
+    # These constants will wind up included in a lot of places. Should they move?
+    DEFAULT_COMPONENT = "default"
+    DEFAULT_LOG_CONFIG = {
+      "default" => "info",
+    }
+    DEFAULT_DEBUG_LOG_CONFIG = {
+      "default" => "debug",
+    }
+
+    class << self
+      attr_reader :instance
+      attr_reader :current_log_config
+
+      def instance=(impl_object)
+        raise(Shoes::Errors::TooManyInstancesError, "Already have an instance for Shoes::Log!") if @instance
+
+        @instance = impl_object
+      end
+
+      def logger(component = self)
+        @instance.logger_for_component(component)
+      end
+
+      def configure_logger(log_config)
+        @instance.configure_logger(log_config)
+      end
+    end
+
+    def log_init(component = self)
+      @log = Shoes::Log.instance.logger_for_component(component)
+    end
+  end
+
+  class LoggedWrapper
+    include ::Shoes::Log
+    def initialize(instance, component = instance)
+      log_init(component)
+
+      @instance = instance
+    end
+
+    def method_missing(method, ...)
+      self.singleton_class.define_method(method) do |*args, **kwargs, &block|
+        ret = @instance.send(method, *args, **kwargs, &block)
+        @log.info("Method: #{method} Args: #{args.inspect} KWargs: #{kwargs.inspect} Block: #{block ? "y" : "n"} Return: #{ret.inspect}")
+        ret
+      end
+      send(method, ...)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @instance.respond_to_missing?(method_name, include_private)
+    end
+  end
+end

data/lacci/lib/shoes/ruby_extensions.rb

@@ -0,0 +1,15 @@
+
+class Range
+  def rand
+    conv = (Integer === self.end && Integer === self.begin ? :to_i : :to_f)
+    ((Kernel.rand * (self.end - self.begin)) + self.begin).send(conv)
+  end
+end
+
+unless Time.respond_to? :today
+  def Time.today
+    t = Time.now
+    t - (t.to_i % 86_400)
+  end
+end
+

data/lacci/lib/shoes/spacing.rb

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

data/lacci/lib/shoes-spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+class Shoes
+  # A Scarpe-compatible display service can set Shoes::Spec.instance to
+  # a ShoesSpec testing class, and use it to run Shoes-Spec code.
+  # A Shoes application should never do this. It's intended to be used
+  # by display services.
+  module Spec
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(spec_inst)
+      if @instance && @instance != spec_inst
+        raise "Lacci can only use a single ShoesSpec implementation at one time!"
+      end
+
+      @instance = spec_inst
+    end
+  end
+
+  # ShoesSpec testing objects can optionally inherit from this object,
+  # which shows the ShoesSpec testing API.
+  #
+  # @see {Shoes::Spec.instance=}
+  class SpecInstance
+    # Once a Shoes app has been created, this method can be called to
+    # execute Shoes-Spec testing code for that application. Shoes-Spec
+    # uses Minitest for most of its APIs, and Minitest generally reports
+    # results with a class name and test name. If those aren't passed
+    # explicitly, the SpecInstance can choose reasonable defaults.
+    #
+    # The test code should be set up to run automatically from the
+    # display service's existing hooks. For instance, the code might
+    # run in response to the first heartbeat, if the display service
+    # uses heartbeats.
+    #
+    # The test code will export assertion data in its native format.
+    # Multiple display services choose to use the Scarpe-Component
+    # for Minitest data export, which is straightforward to import
+    # into the Shoes-Spec test harness.
+    #
+    # @param code [String] the ShoesSpec code to execute
+    # @param class_name [String|NilClass] the Minitest class name for reporting or nil
+    # @param test_name [String|NilClass] the Minitest test name for reporting or nil
+    # @return [void]
+    def run_shoes_spec_test_code(code, class_name: nil, test_name: nil)
+      raise "Child class should override this!"
+    end
+  end
+
+  # ShoesSpec instances support finder methods like button() that return
+  # a proxy to the corresponding drawable. Those proxies should support
+  # standard Shoes::Drawable methods, including the ones appropriate to
+  # the same drawable object. They should also support certain other
+  # testing-specific methods like "trigger_click" that are used to
+  # simulate display-side events during testing.
+  #
+  # Keep in mind that a proxy will often be in a different process from
+  # the Shoes app. So the proxy can't portably return the object or
+  # display object, though it could possibly return another proxy for such
+  # a thing.
+  class SpecProxy
+    # The proxy will have finder methods for all drawables, such as
+    # button(), edit_line(), etc. How to document those?
+
+    # Trigger a click on a button or button-like drawable. Not every
+    # drawable will support this operation.
+    def trigger_click()
+      raise "Child class should override this!"
+    end
+
+    # Trigger a hover over a hoverable drawable. Not every
+    # drawable will support this operation. A drawable that supports
+    # hover should support leave and vice-versa.
+    def trigger_hover()
+      raise "Child class should override this!"
+    end
+
+    # Trigger ending hover over a hoverable drawable. Not every
+    # drawable will support this operation. A drawable that supports
+    # hover should support leave and vice-versa.
+    def trigger_leave()
+      raise "Child class should override this!"
+    end
+
+    # Trigger a change in value for a drawable like a list_box
+    # with multiple values.
+    def trigger_change(value)
+      raise "Child class should override this!"
+    end
+  end
+end

data/lacci/lib/shoes.rb

@@ -0,0 +1,147 @@
+# 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
+
+class Shoes; end
+class Shoes::Error < StandardError; end
+require_relative "shoes/errors"
+
+require_relative "shoes/constants"
+require_relative "shoes/ruby_extensions"
+
+# 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/display_service"
+
+# Pre-declare classes that get referenced outside their own require file
+class Shoes::Drawable < Shoes::Linkable; end
+class Shoes::Slot < Shoes::Drawable; end
+class Shoes::Widget < Shoes::Slot; end
+
+require_relative "shoes/log"
+require_relative "shoes/colors"
+
+require_relative "shoes/builtins"
+
+require_relative "shoes/background"
+require_relative "shoes/border"
+require_relative "shoes/spacing"
+
+require_relative "shoes/drawable"
+require_relative "shoes/app"
+require_relative "shoes/drawables"
+
+require_relative "shoes/download"
+
+# No easy way to tell at this point whether
+# we will later load Shoes-Spec code, e.g.
+# by running a segmented app with test code.
+require_relative "shoes-spec"
+
+# The module containing Shoes in all its glory.
+# Shoes is a platform-independent GUI library, designed to create
+# small visual applications in Ruby.
+#
+class Shoes
+  class << self
+    # Creates a Shoes app with a new window. The block parameter is used to create
+    # drawables 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 relative_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
+      dir = File.dirname(path)
+
+      # Shoes assumes we're starting from the app code's path
+      Dir.chdir(dir)
+
+      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,63 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "shoes"
+
+require "scarpe/components/unit_test_helpers"
+
+require "minitest/autorun"
+
+require "minitest/reporters"
+Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
+
+# For testing Lacci, it's kind of silly to start a Webview application.
+# They're slow, unreliable and memory-hungry. So instead we start a
+# Niente do-nothing application for a simple API test. It's a lot like
+# mocking.
+class NienteTest < Minitest::Test
+  include ::Scarpe::Test::Helpers
+
+  SCARPE_EXE = File.expand_path("../../exe/scarpe", __dir__)
+
+  def run_test_niente_code(
+    scarpe_app_code,
+    test_extension: ".rb",
+    **opts
+  )
+    with_tempfile(["scarpe_test_app", test_extension], scarpe_app_code) do |test_app_location|
+      run_test_niente_app(test_app_location, **opts)
+    end
+  end
+
+  def run_test_niente_app(
+    test_app_location,
+    app_test_code: "",
+    timeout: 5.0,
+    class_name: self.class,
+    method_name: self.name,
+    display_service: "niente"
+  )
+    with_tempfiles([
+      #["scarpe_log_config.json", JSON.dump(log_config_for_test)],
+      [["shoes_spec_code", ".rb"], app_test_code],
+    ]) do |shoes_spec_path,_|
+      system(
+        "LOCALAPPDATA=\"#{Dir.tmpdir}\" " +
+        "SHOES_SPEC_TEST=\"#{shoes_spec_path}\" " +
+        "SCARPE_DISPLAY_SERVICE=\"#{display_service}\" " +
+        "SHOES_MINITEST_EXPORT_FILE=niente_test.json " +
+        "SHOES_MINITEST_CLASS_NAME=\"#{class_name}\" " +
+        "SHOES_MINITEST_METHOD_NAME=\"#{method_name}\" " +
+        "ruby #{SCARPE_EXE} --dev #{test_app_location}"
+      )
+    end
+
+    # Check if the process exited normally or crashed (segfault, failure, timeout)
+    unless $?.success?
+      assert(false, "Niente app failed with exit code: #{$?.exitstatus}")
+      return
+    end
+
+
+  end
+end

data/lacci/test/test_lacci.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestLacci < NienteTest
+  def test_simple_button_click
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+    Shoes.app do
+      @b = button "OK" do
+        @b.text = "Yup"
+      end
+    end
+    SHOES_APP
+    button().trigger_click
+    assert_equal "Yup", button().text
+    SHOES_SPEC
+  end
+end