lacci 0.2.1 → 0.3.0

data/lib/scarpe/unit_test_helpers.rb

@@ -1,236 +0,0 @@
-# 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

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

data/lib/scarpe/video.rb

@@ -1,15 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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

@@ -1,65 +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
-
-    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

@@ -1,104 +0,0 @@
-# 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

@@ -1,57 +0,0 @@
-# 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

data/lib/scarpe/wv/background.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "scarpe/base64"
-
-class Scarpe
-  module WebviewBackground
-    include 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/border.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  module WebviewBorder
-    def style
-      styles = (super if defined?(super)) || {}
-      return styles unless @border_color
-
-      border_color = case @border_color
-      when Range
-        { "border-image": "linear-gradient(45deg, #{@border_color.first}, #{@border_color.last})" }
-      when Array
-        { "border-color": "rgba(#{@border_color.join(", ")})" }
-      else
-        { "border-color": @border_color }
-      end
-      styles.merge(
-        "border-style": "solid",
-        "border-width": "#{@options[:strokewidth] || 1}px",
-        "border-radius": "#{@options[:curve] || 0}px",
-      ).merge(border_color)
-    end
-  end
-end

data/lib/scarpe/wv/button.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class WebviewButton < WebviewWidget
-    def initialize(properties)
-      super
-
-      # Bind to display-side handler for "click"
-      bind("click") do
-        # This will be sent to the bind_self_event in Button
-        send_self_event(event_name: "click")
-      end
-    end
-
-    def element
-      HTML.render do |h|
-        h.button(id: html_id, onclick: handler_js_code("click"), style: style) do
-          @text
-        end
-      end
-    end
-
-    private
-
-    def style
-      styles = {}
-      styles["background-color"] = @color
-      styles["padding-top"] = @padding_top
-      styles["padding-bottom"] = @padding_bottom
-      styles[:color] = @text_color
-      styles[:width] = Dimensions.length(@width) if @width
-      styles[:height] = Dimensions.length(@height) if @height
-      styles["font-size"] = @font_size
-
-      styles[:top] = Dimensions.length(@top) if @top
-      styles[:left] = Dimensions.length(@left) if @left
-      styles[:position] = "absolute" if @top || @left
-      styles["font-size"] = Dimensions.length(font_size) if @size
-      styles["font-family"] = @font if @font
-      styles["color"] = rgb_to_hex(@stroke) if @stroke
-      styles
-    end
-
-    def font_size
-      font_size = @size.is_a?(Symbol) ? SIZES[@size] : @size
-
-      Dimensions.length(font_size)
-    end
-  end
-end