scarpe 0.2.2 → 0.3.0

data/lacci/lacci.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  #spec.add_dependency ""
+  spec.add_dependency "scarpe-components" # Scarpe-Components has no dependencies, and includes useful infrastructure
 
   # 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,6 +23,7 @@ class Scarpe
     end
 
     def default_env_categories
+      require "shoes"
       {
         "Lacci" => [
           env_or_default("SCARPE_DISPLAY_SERVICE", "(none)"),

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.3.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,62 @@
+# 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, 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)
+
+      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,57 @@
+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)
+
+      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
+      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/logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "shoes/log"
+require "json"
+
+module Niente; end
+class Niente::LogImpl
+  include Shoes::Log # for constants
+
+  class PrintLogger
+    def initialize(_)
+    end
+
+    [:error, :warn, :debug, :info].each do |level|
+      define_method(level) do |msg|
+        puts "#{level}: #{msg}"
+      end
+    end
+  end
+
+  def logger_for_component(component)
+    PrintLogger.new(component.to_s)
+  end
+
+  def configure_logger(log_config)
+  end
+end
+
+#Shoes::Log.instance = Niente::LogImpl.new

data/lacci/lib/scarpe/niente/shoes_spec.rb

@@ -0,0 +1,87 @@
+# 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
+      STDERR.puts "Started running #{class_name.inspect}::#{test_name.inspect}"
+      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
+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,20 @@
+# 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_relative "niente/logger"
+Shoes::Log.instance = Niente::LogImpl.new
+
+require_relative "niente/drawable"
+require_relative "niente/app"
+require_relative "niente/display_service"
+
+require_relative "niente/shoes_spec"
+Shoes::Spec.instance = Niente::Test
+
+Shoes::DisplayService.set_display_service_class(Niente::DisplayService)
+

data/lacci/lib/shoes/app.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Shoes
-  class App < Shoes::Widget
+class Shoes
+  class App < Shoes::Drawable
     include Shoes::Log
 
     class << self
@@ -10,7 +10,7 @@ module Shoes
 
     attr_reader :document_root
 
-    display_properties :title, :width, :height, :resizable
+    shoes_styles :title, :width, :height, :resizable
 
     CUSTOM_EVENT_LOOP_TYPES = ["displaylib", "return", "wait"]
 
@@ -25,7 +25,7 @@ module Shoes
 
       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
@@ -36,26 +36,35 @@ module Shoes
       super
 
       # 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.
+      # plus potentially other current state that changes from drawable
+      # to drawable and slot to slot.
       @draw_context = {
         "fill" => "",
         "stroke" => "",
+        "rotate" => 0,
       }
 
-      # This creates the DocumentRoot, including its corresponding display widget
+      # This creates the DocumentRoot, including its corresponding display drawable
       @document_root = Shoes::DocumentRoot.new
 
       @slots = []
 
-      # Now create the App display widget
-      create_display_widget
+      # Now create the App display drawable
+      create_display_drawable
 
       # 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
+          @test_obj = Object.new
+          @test_obj.instance_eval test_code
+        end
+      end
+
+      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 +79,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 +98,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,6 +124,29 @@ 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|
+        # Look up the Shoes drawable and create it...
+        drawable_instance = klass.new(*args, **kwargs, &block)
+
+        unless klass.ancestors.include?(::Shoes::TextDrawable)
+          # Create this drawable in the current app slot
+          drawable_instance.set_parent ::Shoes::App.instance.current_slot
+        end
+
+        drawable_instance
+      end
+
+      send(name, *args, **kwargs, &block)
+    end
+
     def current_draw_context
       @draw_context.dup
     end
@@ -136,7 +168,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 +178,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,7 +187,7 @@ module Shoes
       send_shoes_event(event_name: "destroy") if send_event
     end
 
-    def all_widgets
+    def all_drawables
       out = []
 
       to_add = @document_root.children
@@ -165,13 +199,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,29 +215,47 @@ 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
   def background(...)
     current_slot.background(...)
   end
@@ -210,18 +264,6 @@ class Shoes::App
     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)
@@ -243,7 +285,7 @@ class Shoes::App
   # 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,13 +293,16 @@ 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])
     end
   end
 
+  def rotate(angle)
+    @draw_context["rotate"] = angle
+  end
   # Not implemented yet: curve_to, arc_to
 
   alias_method :info, :puts

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:

data/lacci/lib/shoes/builtins.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Shoes has a number of built-in methods that are intended to be available everywhere,
+# in every Shoes and non-Shoes class, for every Shoes app.
+module Shoes::Builtins
+  # Register the given font with Shoes so that text that wants it can use it.
+  # Also add it to the FONTS constant.
+  #
+  # @param font_file_or_url [String] the filename or URL for the font
+  # @return [void]
+  def font(font_file_or_url)
+    shoes_builtin("font", font_file_or_url)
+
+    font_name = File.basename(font_file_or_url, ".*")
+    Shoes::FONTS << font_name
+  end
+
+  def ask(message_string)
+    shoes_builtin("ask", message_string)
+  end
+
+  def alert(message)
+    shoes_builtin("alert", message)
+  end
+
+  def ask_color(title_bar)
+    shoes_builtin("ask_color", title_bar)
+  end
+
+  def ask_open_file()
+    shoes_builtin("ask_open_file")
+  end
+
+  def ask_save_file()
+    shoes_builtin("ask_save_file")
+  end
+
+  def ask_open_folder()
+    shoes_builtin("ask_open_folder")
+  end
+
+  def ask_save_folder()
+    shoes_builtin("ask_save_folder")
+  end
+
+  def confirm(question)
+    shoes_builtin("confirm", question)
+  end
+
+  # TO ADD: debug, error, info, warn
+  # TO VERIFY OR ADD: gradient, gray, rgb
+
+  private
+
+  def shoes_builtin(cmd_name, *args)
+    Shoes::DisplayService.dispatch_event("builtin", nil, cmd_name, args)
+    nil
+  end
+end
+
+module Kernel
+  include Shoes::Builtins
+end