lacci 0.2.1

data/lib/scarpe/span.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Span < Shoes::Widget
+    display_properties :text, :stroke, :size, :font, :html_attributes
+
+    def initialize(text, stroke: nil, size: :span, font: nil, **html_attributes)
+      @text = text
+      @stroke = stroke
+      @size = size
+      @font = font
+      @html_attributes = html_attributes
+
+      super
+
+      create_display_widget
+    end
+
+    def replace(text)
+      @text = text
+
+      # This should signal the display widget to change
+      self.text = @text
+    end
+  end
+end

data/lib/scarpe/stack.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Stack < Shoes::Slot
+    # TODO: sort out various margin and padding properties, including putting stuff into spacing
+    display_properties :width, :height, :scroll
+
+    def initialize(width: nil, height: nil, margin: nil, padding: nil, scroll: false, margin_top: nil, margin_bottom: nil, margin_left: nil,
+      margin_right: nil, **options, &block)
+
+      @options = options
+
+      super
+
+      create_display_widget
+      # Create the display-side widget *before* running the block, which will add child widgets with their display widgets
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+  end
+end

data/lib/scarpe/star.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "wv/shape_helper"
+class Scarpe
+  class InvalidAttributeValueError < Scarpe::Error; end
+
+  class Star < Shoes::Widget
+    include ShapeHelper
+    display_properties :left, :top, :points, :outer, :inner, :color
+
+    def initialize(left, top, points = 10, outer = 100, inner = 50)
+      @points = convert_to_integer(points, "points", 10)
+      @outer = convert_to_float(outer, "outer", 100.0)
+      @inner = convert_to_float(inner, "inner", 50.0)
+      @color = color_for_fill
+
+      super()
+      create_display_widget
+    end
+
+    private
+
+    def convert_to_integer(value, attribute_name, default = 0)
+      begin
+        value = Integer(value)
+        raise InvalidAttributeValueError, "Negative num '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise InvalidAttributeValueError, error_message
+      end
+    end
+
+    def convert_to_float(value, attribute_name, default = 0.0)
+      begin
+        value = Float(value)
+        raise InvalidAttributeValueError, "Negative num '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise InvalidAttributeValueError, error_message
+      end
+    end
+  end
+end

data/lib/scarpe/subscription_item.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Certain Shoes calls like motion and keydown are basically an
+# event subscription, with no other visible presence. However,
+# they have a place in the widget tree and can be deleted.
+#
+# Depending on the display library they may not have any
+# direct visual (or similar) presence there either.
+#
+# Inheriting from Widget gives these a parent slot and a
+# linkable_id automatically.
+class SubscriptionItem < Shoes::Widget
+  display_property :shoes_api_name
+
+  def initialize(shoes_api_name:, &block)
+    super
+
+    @callback = block
+
+    case shoes_api_name
+    when "hover"
+      # Hover passes the Shoes widget as the block param
+      @unsub_id = bind_self_event("hover") do
+        @callback&.call(self)
+      end
+    when "motion"
+      # Shoes sends back x, y, mods as the args.
+      # Shoes3 uses the strings "control" "shift" and
+      # "control_shift" as the mods arg.
+      @unsub_id = bind_self_event("motion") do |x, y, ctrl_key, shift_key, **_kwargs|
+        mods = [ctrl_key ? "control" : nil, shift_key ? "shift" : nil].compact.join("_")
+        @callback&.call(x, y, mods)
+      end
+    when "click"
+      # Click has block params button, left, top
+      # button is the button number, left and top are coords
+      @unsub_id = bind_self_event("click") do |button, x, y, **_kwargs|
+        @callback&.call(button, x, y)
+      end
+    else
+      raise "Unknown Shoes API call #{shoes_api_name.inspect} passed to SubscriptionItem!"
+    end
+
+    @unsub_id = bind_self_event(shoes_api_name) do |*args|
+      @callback&.call(*args)
+    end
+
+    # This won't create a visible display widget, but will turn into
+    # an invisible widget and a stream of events.
+    create_display_widget
+  end
+
+  def destroy
+    # TODO: we need a better way to do this automatically. See https://github.com/scarpe-team/scarpe/issues/291
+    unsub_shoes_event(@unsub_id) if @unsub_id
+    @unsub_id = nil
+
+    super
+  end
+end

data/lib/scarpe/unit_test_helpers.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "json"
+require "fileutils"
+
+module Scarpe::Test; end
+
+# We want test failures set up once *total*, not per Minitest::Test. So an instance var
+# doesn't do it.
+ALREADY_SET_UP_LOGGED_TEST_FAILURES = { setup: false }
+
+# General helpers for general usage
+# Helpers here should *not* use Webview-specific functionality.
+# The intention is that these are helpers for various Scarpe display
+# services that do *not* use Webview.
+module Scarpe::Test::Helpers
+  def with_tempfile(prefix, contents, dir: Dir.tmpdir)
+    t = Tempfile.new(prefix, dir)
+    t.write(contents)
+    t.flush # Make sure the contents are written out
+
+    yield(t.path)
+  ensure
+    t.close
+    t.unlink
+  end
+
+  # Pass an array of arrays, where each array is of the form:
+  # [prefix, contents, (optional)dir]
+  #
+  # I don't love inlining with_tempfile's contents into here.
+  # But calling it iteratively or recursively was difficult
+  # when I tried it the obvious ways.
+  def with_tempfiles(tf_specs, &block)
+    tempfiles = []
+    tf_specs.each do |prefix, contents, dir|
+      dir ||= Dir.tmpdir
+      t = Tempfile.new(prefix, dir)
+      tempfiles << t
+      t.write(contents)
+      t.flush # Make sure the contents are written out
+    end
+
+    args = tempfiles.map(&:path)
+    yield(args)
+  ensure
+    tempfiles.each do |t|
+      t.close
+      t.unlink
+    end
+  end
+
+  # Temporarily set env vars for the block of code inside
+  def with_env_vars(envs)
+    old_env = {}
+    envs.each do |k, v|
+      old_env[k] = ENV[k]
+      ENV[k] = v
+    end
+    yield
+  ensure
+    old_env.each { |k, v| ENV[k] = v }
+  end
+
+  def assert_include(text, subtext, msg = nil)
+    msg ||= "Expected #{text.inspect} to include #{subtext.inspect}"
+    assert text.include?(subtext), msg
+  end
+
+  def assert_not_include(text, subtext, msg = nil)
+    msg ||= "Expected #{text.inspect} not to include #{subtext.inspect}"
+    assert !text.include?(subtext), msg
+  end
+
+  def assert_html(actual_html, expected_tag, **opts, &block)
+    expected_html = Scarpe::HTML.render do |h|
+      h.public_send(expected_tag, opts, &block)
+    end
+
+    assert_equal expected_html, actual_html
+  end
+
+  # This does a final return of results. If it gets called
+  # multiple times, the test fails because that's not okay.
+  def return_results(result_bool, msg, data = {})
+    result_file = ENV["SCARPE_TEST_RESULTS"] || "./scarpe_results.txt"
+
+    result_structs = [result_bool, msg, data.merge(test_metadata)]
+    if File.exist?(result_file)
+      results_returned = JSON.parse File.read(result_file)
+    end
+
+    # Multiple different sets of results is bad, even if both are passing.
+    if results_returned && results_returned[0..1] != result_structs[0..1]
+      # Just raising here doesn't reliably fail the test.
+      # See: https://github.com/scarpe-team/scarpe/issues/212
+      Scarpe::Logger.logger("Test Results").error("Writing multi-result failure file to #{result_file.inspect}!")
+
+      new_res_data = { first_result: results_returned, second_result: result_structs }.merge(test_metadata)
+      bad_result = [false, "Returned two sets of results!", new_res_data]
+      File.write(result_file, JSON.pretty_generate(bad_result))
+
+      return
+    elsif results_returned
+      Scarpe::Logger.logger("Test Results").warn "Returning identical results twice: #{results_returned.inspect}"
+    end
+
+    Scarpe::Logger.logger("Test Results").debug("Writing results file #{result_file.inspect} to disk!")
+    File.write(result_file, JSON.pretty_generate(result_structs))
+  end
+end
+
+# This test will save extensive logs in case of test failure.
+# Note that it defines setup/teardown methods. If you want
+# multiple setup/teardowns from multiple places to happen you
+# may need to explictly call (e.g. with logged_test_setup/teardown)
+# to ensure everything you want happens.
+module Scarpe::Test::LoggedTest
+  LOGGER_DIR = File.expand_path("#{__dir__}/../../logger")
+
+  def file_id
+    "#{self.class.name}_#{self.name}"
+  end
+
+  def logged_test_setup
+    # Make sure test failures will be saved at the end of the run.
+    # Delete stale test failures and logging only the *first* time this is called.
+    set_up_test_failures
+
+    @normal_log_config = Scarpe::Logger.current_log_config
+    Scarpe::Logger.configure_logger(log_config_for_test)
+
+    Scarpe::Logger.logger("LoggedScarpeTest").info("Test: #{self.class.name}##{self.name}")
+  end
+
+  # If you include this module and don't override setup/teardown, everything will
+  # work fine. But if you need more setup/teardown steps, you can do that too.
+  def setup
+    logged_test_setup
+  end
+
+  def logged_test_teardown
+    # Restore previous log config
+    Scarpe::Logger.configure_logger(@normal_log_config)
+
+    if self.failure
+      save_failure_logs
+    else
+      remove_unsaved_logs
+    end
+  end
+
+  def teardown
+    logged_test_teardown
+  end
+
+  def log_config_for_test
+    {
+      "default" => ["debug", "logger/test_failure_#{file_id}.log"],
+
+      "WebviewAPI" => ["debug", "logger/test_failure_wv_api_#{file_id}.log"],
+
+      "CatsCradle" => ["debug", "logger/test_failure_catscradle_#{file_id}.log"],
+
+      "DisplayService" => ["debug", "logger/test_failure_events_#{file_id}.log"],
+      "WV::RelayDisplayService" => ["debug", "logger/test_failure_events_#{file_id}.log"],
+      "WV::WebviewDisplayService" => ["debug", "logger/test_failure_events_#{file_id}.log"],
+      "WV::ControlInterface" => ["debug", "logger/test_failure_events_#{file_id}.log"],
+    }
+  end
+
+  # This could be a lot simpler except I want to only update the file list in one place,
+  # log_config_for_test(). Having a single spot should (I hope) make it a lot friendlier to
+  # add more logfiles for different components, logged API objects, etc.
+  def saved_log_files
+    lc = log_config_for_test
+    log_outfiles = lc.values.map { |_level, loc| loc }
+    log_outfiles.select { |s| s.start_with?("logger/") }.map { |s| s.delete_prefix("logger/") }
+  end
+
+  def set_up_test_failures
+    return if ALREADY_SET_UP_LOGGED_TEST_FAILURES[:setup]
+
+    ALREADY_SET_UP_LOGGED_TEST_FAILURES[:setup] = true
+    # Delete stale test failures, if any, before starting the first failure-logged test
+    Dir["#{LOGGER_DIR}/test_failure*.log"].each { |fn| File.unlink(fn) }
+
+    Minitest.after_run do
+      # Print test failure notice to console
+      unless Dir["#{LOGGER_DIR}/test_failure*.out.log"].empty?
+        puts "Some tests have failed! See #{LOGGER_DIR}/test_failure*.out.log for test logs!"
+      end
+
+      # Remove un-saved test logs
+      Dir["#{LOGGER_DIR}/test_failure*.log"].each do |f|
+        next if f.include?(".out.log")
+
+        File.unlink(f) if File.exist?(f)
+      end
+    end
+  end
+
+  def logfail_out_loc(filepath)
+    # Add a .out prefix before final .log
+    out_loc = filepath.gsub(%r{.log\Z}, ".out.log")
+
+    if out_loc == filepath
+      raise "Something is wrong! Could not figure out failure-log output path for #{filepath.inspect}!"
+    end
+
+    if File.exist?(out_loc)
+      raise "Duplicate test file #{out_loc.inspect}? This file should *not* already exist!"
+    end
+
+    out_loc
+  end
+
+  def save_failure_logs
+    saved_log_files.each do |log_file|
+      full_loc = File.expand_path("#{LOGGER_DIR}/#{log_file}")
+      # TODO: we'd like to skip 0-length logfiles. But also Logging doesn't flush. For now, ignore.
+      next unless File.exist?(full_loc)
+
+      FileUtils.mv full_loc, logfail_out_loc(full_loc)
+    end
+  end
+
+  def remove_unsaved_logs
+    Dir["#{LOGGER_DIR}/test_failure*.log"].each do |f|
+      next if f.include?(".out.log") # Don't delete saved logs
+
+      File.unlink(f)
+    end
+  end
+end

data/lib/scarpe/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Scarpe
+  VERSION = "0.2.1"
+end

data/lib/scarpe/video.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Video < Shoes::Widget
+    display_properties :url
+
+    def initialize(url)
+      @url = url
+      super
+      create_display_widget
+    end
+
+    # other methods
+  end
+end

data/lib/scarpe/widgets.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "colors"
+require "shoes/widget"
+require "shoes/app"
+
+require_relative "spacing"
+require_relative "background"
+require_relative "border"
+require_relative "star"
+
+require_relative "fill"
+require_relative "font"
+
+require_relative "slot"
+require_relative "para"
+require_relative "stack"
+require_relative "flow"
+require_relative "document_root"
+require_relative "download"
+require_relative "subscription_item"
+require_relative "button"
+require_relative "image"
+require_relative "edit_box"
+require_relative "edit_line"
+require_relative "list_box"
+require_relative "alert"
+require_relative "span"
+require_relative "shape"
+require_relative "arc"
+
+require "shoes/text_widget"
+require_relative "link"
+require_relative "line"
+require_relative "video"

data/lib/scarpe/wv/alert.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewAlert < WebviewWidget
+    def initialize(properties)
+      super
+
+      bind("click") do
+        send_self_event(event_name: "click")
+      end
+    end
+
+    def element
+      onclick = handler_js_code("click")
+
+      HTML.render do |h|
+        h.div(id: html_id, style: overlay_style) do
+          h.div(style: modal_style) do
+            h.div(style: text_style) { @text }
+            h.button(style: button_style, onclick: onclick) { "OK" }
+          end
+        end
+      end
+    end
+
+    private
+
+    def overlay_style
+      {
+        position: "fixed",
+        top: "0",
+        left: "0",
+        width: "100%",
+        height: "100%",
+        overflow: "auto",
+        "z-index": "1",
+        background: "rgba(0,0,0,0.4)",
+        display: "flex",
+        "align-items": "center",
+        "justify-content": "center",
+      }
+    end
+
+    def modal_style
+      {
+        "min-width": "200px",
+        "min-height": "50px",
+        padding: "10px",
+        display: "flex",
+        background: "#fefefe",
+        "flex-direction": "column",
+        "justify-content": "space-between",
+        "border-radius": "9px",
+      }
+    end
+
+    def text_style
+      {}
+    end
+
+    def button_style
+      {}
+    end
+  end
+end

data/lib/scarpe/wv/app.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+class Scarpe
+  # Scarpe::WebviewApp must only be used from the main thread, due to GTK+ limitations.
+  class WebviewApp < WebviewWidget
+    attr_reader :debug
+    attr_reader :control_interface
+
+    attr_writer :shoes_linkable_id
+
+    def initialize(properties)
+      super
+
+      # It's possible to provide a Ruby script by setting
+      # SCARPE_TEST_CONTROL to its file path. This can
+      # allow pre-setting test options or otherwise
+      # performing additional actions not written into
+      # the Shoes app itself.
+      #
+      # The control interface is what lets these files see
+      # events, specify overrides and so on.
+      @control_interface = ControlInterface.new
+      if ENV["SCARPE_TEST_CONTROL"]
+        require "scarpe/unit_test_helpers"
+        @control_interface.instance_eval File.read(ENV["SCARPE_TEST_CONTROL"])
+      end
+
+      # TODO: rename @view
+      @view = Scarpe::WebWrangler.new title: @title,
+        width: @width,
+        height: @height,
+        resizable: @resizable,
+        debug: @debug
+
+      @callbacks = {}
+
+      # The control interface has to exist to get callbacks like "override Scarpe app opts".
+      # But the Scarpe App needs those options to be created. So we can't pass these to
+      # ControlInterface.new.
+      @control_interface.set_system_components app: self, doc_root: nil, wrangler: @view
+
+      bind_shoes_event(event_name: "init") { init }
+      bind_shoes_event(event_name: "run") { run }
+      bind_shoes_event(event_name: "destroy") { destroy }
+    end
+
+    attr_writer :document_root
+
+    def init
+      scarpe_app = self
+
+      @view.init_code("scarpeInit") do
+        request_redraw!
+      end
+
+      @view.bind("scarpeHandler") do |*args|
+        handle_callback(*args)
+      end
+
+      @view.bind("scarpeExit") do
+        scarpe_app.destroy
+      end
+    end
+
+    def run
+      @control_interface.dispatch_event(:init)
+
+      # This takes control of the main thread and never returns. And it *must* be run from
+      # the main thread. And it stops any Ruby background threads.
+      # That's totally cool and normal, right?
+      @view.run
+    end
+
+    def destroy
+      if @document_root || @view
+        @control_interface.dispatch_event :shutdown
+      end
+      @document_root = nil
+      if @view
+        @view.destroy
+        @view = nil
+      end
+    end
+
+    # All JS callbacks to Scarpe widgets are dispatched
+    # via this handler
+    def handle_callback(name, *args)
+      @callbacks[name].call(*args)
+    end
+
+    # Bind a Scarpe callback name; see handle_callback above.
+    # See Scarpe::Widget for how the naming is set up
+    def bind(name, &block)
+      @callbacks[name] = block
+    end
+
+    def request_redraw!
+      wrangler = WebviewDisplayService.instance.wrangler
+      if wrangler.is_running
+        wrangler.replace(@document_root.to_html)
+      end
+    end
+  end
+end

data/lib/scarpe/wv/arc.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "shape_helper"
+
+class Scarpe
+  class WebviewArc < Scarpe::WebviewWidget
+    include ShapeHelper
+    def initialize(properties)
+      super(properties)
+    end
+
+    def element(&block)
+      HTML.render do |h|
+        h.div(id: html_id, style: style) do
+          h.svg(width: @width, height: @height) do
+            h.path(d: arc_path)
+          end
+          block.call(h) if block_given?
+        end
+      end
+    end
+
+    private
+
+    def style
+      {
+        left: "#{@left}px",
+        top: "#{@top}px",
+        width: "#{@width}px",
+        height: "#{@height}px",
+      }
+    end
+
+    def arc_path
+      center_x = @width / 2
+      center_y = @height / 2
+      radius_x = @width / 2
+      radius_y = @height / 2
+      start_angle_degrees = radians_to_degrees(@angle1) % 360
+      end_angle_degrees = radians_to_degrees(@angle2) % 360
+      large_arc_flag = (end_angle_degrees - start_angle_degrees) % 360 > 180 ? 1 : 0
+
+      "M#{center_x} #{center_y} L#{@width} #{center_y} " \
+        "A#{radius_x} #{radius_y} 0 #{large_arc_flag} 0 " \
+        "#{center_x + radius_x * Math.cos(degrees_to_radians(end_angle_degrees))} " \
+        "#{center_y + radius_y * Math.sin(degrees_to_radians(end_angle_degrees))} Z"
+    end
+
+    def degrees_to_radians(degrees)
+      degrees * Math::PI / 180
+    end
+
+    def radians_to_degrees(radians)
+      radians * (180.0 / Math::PI)
+    end
+  end
+end