scarpe 0.2.2 → 0.4.0

data/lacci/lacci.gemspec

@@ -23,14 +23,14 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features|tasks)/|\.(?:git|travis|circleci)|appveyor)})
     end
   end
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  #spec.add_dependency ""
+  spec.add_dependency "scarpe-components", "~>0.4.0"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lacci/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/lacci/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/lacci/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/lacci/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/lacci/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/lacci/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/lacci/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/lacci/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/lacci/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])

data/lacci/lib/shoes/background.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module Shoes
+class Shoes
   module Background
     def self.included(includer)
-      includer.display_property(:background_color)
+      includer.shoes_style(:background_color)
     end
 
     # NOTE: this needs to be passed through in order for the styling to work

data/lacci/lib/shoes/border.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module Shoes
+class Shoes
   module Border
     def self.included(includer)
-      includer.display_properties :border_color, :options
+      includer.shoes_styles :border_color, :options
     end
 
     # Considering a signature like this: