scarpe 0.2.1 → 0.3.0

data/lib/scarpe/para.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class Para < Scarpe::Widget
-    class << self
-      def inherited(subclass)
-        Scarpe::Widget.widget_classes ||= []
-        Scarpe::Widget.widget_classes << subclass
-        super
-      end
-    end
-
-    display_properties :text_items, :stroke, :size, :font, :html_attributes, :hidden
-
-    def initialize(*args, stroke: nil, size: :para, font: nil, hidden: false, **html_attributes)
-      @text_children = args || []
-      if hidden
-        @hidden_text_items = text_children_to_items(@text_children)
-        @text_items = []
-      else
-        # Text_children alternates strings and TextWidgets, so we can't just pass
-        # it as a display property. It won't serialize.
-        @text_items = text_children_to_items(@text_children)
-        @hidden_text_items = []
-      end
-      stroke = to_rgb(stroke)
-
-      @html_attributes = html_attributes || {}
-
-      super
-
-      create_display_widget
-    end
-
-    def text_children_to_items(text_children)
-      text_children.map { |arg| arg.is_a?(String) ? arg : arg.linkable_id }
-    end
-
-    def replace(*children)
-      @text_children = children
-
-      # This should signal the display widget to change
-      self.text_items = text_children_to_items(@text_children)
-    end
-
-    def hide
-      # idempotent
-      return unless @hidden_text_items.empty?
-
-      @hidden_text_items = self.text_items
-      self.text_items = []
-    end
-
-    def show
-      # idempotent
-      return unless self.text_items.empty?
-
-      self.text_items = @hidden_text_items
-      @hidden_text_items = []
-    end
-  end
-
-  class Widget
-    def banner(*args, **kwargs)
-      para(*args, **{ size: :banner }.merge(kwargs))
-    end
-
-    def title(*args, **kwargs)
-      para(*args, **{ size: :title }.merge(kwargs))
-    end
-
-    def subtitle(*args, **kwargs)
-      para(*args, **{ size: :subtitle }.merge(kwargs))
-    end
-
-    def tagline(*args, **kwargs)
-      para(*args, **{ size: :tagline }.merge(kwargs))
-    end
-
-    def caption(*args, **kwargs)
-      para(*args, **{ size: :caption }.merge(kwargs))
-    end
-
-    def inscription(*args, **kwargs)
-      para(*args, **{ size: :inscription }.merge(kwargs))
-    end
-
-    alias_method :ins, :inscription
-  end
-end

data/lib/scarpe/shape.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "wv/shape_helper"
-
-class Scarpe
-  class Shape < Scarpe::Widget
-    include ShapeHelper
-    display_properties :left, :top
-
-    def initialize(left: nil, top: nil, path_commands: nil, &block)
-      @left = left
-      @top = top
-
-      super()
-      create_display_widget
-      instance_eval(&block) if block_given?
-    end
-  end
-end

data/lib/scarpe/spacing.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  module Spacing
-    def self.included(includer)
-      includer.display_properties :margin, :padding
-    end
-  end
-end

data/lib/scarpe/stack.rb

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

data/lib/scarpe/star.rb

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

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

@@ -1,163 +0,0 @@
-# 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/widget.rb

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

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