scarpe 0.2.1 → 0.3.0

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

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+class Shoes
+  class App < Shoes::Drawable
+    include Shoes::Log
+
+    class << self
+      attr_accessor :instance
+    end
+
+    attr_reader :document_root
+
+    shoes_styles :title, :width, :height, :resizable
+
+    CUSTOM_EVENT_LOOP_TYPES = ["displaylib", "return", "wait"]
+
+    def initialize(
+      title: "Shoes!",
+      width: 480,
+      height: 420,
+      resizable: true,
+      &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 Shoes::Errors::TooManyInstancesError, "Cannot create multiple Shoes::App objects!"
+      else
+        Shoes::App.instance = self
+      end
+
+      @do_shutdown = false
+      @event_loop_type = "displaylib" # the default
+
+      super
+
+      # The draw context tracks current settings like fill and stroke,
+      # 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 drawable
+      @document_root = Shoes::DocumentRoot.new
+
+      @slots = []
+
+      # 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 != ""
+          @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
+
+      @app_code_body = app_code_body
+
+      # Try to de-dup as much as possible and not send repeat or multiple
+      # destroy events
+      @watch_for_destroy = bind_shoes_event(event_name: "destroy") do
+        Shoes::DisplayService.unsub_from_events(@watch_for_destroy) if @watch_for_destroy
+        @watch_for_destroy = nil
+        self.destroy(send_event: false)
+      end
+
+      @watch_for_event_loop = bind_shoes_event(event_name: "custom_event_loop") do |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
+
+      Signal.trap("INT") do
+        @log.warn("App interrupted by signal, stopping...")
+        puts "\nStopping Shoes app..."
+        destroy
+      end
+    end
+
+    def init
+      send_shoes_event(event_name: "init")
+      return if @do_shutdown
+
+      ::Shoes::App.instance.with_slot(@document_root, &@app_code_body)
+    end
+
+    # "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 drawables are found in that slot.
+    def push_slot(slot)
+      @slots.push(slot)
+    end
+
+    def pop_slot
+      return if @slots.size <= 1
+
+      @slots.pop
+    end
+
+    def current_slot
+      @slots[-1]
+    end
+
+    def with_slot(slot_item, &block)
+      return unless block_given?
+
+      push_slot(slot_item)
+      Shoes::App.instance.instance_eval(&block)
+    ensure
+      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
+
+    # This usually doesn't return. The display service may take control
+    # of the main thread. Local Webview even stops any background threads.
+    # However, some display libraries don't want to shut down and don't
+    # want to (and/or can't) take control of the event loop.
+    def run
+      if @do_shutdown
+        $stderr.puts "Destroy has already been signaled, but we just called Shoes::App.run!"
+        return
+      end
+
+      # The display lib can send us an event to customise the event loop handling.
+      # But it must do so before the "run" event returns.
+      send_shoes_event(event_name: "run")
+
+      case @event_loop_type
+      when "wait"
+        # Display lib wants us to busy-wait instead of it.
+        until @do_shutdown
+          Shoes::DisplayService.dispatch_event("heartbeat", nil)
+        end
+      when "displaylib"
+        # If run event returned, that means we're done.
+        destroy
+      when "return"
+        # 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 Shoes::Errors::InvalidAttributeValueError, "Internal error! Incorrect event loop type: #{@event_loop_type.inspect}!"
+      end
+    end
+
+    def destroy(send_event: true)
+      @do_shutdown = true
+      send_shoes_event(event_name: "destroy") if send_event
+    end
+
+    def all_drawables
+      out = []
+
+      to_add = @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
+      end
+
+      out
+    end
+
+    # We can add various ways to find drawables here.
+    # These are sort of like Shoes selectors, used for testing.
+    def find_drawables_by(*specs)
+      drawables = all_drawables
+      specs.each do |spec|
+        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]
+          when "$"
+            begin
+              # I'm not finding a global_variable_get or similar...
+              global_value = eval s
+              drawables &= [global_value]
+            rescue
+              raise Shoes::Errors::InvalidAttributeValueError, "Error getting global variable: #{spec.inspect}"
+            end
+          when "@"
+            if Shoes::App.instance.instance_variables.include?(spec.to_sym)
+              drawables &= [self.instance_variable_get(spec)]
+            else
+              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(Shoes::Errors::InvalidAttributeValueError, "Don't know how to find drawables by #{spec.inspect}!")
+        end
+      end
+      drawables
+    end
+  end
+end
+
+# 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
+
+  def border(...)
+    current_slot.border(...)
+  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"] = ""
+  end
+
+  # Shape DSL methods
+
+  def move_to(x, y)
+    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])
+    end
+  end
+
+  def line_to(x, y)
+    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
+end

data/{lib/scarpe → lacci/lib/shoes}/background.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-class Scarpe
+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/{lib/scarpe → lacci/lib/shoes}/border.rb

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