scarpe 0.2.2 → 0.4.0

data/lacci/lib/shoes/widgets/stack.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Stack < Shoes::Slot
-    include Shoes::Background
-    include Shoes::Border
-    include Shoes::Spacing
-
-    # 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/lacci/lib/shoes/widgets/star.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Shoes
-  class Star < Shoes::Widget
-    display_properties :left, :top, :points, :outer, :inner, :draw_context
-
-    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)
-
-      @draw_context = Shoes::App.instance.current_draw_context
-
-      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/lacci/lib/shoes/widgets/subscription_item.rb

@@ -1,60 +0,0 @@
-# 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 Shoes::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/lacci/lib/shoes/widgets/text_widget.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-# Shoes::TextWidget
-
-module Shoes
-  class TextWidget < Shoes::Widget
-    class << self
-      # rubocop:disable Lint/MissingSuper
-      def inherited(subclass)
-        Shoes::Widget.widget_classes ||= []
-        Shoes::Widget.widget_classes << subclass
-      end
-      # rubocop:enable Lint/MissingSuper
-    end
-  end
-
-  class << self
-    def default_text_widget_with(element)
-      class_name = element.capitalize
-
-      widget_class = Class.new(Shoes::TextWidget) do
-        # Can we just change content to text to match the Shoes API?
-        display_property :content
-
-        def initialize(content)
-          @content = content
-
-          super
-
-          create_display_widget
-        end
-
-        def text
-          self.content
-        end
-
-        def text=(new_text)
-          self.content = new_text
-        end
-      end
-      Shoes.const_set class_name, widget_class
-      widget_class.class_eval do
-        display_property :content
-      end
-    end
-  end
-end
-
-Shoes.default_text_widget_with(:code)
-Shoes.default_text_widget_with(:em)
-Shoes.default_text_widget_with(:strong)

data/lacci/lib/shoes/widgets/video.rb

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

data/lacci/lib/shoes/widgets.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "shoes/widgets/slot"
-require "shoes/widgets/stack"
-require "shoes/widgets/flow"
-require "shoes/widgets/document_root"
-
-require "shoes/widgets/text_widget"
-
-require "shoes/widgets/font"
-require "shoes/widgets/subscription_item"
-
-require "shoes/widgets/arc"
-require "shoes/widgets/line"
-require "shoes/widgets/shape"
-require "shoes/widgets/star"
-
-require "shoes/widgets/alert"
-require "shoes/widgets/button"
-require "shoes/widgets/check"
-require "shoes/widgets/edit_box"
-require "shoes/widgets/edit_line"
-require "shoes/widgets/image"
-require "shoes/widgets/link"
-require "shoes/widgets/list_box"
-require "shoes/widgets/para"
-require "shoes/widgets/radio"
-require "shoes/widgets/span"
-require "shoes/widgets/video"

data/lib/scarpe/evented_assertions.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "tempfile"
-require "json"
-require "fileutils"
-
-module Scarpe::Test; end
-
-# We need a separate assertion system for the kind of Scarpe
-# testing where we start a subprocess, perform the assertion
-# logic in the subprocess, and then run Minitest in the parent.
-# It's an unusual setup.
-module Scarpe::Test::EventedAssertions
-  # Assert that `text` includes `subtext`.
-  #
-  # @param text [String] the longer text
-  # @param subtext [String] the text that is asserted to be included
-  # @param msg [String,nil] if supplied, the failure message for the assertion
-  # @return [void]
-  def assert_include(text, subtext, msg = nil)
-    msg ||= "Expected #{text.inspect} to include #{subtext.inspect}"
-    assert text.include?(subtext), msg
-  end
-
-  # Assert that `text` does not include `subtext`.
-  #
-  # @param text [String] the longer text
-  # @param subtext [String] the text that is asserted to not be included
-  # @param msg [String,nil] if supplied, the failure message for the assertion
-  # @return [void]
-  def assert_not_include(text, subtext, msg = nil)
-    msg ||= "Expected #{text.inspect} not to include #{subtext.inspect}"
-    assert !text.include?(subtext), msg
-  end
-
-  # Assert that `actual_html` is the same as `expected_tag` with `opts`.
-  # This uses Scarpe's HTML tag-based renderer to render the tag and options
-  # into text, and valides that the text is the same.
-  #
-  # @see Scarpe::HTML.render
-  #
-  # @param actual_html [String] the html to compare to
-  # @param expected_tag [String,Symbol] the HTML tag, used to send a method call
-  # @param opts keyword options passed to the tag method call
-  # @yield block passed to the tag method call.
-  # @return [void]
-  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 allowed.
-  #
-  # @param result_bool [Boolean] true if the results are success, false if failure
-  # @param msg [String] the message included with the results
-  # @param data [Hash] any additional data to pass with the results
-  # @return void
-  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
-      Shoes::Log.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
-      Shoes::Log.logger("Test Results").warn "Returning identical results twice: #{results_returned.inspect}"
-    end
-
-    Shoes::Log.logger("Test Results").debug("Writing results file #{result_file.inspect} to disk!")
-    File.write(result_file, JSON.pretty_generate(result_structs))
-  end
-end

data/lib/scarpe/wv/alert.rb

@@ -1,66 +0,0 @@
-# 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
-
-    protected
-
-    # If the whole widget is hidden, the parent style adds display:none
-    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",
-      }.merge(style)
-    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/background.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "scarpe/components/base64"
-
-class Scarpe
-  module WebviewBackground
-    include Components::Base64
-
-    def style
-      styles = (super if defined?(super)) || {}
-      return styles unless @background_color
-
-      color = case @background_color
-      when Array
-        "rgba(#{@background_color.join(", ")})"
-      when Range
-        "linear-gradient(45deg, #{@background_color.first}, #{@background_color.last})"
-      when ->(value) { File.exist?(value) }
-        "url(data:image/png;base64,#{encode_file_to_base64(@background_color)})"
-      else
-        @background_color
-      end
-
-      styles.merge(background: color)
-    end
-  end
-end

data/lib/scarpe/wv/control_interface_test.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-# The ControlInterface doesn't, by default, include much of a test framework.
-# But writing a test framework in heredocs in test_helper.rb seems bad.
-# So we write a test framework here, but don't include it by default.
-# A running shoes app won't normally include it, but unit tests will.
-
-require "json"
-
-require "scarpe/components/unit_test_helpers"
-require "scarpe/evented_assertions"
-
-class Scarpe
-  DEFAULT_ASSERTION_TIMEOUT = 1.0
-
-  class ControlInterface
-    include Scarpe::Test::EventedAssertions
-    include Scarpe::Test::Helpers
-
-    def timed_out?
-      @did_time_out
-    end
-
-    def die_after(time)
-      t_start = Time.now
-      @die_after = [t_start, time]
-
-      wrangler.periodic_code("scarpeTestTimeout") do |*_args|
-        t_delta = (Time.now - t_start).to_f
-        if t_delta > time
-          @did_time_out = true
-          @log.warn("die_after - timed out after #{t_delta.inspect} (threshold: #{time.inspect})")
-          return_results(false, "Timed out!")
-          app.destroy
-        end
-      end
-    end
-
-    # This is returned alongside the actual results automatically
-    def test_metadata
-      data = {}
-      if @die_after
-        t_delta = (Time.now - @die_after[0]).to_f
-        data["die_after"] = {
-          t_start: @die_after[0].to_s,
-          threshold: @die_after[1],
-          passed: t_delta,
-        }
-      end
-      data
-    end
-
-    # Need to be able to query widgets in test code
-
-    def all_wv_widgets
-      known = [doc_root]
-      to_check = [doc_root]
-
-      until to_check.empty?
-        next_layer = to_check.flat_map(&:children)
-        known += next_layer
-        to_check = next_layer
-      end
-
-      # I don't *think* we'll ever have widget trees that merge back together, but just in case we'll de-dup
-      known.uniq
-    end
-
-    # Shoes doesn't name widgets. We aren't guaranteed that the Shoes widgets are even in the same
-    # process, since we have the Relay display service for Webview. So mostly we can look by
-    # display service class.
-    def find_wv_widgets(*specifiers)
-      widgets = all_wv_widgets
-
-      specifiers.each do |spec|
-        if spec.is_a?(Class)
-          widgets.select! { |w| spec === w }
-        else
-          raise "I don't know how to search for widgets by #{spec.inspect}!"
-        end
-      end
-
-      widgets
-    end
-
-    # We want an assertions library, but one that runs inside the spawned
-    # Webview sub-process.
-
-    # Note that we do *not* extract this assertions library to use elsewhere
-    # because it's very focused on evented assertions that start and stop
-    # over a period of time. Instantaneous procedural asserts don't want to
-    # use this API.
-
-    def return_when_assertions_done
-      assertions_may_exist
-
-      wrangler.periodic_code("scarpeReturnWhenAssertionsDone") do |*_args|
-        if @assertions_pending.empty?
-          success = @assertions_failed.empty?
-          return_results success, "Assertions #{success ? "succeeded" : "failed"}", assertion_data_as_a_struct
-          app.destroy
-        end
-      end
-    end
-
-    def assertions_may_exist
-      @assertions_pending ||= {}
-      @assertions_failed ||= {}
-      @assertions_passed ||= 0
-      @assertion_counter ||= 0
-    end
-
-    def start_assertion(code)
-      assertions_may_exist
-
-      this_assertion = @assertion_counter
-      @assertion_counter += 1
-
-      @assertions_pending[this_assertion] = {
-        id: this_assertion,
-        code: code,
-      }
-
-      this_assertion
-    end
-
-    def pass_assertion(id)
-      @assertions_pending.delete(id)
-      @assertions_passed += 1
-    end
-
-    def fail_assertion(id, fail_message)
-      item = @assertions_pending.delete(id)
-      item[:fail_message] = fail_message
-      @assertions_failed[id] = item
-    end
-
-    def assertions_pending?
-      !@assertions_pending.empty?
-    end
-
-    def assertion_data_as_a_struct
-      {
-        still_pending: @assertions_pending.size,
-        succeeded: @assertions_passed,
-        failed: @assertions_failed.size,
-        failures: @assertions_failed.values.map { |item| [item[:code], item[:failure_reason]] },
-      }
-    end
-
-    # Create a promise to do a JS assertion, normally after other ops have finished.
-    def assert_js(js_code, wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT)
-      id = start_assertion(js_code)
-
-      # this isn't a TestPromise, so it doesn't have the additional DSL entries
-      promise = wrangler.eval_js_async(js_code, wait_for: wait_for, timeout: timeout)
-      promise.on_rejected do
-        fail_assertion(id, "JS Eval failed: #{promise.reason.inspect}")
-      end
-      promise.on_fulfilled do
-        ret_val = promise.returned_value
-        if ret_val
-          pass_assertion(id)
-        else
-          fail_assertion(id, "Expected true JS value: #{ret_val.inspect}")
-        end
-      end
-
-      # So we wrap it in a no-op TestPromise, to get the DSL entries.
-      TestPromise.new(iface: self, wait_for: [promise]).to_execute {}
-    end
-
-    def assert(value, msg = nil)
-      id = start_assertion("#{caller[0]}: #{msg || "Value should be true!"}")
-
-      if value
-        pass_assertion(id)
-      else
-        fail_assertion(id, "Expected true Ruby value: #{value.inspect}")
-      end
-    end
-
-    def assert_equal(val1, val2, msg = nil)
-      assert val1 == val2, (msg || "Expected #{val2.inspect} to equal #{val1.inspect}!")
-    end
-
-    # How do we signal an error?
-    def with_js_value(js_code, wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
-      raise "Must give a block to with_js_value!" unless block
-
-      js_promise = wrangler.eval_js_async(js_code, wait_for: wait_for, timeout: timeout)
-      ruby_promise = TestPromise.new(iface: self, wait_for: [js_promise])
-      ruby_promise.to_execute(&block)
-      ruby_promise
-    end
-
-    def with_js_dom_html(wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
-      with_js_value("document.getElementById('wrapper-wvroot').innerHTML", wait_for: wait_for, timeout: timeout, &block)
-    end
-
-    def fully_updated(wait_for: [])
-      wrangler.promise_dom_fully_updated
-    end
-  end
-
-  # A {Scarpe::Promise} but with helper functions for Webview testing.
-  class TestPromise < Scarpe::Promise
-    def initialize(iface:, state: nil, wait_for: [], &scheduler)
-      @iface = iface
-      super(state: state, parents: wait_for, &scheduler)
-    end
-
-    def inspect
-      "<#TestPromise::#{object_id} state=#{state.inspect} parents=#{parents.inspect} value=#{returned_value.inspect} reason=#{reason.inspect}>"
-    end
-
-    # This method expects to wait for the parent TestPromise and then run a block of Ruby that returns
-    # another promise. This is useful for wrapping Promises like those from replace() that don't have
-    # the test DSL built in. The block will execute when this outer promise is scheduled -- so we don't do
-    # a replace() too early, for instance. And then the outer promise will fulfill when the inner one does.
-    def then_ruby_promise(wait_for: [], &block)
-      ruby_wrapper_promise = TestPromise.new iface: @iface, wait_for: ([self] + wait_for)
-
-      ruby_wrapper_promise.on_scheduled do
-        inner_ruby_promise = block.call
-        inner_ruby_promise.on_fulfilled { ruby_wrapper_promise.fulfilled!(inner_ruby_promise.returned_value) }
-      end
-    end
-
-    def then_with_js_value(js_code, wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
-      @iface.with_js_value(js_code, wait_for: (wait_for + [self]), timeout:, &block)
-    end
-
-    def then_with_js_dom_html(wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
-      @iface.with_js_dom_html(wait_for: (wait_for + [self]), timeout:, &block)
-    end
-  end
-end

data/lib/scarpe/wv/dimensions.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class Dimensions
-    class << self
-      def length(value)
-        case value
-        when Integer
-          if value < 0
-            "calc(100% - #{value.abs}px)"
-          else
-            "#{value}px"
-          end
-        when Float
-          "#{value * 100}%"
-        else
-          value
-        end
-      end
-    end
-  end
-end