scarpe 0.1.0 → 0.2.0

data/lib/scarpe/stack.rb

@@ -1,16 +1,70 @@
-module Scarpe
-  class Stack
-    include Scarpe::Container
-    
-    attr_reader :app
-    def initialize(app, &block)
-      @app = app
-      @app.append(render)
-      append(&block)
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "nokogiri"
+
+class Scarpe
+  class Stack < Scarpe::Widget
+    include Scarpe::Background
+    include Scarpe::Border
+    include Scarpe::Spacing
+
+    display_properties :width, :height, :margin, :padding, :scroll, :margin_top, :margin_left, :margin_right, :margin_bottom, :options
+
+    def initialize(width: nil, height: "100%", margin: nil, padding: nil, scroll: false, margin_top: nil, margin_bottom: nil, margin_left: nil,
+      margin_right: nil, **options, &block)
+
+      # TODO: what are these options? Are they guaranteed serializable?
+      @options = options
+
+      super
+
+      create_display_widget
+      # Create the display-side widget *before* instance_eval, which will add child widgets with their display widgets
+      instance_eval(&block) if block_given?
+    end
+  end
+
+  class Widget
+    def download(url)
+      Thread.new do
+        begin
+          uri = URI(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+          request = Net::HTTP::Get.new(uri.request_uri)
+
+          http.request(request) do |response|
+            case response
+            when Net::HTTPSuccess
+              # content = response.body
+
+              # headers = response.header
+
+              get_title(content)
+            else
+              Scarpe.error("Failed to download content. Response code: #{response.code}")
+            end
+          end
+        rescue StandardError => e
+          Scarpe.error("Error occurred while downloading: #{e.message}")
+        end
+      end
     end
 
-    def render
-      "<div style='display: flex; flex-direction: column' id=#{object_id}></div>"
+    private
+
+    def get_title(content)
+      doc = Nokogiri::HTML(content)
+
+      title = doc.at_css("title")&.text&.strip || ""
+
+      # headings = doc.css("h1").map(&:text)
+
+      title
     end
   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 < Scarpe::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/text_widget.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Scarpe::TextWidget
+
+class Scarpe
+  class TextWidget < Scarpe::Widget
+    class << self
+      # rubocop:disable Lint/MissingSuper
+      def inherited(subclass)
+        Scarpe::Widget.widget_classes ||= []
+        Scarpe::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(Scarpe::TextWidget) do
+        display_property :content
+
+        def initialize(content)
+          @content = content
+
+          super
+
+          create_display_widget
+        end
+      end
+      Scarpe.const_set class_name, widget_class
+      widget_class.class_eval do
+        display_property :content
+      end
+    end
+  end
+end
+
+Scarpe.default_text_widget_with(:code)
+Scarpe.default_text_widget_with(:em)
+Scarpe.default_text_widget_with(:strong)

data/lib/scarpe/unit_test_helpers.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "json"
+require "fileutils"
+
+# 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; 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
+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
+
+  # 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
+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"],
+
+      "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 +1,5 @@
 # frozen_string_literal: true
 
-module Scarpe
-  VERSION = "0.1.0"
+class Scarpe
+  VERSION = "0.2.0"
 end

data/lib/scarpe/widget.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+# Scarpe::Widget
+#
+# Interface:
+# A Scarpe::Widget defines the "element" method to indicate that it has custom markup of
+# some kind. A Widget with no element method renders as its children's markup, joined.
+
+class Scarpe
+  class Widget < DisplayService::Linkable
+    include Scarpe::Log
+    include Scarpe::Colors
+
+    class << self
+      attr_accessor :widget_classes, :alias_name
+
+      def alias_as(name)
+        self.alias_name = name
+      end
+
+      def inherited(subclass)
+        self.widget_classes ||= []
+        self.widget_classes << subclass
+        super
+      end
+
+      def dsl_name
+        n = name.split("::").last.chomp("Widget")
+        n.gsub(/(.)([A-Z])/, '\1_\2').downcase
+      end
+
+      def widget_class_by_name(name)
+        widget_classes.detect { |k| k.dsl_name == name.to_s || k.alias_name.to_s == name.to_s }
+      end
+
+      private
+
+      def linkable_properties
+        @linkable_properties ||= []
+      end
+
+      def linkable_properties_hash
+        @linkable_properties_hash ||= {}
+      end
+
+      public
+
+      # Display properties in Shoes Linkables are automatically sync'd with the display side objects.
+      # TODO: do we want types or other modifiers on specific properties?
+      def display_property(name)
+        name = name.to_s
+
+        return if linkable_properties_hash[name]
+
+        linkable_properties << { name: name }
+        linkable_properties_hash[name] = true
+      end
+
+      def display_properties(*names)
+        names.each { |n| display_property(n) }
+      end
+
+      def display_property_names
+        linkable_properties.map { |prop| prop[:name] }
+      end
+
+      def display_property_name?(name)
+        linkable_properties_hash[name.to_s]
+      end
+    end
+
+    def initialize(*args, **kwargs)
+      log_init("Widget")
+
+      self.class.display_property_names.each do |prop|
+        if kwargs[prop.to_sym]
+          instance_variable_set("@" + prop, kwargs[prop.to_sym])
+        end
+      end
+
+      super() # linkable_id defaults to object_id
+    end
+
+    def bind_self_event(event_name, &block)
+      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+
+      bind_shoes_event(event_name: event_name, target: linkable_id, &block)
+    end
+
+    def bind_no_target_event(event_name, &block)
+      bind_shoes_event(event_name:, &block)
+    end
+
+    def display_properties
+      properties = {}
+      self.class.display_property_names.each do |prop|
+        properties[prop] = instance_variable_get("@" + prop)
+      end
+      properties["shoes_linkable_id"] = self.linkable_id
+      properties
+    end
+
+    def create_display_widget
+      klass_name = self.class.name.delete_prefix("Scarpe::").delete_prefix("Shoes::")
+
+      # Should we save a reference to widget for later reference?
+      DisplayService.display_service.create_display_widget_for(klass_name, self.linkable_id, display_properties)
+    end
+
+    attr_reader :parent
+    attr_reader :children
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+      send_shoes_event(new_parent.linkable_id, event_name: "parent", target: linkable_id)
+    end
+
+    # Do not call directly, use set_parent
+    def remove_child(child)
+      @children ||= []
+      unless @children.include?(child)
+        @log.warn("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
+
+    # Removes the element from the Scarpe::Widget tree
+    def destroy
+      @parent&.remove_child(self)
+      send_shoes_event(event_name: "destroy", target: linkable_id)
+    end
+
+    alias_method :destroy_self, :destroy
+
+    # We use method_missing for widget-creating methods like "button",
+    # and also to auto-create display-property getters and setters.
+    def method_missing(name, *args, **kwargs, &block)
+      name_s = name.to_s
+
+      if name_s[-1] == "="
+        prop_name = name_s[0..-2]
+        if self.class.display_property_name?(prop_name)
+          self.class.define_method(name) do |new_value|
+            raise "Trying to set display properties in an object with no linkable ID!" unless linkable_id
+
+            instance_variable_set("@" + prop_name, new_value)
+            send_shoes_event({ prop_name => new_value }, event_name: "prop_change", target: linkable_id)
+          end
+
+          return self.send(name, *args, **kwargs, &block)
+        end
+      end
+
+      if self.class.display_property_name?(name_s)
+        self.class.define_method(name) do
+          raise "Trying to get display properties in an object with no linkable ID!" unless linkable_id
+
+          instance_variable_get("@" + name_s)
+        end
+
+        return self.send(name, *args, **kwargs, &block)
+      end
+
+      klass = Widget.widget_class_by_name(name)
+      return super unless klass
+
+      ::Scarpe::Widget.define_method(name) do |*args, **kwargs, &block|
+        # Look up the Shoes widget and create it...
+        widget_instance = klass.new(*args, **kwargs, &block)
+
+        unless klass.ancestors.include?(Scarpe::TextWidget)
+          widget_instance.set_parent(self)
+        end
+
+        widget_instance
+      end
+
+      send(name, *args, **kwargs, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name_s = name.to_s
+      return true if self.class.display_property_name?(name_s)
+      return true if self.class.display_property_name?(name_s[0..-2]) && name_s[-1] == "="
+      return true if Widget.widget_class_by_name(name_s)
+
+      super
+    end
+  end
+end

data/lib/scarpe/widgets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "colors"
+require_relative "widget"
+require_relative "app"
+
+require_relative "spacing"
+require_relative "background"
+require_relative "border"
+require_relative "star"
+
+require_relative "fill"
+
+require_relative "document_root"
+require_relative "para"
+require_relative "stack"
+require_relative "flow"
+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_relative "text_widget"
+require_relative "link"
+require_relative "line"

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