lacci 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aab735aab6fb64d87496b2ebefac1235a3858b1e14f176a2b165bf0c82c10260
-  data.tar.gz: 961b0b461164093bf51bf2ab7f79ae95e626a561548c7421bdcc75efe199e4e1
+  metadata.gz: 3bf9fa7d8c25eece259eb65e02ac680c3004762fa86951597ae1721010a8af52
+  data.tar.gz: b997f33fc1f63480f38144f89c54af16a3f99c7eafaf960b53770ea4894b51e6
 SHA512:
-  metadata.gz: 3e3bffa1f9f822b082ed7268458f0a93c49614a3b6169f4648fe57c126d77a4131d5113a15ca2a7421fe3271746ba36eb10faed83a326c4eb9514ec0447eaecf
-  data.tar.gz: 7f2c9d2e4672faea8f3f5613a9b4bdc4c78b65e9443a669c166a76d95cee2c305095eda4688418bc4b8a3d804e9ea2662fa09f0a906b61435a9aa3d019367cce
+  metadata.gz: 7eb784a865dfd9add9ade9861a62cfa2192e407d1371e49cdd23eb6205c55c36f67d6a31347775ee6b3d43c6e025ea1788e6c51dedf4251a562dcb62f2cda1e5
+  data.tar.gz: ea5b4aef895ee41ea78699bac827f8404ebbef97f0d7e8ed93b41382076c3188538e70aa32016b5ff90bd81b05feca8effc977f5452efe30744f25a7d3fe845f

data/Gemfile

@@ -4,6 +4,8 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "scarpe-components", path: "../scarpe-components"
+
 gem "rake", "~> 13.0"
 
 group :test do

data/Gemfile.lock

@@ -1,7 +1,13 @@
+PATH
+  remote: ../scarpe-components
+  specs:
+    scarpe-components (0.3.0)
+
 PATH
   remote: .
   specs:
-    lacci (0.2.1)
+    lacci (0.3.0)
+      scarpe-components
 
 GEM
   remote: https://rubygems.org/
@@ -66,6 +72,7 @@ DEPENDENCIES
   redcarpet
   rubocop (~> 1.21)
   rubocop-shopify
+  scarpe-components!
   yard
 
 BUNDLED WITH

data/lib/lacci/scarpe_cli.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Scarpe
+module Scarpe
   module CLI
     DEFAULT_USAGE = <<~'USAGE'
       Usage: scarpe_core [OPTIONS] <scarpe app file>           # Same as "scarpe run"
@@ -23,11 +23,11 @@ class Scarpe
     end
 
     def default_env_categories
+      require "shoes"
       {
         "Lacci" => [
           env_or_default("SCARPE_DISPLAY_SERVICE", "(none)"),
           env_or_default("SCARPE_LOG_CONFIG", "(default)#{Shoes::Log::DEFAULT_LOG_CONFIG.inspect}"),
-          env_or_default("SCARPE_APP_TEST", "(none)"),
         ],
         "Ruby and Shell" => [
           ["RUBY_DESCRIPTION", RUBY_DESCRIPTION],

data/lib/lacci/scarpe_core.rb

@@ -12,9 +12,10 @@ if RUBY_VERSION[0..2] < "3.2"
   exit(-1)
 end
 
-class Scarpe; end
+module Scarpe; end
 
 # The base error class for Scarpe errors, but not necessarily {Shoes::Error}s
+class Shoes::Error < StandardError; end
 class Scarpe::Error < StandardError; end
 
 require "lacci/version"

data/lib/lacci/version.rb

@@ -9,5 +9,5 @@
 # mostly invisible. Instead, look at the {Shoes} module
 # to see what's in Lacci.
 module Lacci
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/lib/scarpe/niente/app.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Niente
+  class App < Drawable
+    def initialize(properties)
+      super
+
+      bind_shoes_event(event_name: "init") { init }
+      bind_shoes_event(event_name: "run") { run }
+      bind_shoes_event(event_name: "destroy") { destroy }
+    end
+
+    def init
+    end
+
+    def run
+      send_shoes_event("wait", event_name: "custom_event_loop")
+    end
+
+    def destroy
+    end
+  end
+end

data/lib/scarpe/niente/display_service.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Niente
+  # This is a "null" DisplayService, doing as little as it
+  # can get away with.
+  class DisplayService < Shoes::DisplayService
+    include Shoes::Log
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def initialize
+      if Niente::DisplayService.instance
+        raise Shoes::SingletonError, "ERROR! This is meant to be a singleton!"
+      end
+
+      Niente::DisplayService.instance = self
+
+      log_init("Niente::DisplayService")
+      super()
+    end
+
+    # Create a fake display drawable for a specific Shoes drawable, and pair it with
+    # the linkable ID for this Shoes drawable.
+    #
+    # @param drawable_class_name [String] The class name of the Shoes drawable, e.g. Shoes::Button
+    # @param drawable_id [String] the linkable ID for drawable events
+    # @param properties [Hash] a JSON-serialisable Hash with the drawable's Shoes styles
+    # @param is_widget [Boolean] whether the class is a user-defined Shoes::Widget subclass
+    # @return [Webview::Drawable] the newly-created Webview drawable
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties, parent_id:, is_widget:)
+      existing = query_display_drawable_for(drawable_id, nil_ok: true)
+      if existing
+        @log.warn("There is already a display drawable for #{drawable_id.inspect}! Returning #{existing.class.name}.")
+        return existing
+      end
+
+      if drawable_class_name == "App"
+        @app = Niente::App.new(properties)
+        set_drawable_pairing(drawable_id, @app)
+
+        return @app
+      end
+
+      display_drawable = Niente::Drawable.new(properties)
+      display_drawable.shoes_type = drawable_class_name
+      set_drawable_pairing(drawable_id, display_drawable)
+
+      # Nil parent is okay for DocumentRoot and TextDrawables, so we have to specify it.
+      parent = DisplayService.instance.query_display_drawable_for(parent_id, nil_ok: true)
+      display_drawable.set_parent(parent)
+
+      return display_drawable
+    end
+
+    # Destroy the display service and the app. Quit the process (eventually.)
+    #
+    # @return [void]
+    def destroy
+      @app.destroy
+      DisplayService.instance = nil
+    end
+  end
+end
+

data/lib/scarpe/niente/drawable.rb

@@ -0,0 +1,59 @@
+module Niente
+  class Drawable < Shoes::Linkable
+    attr_reader :shoes_linkable_id
+    attr_reader :parent
+    attr_reader :children
+
+    attr_accessor :shoes_type
+
+    def initialize(props)
+      @shoes_linkable_id = props.delete("shoes_linkable_id") || props.delete(:shoes_linkable_id)
+      @data = props
+
+      super(linkable_id: @shoes_linkable_id)
+
+      # This should only be used for reparenting after a drawable was initially created.
+      bind_shoes_event(event_name: "parent", target: shoes_linkable_id) do |new_parent_id|
+        display_parent = DisplayService.instance.query_display_drawable_for(new_parent_id)
+        if @parent != display_parent
+          set_parent(display_parent)
+        end
+      end
+
+      # When Shoes drawables change properties, we get a change notification here
+      bind_shoes_event(event_name: "prop_change", target: shoes_linkable_id) do |prop_changes|
+        prop_changes.each do |k, v|
+          instance_variable_set("@" + k, v)
+        end
+        properties_changed(prop_changes) if respond_to?(:properties_changed)
+      end
+
+      bind_shoes_event(event_name: "destroy", target: shoes_linkable_id) do
+        set_parent(nil)
+      end
+    end
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+    end
+
+    # Do not call directly, use set_parent
+    def remove_child(child)
+      @children ||= []
+      unless @children.include?(child)
+        STDERR.puts("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
+  end
+end
+

data/lib/scarpe/niente/shoes_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "scarpe/components/string_helpers"
+
+module Niente; end
+
+class Niente::Test
+  def self.run_shoes_spec_test_code(code, class_name: nil, test_name: nil)
+    if @shoes_spec_init
+      raise Shoes::Errors::MultipleShoesSpecRunsError, "Scarpe-Webview can only run a single Shoes spec per process!"
+    end
+    @shoes_spec_init = true
+
+    require "scarpe/components/minitest_export_reporter"
+    Minitest::Reporters::ShoesExportReporter.activate!
+
+    class_name ||= ENV["SHOES_MINITEST_CLASS_NAME"] || "TestShoesSpecCode"
+    test_name ||= ENV["SHOES_MINITEST_METHOD_NAME"] || "test_shoes_spec"
+
+    Shoes::DisplayService.subscribe_to_event("heartbeat", nil) do
+      unless @hb_init
+        Minitest.run []
+        Shoes::App.instance.destroy
+      end
+      @hb_init = true
+    end
+
+    test_class = Class.new(Niente::ShoesSpecTest)
+    Object.const_set(Scarpe::Components::StringHelpers.camelize(class_name), test_class)
+    test_name = "test_" + test_name unless test_name.start_with?("test_")
+    test_class.define_method(test_name) do
+      eval(code)
+    end
+  end
+end
+
+class Niente::ShoesSpecTest < Minitest::Test
+  Shoes::Drawable.drawable_classes.each do |drawable_class|
+    finder_name = drawable_class.dsl_name
+
+    define_method(finder_name) do |*args|
+      app = Shoes::App.instance
+
+      drawables = app.find_drawables_by(drawable_class, *args)
+      raise Shoes::Errors::MultipleDrawablesFoundError, "Found more than one #{finder_name} matching #{args.inspect}!" if drawables.size > 1
+      raise Shoes::Errors::NoDrawablesFoundError, "Found no #{finder_name} matching #{args.inspect}!" if drawables.empty?
+
+      Niente::ShoesSpecProxy.new(drawables[0])
+    end
+  end
+
+  def drawable(*specs)
+    drawables = Shoes::App.instance.find_drawables_by(*specs)
+    raise Shoes::Errors::MultipleDrawablesFoundError, "Found more than one #{finder_name} matching #{args.inspect}!" if drawables.size > 1
+    raise Shoes::Errors::NoDrawablesFoundError, "Found no #{finder_name} matching #{args.inspect}!" if drawables.empty?
+    Niente::ShoesSpecProxy.new(drawables[0])
+  end
+end
+
+class Niente::ShoesSpecProxy
+  attr_reader :obj
+  attr_reader :linkable_id
+  attr_reader :display
+
+  def initialize(obj)
+    @obj = obj
+    @linkable_id = obj.linkable_id
+    @display = ::Shoes::DisplayService.display_service.query_display_drawable_for(obj.linkable_id)
+  end
+
+  def method_missing(method, ...)
+    if @obj.respond_to?(method)
+      self.singleton_class.define_method(method) do |*args, **kwargs, &block|
+        @obj.send(method, *args, **kwargs, &block)
+      end
+      send(method, ...)
+    else
+      super # raise an exception
+    end
+  end
+
+  JS_EVENTS = [:click, :hover, :leave]
+  JS_EVENTS.each do |event|
+    define_method("trigger_#{event}") do |*args, **kwargs|
+      ::Shoes::DisplayService.dispatch_event(event.to_s, @linkable_id, *args, **kwargs)
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @obj.respond_to_missing?(method_name, include_private)
+  end
+end

data/lib/scarpe/niente.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Niente -- Italian for "nothing" -- is a null display service
+# that doesn't display anything. It does very little, while
+# keeping a certain amount of "mental model" or schema of
+# how a real display service should act.
+module Niente; end
+
+require "scarpe/components/print_logger"
+Shoes::Log.instance = Scarpe::Components::PrintLogImpl.new
+if ENV["NIENTE_LOG_LEVEL"]
+  pl = Scarpe::Components::PrintLogImpl::PrintLogger
+  level = ENV["NIENTE_LOG_LEVEL"].strip.downcase.to_sym
+  unless pl::LEVELS.key?(level)
+    raise "Unrecognized Niente log level: #{level.inspect}!"
+  end
+  pl.min_level = pl::LEVELS[level]
+end
+
+require_relative "niente/drawable"
+require_relative "niente/app"
+require_relative "niente/display_service"
+
+require_relative "niente/shoes_spec"
+Shoes::Spec.instance = Niente::Test
+
+require "scarpe/components/segmented_file_loader"
+loader = Scarpe::Components::SegmentedFileLoader.new
+Shoes.add_file_loader loader
+
+Shoes::DisplayService.set_display_service_class(Niente::DisplayService)
+

data/lib/shoes/app.rb

@@ -1,61 +1,81 @@
 # frozen_string_literal: true
 
-module Shoes
-  class App < Shoes::Widget
+class Shoes
+  class App < Shoes::Drawable
     include Shoes::Log
 
     class << self
       attr_accessor :instance
     end
 
+    # The Shoes root of the drawable tree
     attr_reader :document_root
 
-    display_properties :title, :width, :height, :resizable
+    # The application directory for this app. Often this will be the directory
+    # containing the launched application file.
+    attr_reader :dir
+
+    shoes_styles :title, :width, :height, :resizable, :features
+
+    # This is defined to avoid the linkable-id check in the Shoes-style method_missing def'n
+    def features
+      @features
+    end
 
     CUSTOM_EVENT_LOOP_TYPES = ["displaylib", "return", "wait"]
 
+    init_args
     def initialize(
       title: "Shoes!",
       width: 480,
       height: 420,
       resizable: true,
+      features: [],
       &app_code_body
     )
       log_init("Shoes::App")
 
       if Shoes::App.instance
         @log.error("Trying to create a second Shoes::App in the same process! Fail!")
-        raise "Cannot create multiple Shoes::App objects!"
+        raise Shoes::Errors::TooManyInstancesError, "Cannot create multiple Shoes::App objects!"
       else
         Shoes::App.instance = self
       end
 
+      # We cd to the app's containing dir when running the app
+      @dir = Dir.pwd
+
       @do_shutdown = false
       @event_loop_type = "displaylib" # the default
 
-      super
+      @features = features
 
-      # The draw context tracks current settings like fill and stroke,
-      # plus potentially other current state that changes from widget
-      # to widget and slot to slot.
-      @draw_context = {
-        "fill" => "",
-        "stroke" => "",
-      }
+      unknown_ext = features - Shoes::FEATURES - Shoes::EXTENSIONS
+      unsupported_features = unknown_ext & Shoes::KNOWN_FEATURES
+      unless unsupported_features.empty?
+        @log.error("Shoes app requires feature(s) not supported by this display service: #{unsupported_features.inspect}!")
+        raise Shoes::Errors::UnsupportedFeatureError, "Shoes app needs features: #{unsupported_features.inspect}"
+      end
+      unless unknown_ext.empty?
+        @log.warn("Shoes app requested unknown features #{unknown_ext.inspect}! Known: #{(Shoes::FEATURES + Shoes::EXTENSIONS).inspect}")
+      end
 
-      # This creates the DocumentRoot, including its corresponding display widget
+      @slots = []
+
+      super
+
+      # This creates the DocumentRoot, including its corresponding display drawable
       @document_root = Shoes::DocumentRoot.new
 
-      @slots = []
+      # Now create the App display drawable
+      create_display_drawable
 
-      # Now create the App display widget
-      create_display_widget
+      # Set up testing *after* Display Service basic objects exist
 
-      # Set up testing events *after* Display Service basic objects exist
-      if ENV["SCARPE_APP_TEST"]
-        test_code = File.read ENV["SCARPE_APP_TEST"]
-        if test_code != ""
-          self.instance_eval test_code
+      if ENV["SHOES_SPEC_TEST"]
+        test_code = File.read ENV["SHOES_SPEC_TEST"]
+        unless test_code.empty?
+          Shoes::Spec.instance.run_shoes_spec_test_code test_code
         end
       end
 
@@ -70,7 +90,7 @@ module Shoes
       end
 
       @watch_for_event_loop = bind_shoes_event(event_name: "custom_event_loop") do |loop_type|
-        raise("Unknown event loop type: #{loop_type.inspect}!") unless CUSTOM_EVENT_LOOP_TYPES.include?(loop_type)
+        raise(Shoes::Errors::InvalidAttributeValueError, "Unknown event loop type: #{loop_type.inspect}!") unless CUSTOM_EVENT_LOOP_TYPES.include?(loop_type)
 
         @event_loop_type = loop_type
       end
@@ -89,9 +109,9 @@ module Shoes
       ::Shoes::App.instance.with_slot(@document_root, &@app_code_body)
     end
 
-    # "Container" widgets like flows, stacks, masks and the document root
+    # "Container" drawables like flows, stacks, masks and the document root
     # are considered "slots" in Shoes parlance. When a new slot is created,
-    # we push it here in order to track what widgets are found in that slot.
+    # we push it here in order to track what drawables are found in that slot.
     def push_slot(slot)
       @slots.push(slot)
     end
@@ -115,8 +135,26 @@ module Shoes
       pop_slot
     end
 
+    # We use method_missing for drawable-creating methods like "button".
+    # The parent's method_missing will auto-create Shoes style getters and setters.
+    # This is similar to the method_missing in Shoes::Slot, but different in
+    # where the new drawable appears.
+    def method_missing(name, *args, **kwargs, &block)
+      klass = ::Shoes::Drawable.drawable_class_by_name(name)
+      return super unless klass
+
+      ::Shoes::App.define_method(name) do |*args, **kwargs, &block|
+        klass.new(*args, **kwargs, &block)
+      end
+
+      send(name, *args, **kwargs, &block)
+    end
+
+    # Get the current draw context for the current slot
+    #
+    # @return [Hash] a hash of Shoes styles for the current draw context
     def current_draw_context
-      @draw_context.dup
+      current_slot&.current_draw_context
     end
 
     # This usually doesn't return. The display service may take control
@@ -136,7 +174,9 @@ module Shoes
       case @event_loop_type
       when "wait"
         # Display lib wants us to busy-wait instead of it.
-        sleep 0.1 until @do_shutdown
+        until @do_shutdown
+          Shoes::DisplayService.dispatch_event("heartbeat", nil)
+        end
       when "displaylib"
         # If run event returned, that means we're done.
         destroy
@@ -144,7 +184,7 @@ module Shoes
         # We can just return to the main event loop. But we shouldn't call destroy.
         # Presumably some event loop *outside* our event loop is handling things.
       else
-        raise "Internal error! Incorrect event loop type: #{@event_loop_type.inspect}!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Internal error! Incorrect event loop type: #{@event_loop_type.inspect}!"
       end
     end
 
@@ -153,10 +193,10 @@ module Shoes
       send_shoes_event(event_name: "destroy") if send_event
     end
 
-    def all_widgets
+    def all_drawables
       out = []
 
-      to_add = @document_root.children
+      to_add = [@document_root, @document_root.children]
       until to_add.empty?
         out.concat(to_add)
         to_add = to_add.flat_map { |w| w.respond_to?(:children) ? w.children : [] }.compact
@@ -165,13 +205,15 @@ module Shoes
       out
     end
 
-    # We can add various ways to find widgets here.
+    # We can add various ways to find drawables here.
     # These are sort of like Shoes selectors, used for testing.
-    def find_widgets_by(*specs)
-      widgets = all_widgets
+    def find_drawables_by(*specs)
+      drawables = all_drawables
       specs.each do |spec|
-        if spec.is_a?(Class)
-          widgets.select! { |w| spec === w }
+        if spec == Shoes::App
+          drawables = [Shoes::App.instance]
+        elsif spec.is_a?(Class)
+          drawables.select! { |w| spec === w }
         elsif spec.is_a?(Symbol) || spec.is_a?(String)
           s = spec.to_s
           case s[0]
@@ -179,71 +221,68 @@ module Shoes
             begin
               # I'm not finding a global_variable_get or similar...
               global_value = eval s
-              widgets &= [global_value]
+              drawables &= [global_value]
             rescue
-              raise "Error getting global variable: #{spec.inspect}"
+              raise Shoes::Errors::InvalidAttributeValueError, "Error getting global variable: #{spec.inspect}"
             end
           when "@"
             if Shoes::App.instance.instance_variables.include?(spec.to_sym)
-              widgets &= [self.instance_variable_get(spec)]
+              drawables &= [self.instance_variable_get(spec)]
             else
-              raise "Can't find top-level instance variable: #{spec.inspect}!"
+              raise Shoes::Errors::InvalidAttributeValueError, "Can't find top-level instance variable: #{spec.inspect}!"
             end
           else
+            if s.start_with?("id:")
+              find_id = Integer(s[3..-1])
+              drawable = Shoes::Drawable.drawable_by_id(find_id)
+              drawables &= [drawable]
+            else
+              raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to find drawables by #{spec.inspect}!"
+            end
           end
         else
-          raise("Don't know how to find widgets by #{spec.inspect}!")
+          raise(Shoes::Errors::InvalidAttributeValueError, "Don't know how to find drawables by #{spec.inspect}!")
         end
       end
-      widgets
+      drawables
     end
   end
 end
 
-# DSL methods
-class Shoes::App
+# Event handler DSLs get defined in both App and Slot - same code, slightly different results
+events = [:motion, :hover, :leave, :click, :release, :keypress, :animate, :every, :timer]
+events.each do |event|
+  Shoes::App.define_method(event) do |*args, &block|
+    subscription_item(args:, shoes_api_name: event.to_s, &block)
+  end
+  Shoes::Slot.define_method(event) do |*args, &block|
+    subscription_item(args:, shoes_api_name: event.to_s, &block)
+  end
+end
+
+# These methods will need to be defined on Slots too, but probably need a rework in general.
+class Shoes::App < Shoes::Drawable
+  # This is going to go away. See issue #496
   def background(...)
     current_slot.background(...)
   end
 
+  # This is going to go away. See issue #498
   def border(...)
     current_slot.border(...)
   end
 
-  def motion(&block)
-    subscription_item(shoes_api_name: "motion", &block)
-  end
-
-  def hover(&block)
-    subscription_item(shoes_api_name: "hover", &block)
-  end
-
-  def click(&block)
-    subscription_item(shoes_api_name: "click", &block)
-  end
-
-  # Draw context methods
-
-  def fill(color)
-    @draw_context["fill"] = color
-  end
-
-  def nofill
-    @draw_context["fill"] = ""
-  end
-
-  def stroke(color)
-    @draw_context["stroke"] = color
-  end
-
-  def nostroke
-    @draw_context["stroke"] = ""
+  # Draw Context methods -- forward to the current slot
+  [:fill, :nofill, :stroke, :strokewidth, :nostroke, :rotate].each do |dc_method|
+    define_method(dc_method) do |*args|
+      current_slot.send(dc_method, *args)
+    end
   end
 
   # Shape DSL methods
 
   def move_to(x, y)
-    raise("Pass only Numeric arguments to move_to!") unless x.is_a?(Numeric) && y.is_a?(Numeric)
+    raise(Shoes::Errors::InvalidAttributeValueError, "Pass only Numeric arguments to move_to!") unless x.is_a?(Numeric) && y.is_a?(Numeric)
 
     if current_slot.is_a?(::Shoes::Shape)
       current_slot.add_shape_command(["move_to", x, y])
@@ -251,7 +290,7 @@ class Shoes::App
   end
 
   def line_to(x, y)
-    raise("Pass only Numeric arguments to line_to!") unless x.is_a?(Numeric) && y.is_a?(Numeric)
+    raise(Shoes::Errors::InvalidAttributeValueError, "Pass only Numeric arguments to line_to!") unless x.is_a?(Numeric) && y.is_a?(Numeric)
 
     if current_slot.is_a?(::Shoes::Shape)
       current_slot.add_shape_command(["line_to", x, y])