scarpe 0.2.1 → 0.3.0

data/lib/scarpe.rb

@@ -1,42 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "scarpe/logger"
-
-# This will never be triggered -- we use the (...) feature below, which means this
-# file won't even parse in old Rubies.
 if RUBY_VERSION[0..2] < "3.2"
-  Scarpe::Logger.logger("Scarpe").error("Scarpe requires Ruby 3.2 or higher!")
+  Shoes::Log.logger("Scarpe").error("Scarpe requires Ruby 3.2 or higher!")
   exit(-1)
 end
 
-require "securerandom"
-require "json"
-
-require_relative "constants"
-
-class Scarpe::Error < StandardError; end
-
-require_relative "scarpe/version"
-require_relative "scarpe/promises"
-require_relative "scarpe/display_service"
-require_relative "scarpe/widgets"
-
-require "bloops"
+require "shoes"
+require "lacci/scarpe_core"
 
 d_s = ENV["SCARPE_DISPLAY_SERVICE"] || "wv_local"
 # This is require, not require_relative, to allow gems to supply a new display service
+require "scarpe/errors"
 require "scarpe/#{d_s}"
-
-#Constants Module
-include Constants
-
-class Scarpe
-  class << self
-    def app(...)
-      app = Scarpe::App.new(...)
-      app.init
-      app.run
-      app.destroy
-    end
-  end
-end

data/logger/debug_web_wrangler.json

@@ -1,4 +1,4 @@
 {
     "default": "warn",
-    "WV::WebWrangler": ["debug", "logger/web_wrangler.log"]
+    "Webview::WebWrangler": ["debug", "logger/web_wrangler.log"]
 }

data/logger/scarpe_wv_test.json

@@ -1,4 +1,4 @@
 {
     "default": ["debug", "logger/test_failure.log"],
-    "WebviewAPI": ["debug", "logger/test_failure_wv_api.log"]
+    "Webview::API": ["debug", "logger/test_failure_wv_api.log"]
 }

data/scarpe-components/.gitignore

@@ -0,0 +1 @@
+scarpe-components-*.gem

data/scarpe-components/Gemfile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "lacci", path: "../lacci"
+
+gem "rake", "~> 13.0"
+
+gem "nokogiri"
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "minitest-reporters"
+end
+
+group :development do
+  gem "debug"
+  gem "rubocop", "~> 1.21"
+  gem "rubocop-shopify"
+end

data/scarpe-components/Gemfile.lock

@@ -0,0 +1,86 @@
+PATH
+  remote: ../lacci
+  specs:
+    lacci (0.3.0)
+      scarpe-components
+
+PATH
+  remote: .
+  specs:
+    scarpe-components (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    ast (2.4.2)
+    base64 (0.1.1)
+    builder (3.2.4)
+    debug (1.8.0)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
+    io-console (0.6.0)
+    irb (1.8.0)
+      rdoc (~> 6.5)
+      reline (>= 0.3.6)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    minitest (5.19.0)
+    minitest-reporters (1.6.1)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    nokogiri (1.15.4-x86_64-darwin)
+      racc (~> 1.4)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    psych (5.1.0)
+      stringio
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rdoc (6.5.0)
+      psych (>= 4.0.0)
+    regexp_parser (2.8.1)
+    reline (0.3.8)
+      io-console (~> 0.5)
+    rexml (3.2.6)
+    rubocop (1.56.2)
+      base64 (~> 0.1.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-shopify (2.14.0)
+      rubocop (~> 1.51)
+    ruby-progressbar (1.13.0)
+    stringio (3.0.8)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-darwin-22
+
+DEPENDENCIES
+  debug
+  lacci!
+  minitest (~> 5.0)
+  minitest-reporters
+  nokogiri
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+  rubocop-shopify
+  scarpe-components!
+
+BUNDLED WITH
+   2.4.14

data/scarpe-components/README.md

@@ -0,0 +1,35 @@
+# Scarpe-Components
+
+Scarpe is several things. We package up the Shoes API with as few implementation details as possible (called Lacci.) We have a Webview-based display library, in both local and over-a-socket (relay) versions. We have a Wasm display library (Scarpe-Wasm) in a separate gem.
+
+And we have various default implementations of different reusable components. Scarpe's hierarchical logger isn't particularly specific to your display library or underlying GUI library, but we'd like it to be usable by multiple display libs. CatsCradle is only useful if you're trying to fix up an impedance mismatch between Ruby and an evented under-layer, but it's not really specific to Webview. Scarpe's default downloader, using Ruby's built-in HTTP libraries, is good in many cases but you might want to replace it (e.g. with Typhoeus for better parallel downloads or Hystrix for robustness to bad network connections) in some cases.
+
+Part of our solution is the Scarpe-Components gem, which lives in the same repository as Scarpe (for now?). These components can live there. Any specific display library can pick and choose what it wants or needs and handle its dependencies as it sees fit.
+
+## Dependency Hell
+
+A "gem full of optional reusable components" presents an awkward challenge for Rubygems. What are the gem's dependencies? Do you make it depend on every possible library, requiring FastImage and Nokogiri and SQLite and whatever else any component might ever require? That would be as bad as making ActiveRecord need MySQL and SQLite and Postgres and Oracle and... But if you don't give it *any* dependencies, you're going to have a harsh surprise at runtime when Bundler can't find any of the gems you need.
+
+You can break everything up into tiny pieces, like ActiveRecord having a separate adapter for certain databases. You could do the same with an activerecord-mysql and activerecord-postgres and activerecord-sqlite gem to complete the set. Or, like, ActiveRecord, you can say "declare activerecord as a dependency, and also one or more other database gems, and we'll figure out what's available at runtime." That approach can be pretty fragile and it adds extra complexity -- how do you make sure everything is required at the right time and ActiveRecord can find everything that's available? How do you balance gem dependencies that are built into ActiveRecord with those for unusual databases that get added by other gems, later? Your plugin system (like ActiveRecord's) can get extensive and fragile.
+
+Scarpe-Components kicks that problem down the road to the display libraries. Would a particular display library like to use the FastImage-based image implementation? Great! It can declare a dependency on the FastImage gem. Would it like to optionally allow the built-in Ruby downloader, but also have an optional robustified version using RestClient? Lovely. It can either create multiple gems (e.g. scarpe-gtk-rcdownload and scarpe-gtk-plaindownload) or look for RestClient being available at runtime, as it pleases. The FastImage implementation lives in Scarpe-Components, but the dependency is declared by the display library or the app.
+
+## Using an Implementation
+
+Components in Scarpe-Components are designed to be used individually. They can require each other, but they should only require components they will actually use. The whole library is designed to be used a la carte, and normally no display service will use every component.
+
+A display library will declare scarpe-components as a dependency. Then, usually from its named require file (e.g. wv_local.rb, wv_relay.rb, wasm_local.rb) it will set up those dependencies by requiring components that it wants and if necessary creating and configuring them. That way a specific display service (e.g. wv_local) can require a specific component (e.g. Logging-gem-based hierarchical logging) and configure it how it wants (e.g. ENV var pointing to a local JSON config file.)
+
+## How is this Different from Lacci?
+
+Scarpe already has a gem full of reusable components, one that every Scarpe-based application already has to use. Lacci declares the Shoes API, and is 100% required for every Scarpe-based Shoes application everywhere.
+
+So how do you tell what goes into Scarpe-Components vs what goes into Lacci?
+
+Lacci is, at heart, an API with as little implementation as possible. It declares the Shoes GUI objects, but not how to display them. Ordinarily a Shoes application will require (in the sense of Kernel#require) every part of Lacci -- it will load the entire library. Even if we add optional components (e.g. a Lacci-based Bloops API with no implementation behind it), those components will be loaded by every Shoes app that uses that part of the API.
+
+As a result, Lacci should have minimal (preferably zero) dependencies. Any code doing "real work" should be removed from Lacci completely, as soon as possible. Since *every* Shoes app is going to require Lacci, it should be possible to use it with essentially no dependencies, minimal memory footprint, minimal load time. It is a skeleton to hang functionality on, not a thing that functions for itself.
+
+Scarpe-Components is a grab bag of default implementations, intended to be replaceable. But each of them does something. Most of them have dependencies. It's fine for a Scarpe-Component implementation to depend on the Logging gem, provided it says it does. Nokogiri? 100% fair. Does it do something with a nontrivial amount of computation, like rendering HTML output? No problem. This is very different from Lacci.
+
+If a component should be reused, it's probably fine to put it into Scarpe-Components. It *might* be fine to put it in Lacci. For Scarpe-Components, ask yourself, "will more than one Scarpe display service possibly want to use this?" For Lacci, the test is more strict: "will *every* Scarpe display service want to use this? Does it have no dependencies at all, and do very little computation and take very little memory?"

data/scarpe-components/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: [:test]

data/scarpe-components/lib/scarpe/components/base64.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "base64"
+require "uri"
+
+module Scarpe; end
+module Scarpe::Components; end
+module Scarpe
+  module Components::Base64
+    def valid_url?(string)
+      uri = URI.parse(string)
+      uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+    rescue URI::InvalidURIError, URI::BadURIError
+      false
+    end
+
+    def encode_file_to_base64(image_path)
+      image_data = File.binread(image_path)
+
+      encoded_data = ::Base64.strict_encode64(image_data)
+
+      encoded_data
+    end
+  end
+end

data/scarpe-components/lib/scarpe/components/calzini/alert.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Scarpe::Components::Calzini
+  def alert_element(props)
+    event = props["event_name"] || "click"
+    onclick = handler_js_code(event)
+
+    HTML.render do |h|
+      h.div(id: html_id, style: alert_overlay_style(props)) do
+        h.div(style: alert_modal_style) do
+          h.div(style: {}) { props["text"] }
+          h.button(style: {}, onclick: onclick) { "OK" }
+        end
+      end
+    end
+  end
+
+  private
+
+  # If the whole drawable is hidden, the parent style adds display:none
+  def alert_overlay_style(props)
+    {
+      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(drawable_style(props))
+  end
+
+  def alert_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
+end

data/scarpe-components/lib/scarpe/components/calzini/art_widgets.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Scarpe::Components::Calzini
+  def arc_element(props, &block)
+    dc = props["draw_context"] || {}
+    rotate = dc["rotate"]
+    HTML.render do |h|
+      h.div(id: html_id, style: arc_style(props)) do
+        h.svg(width: props["width"], height: props["height"]) do
+          h.path(d: arc_path(props), transform: "rotate(#{rotate}, #{props["width"] / 2}, #{props["height"] / 2})")
+        end
+        block.call(h) if block_given?
+      end
+    end
+  end
+
+  def rect_element(props)
+    dc = props["draw_context"] || {}
+    rotate = dc["rotate"]
+    HTML.render do |h|
+      h.div(id: html_id, style: drawable_style(props)) do
+        width = props["width"].to_i
+        height = props["height"].to_i
+        if props["curve"]
+          width += 2 * props["curve"].to_i
+          height += 2 * props["curve"].to_i
+        end
+        h.svg(width:, height:) do
+          attrs = { x: props["left"], y: props["top"], width: props["width"], height: props["height"], style: rect_svg_style(props) }
+          attrs[:rx] = props["curve"] if props["curve"]
+
+          h.rect(**attrs, transform: "rotate(#{rotate} #{width / 2} #{height / 2})")
+        end
+      end
+    end
+  end
+
+  def line_element(props)
+    HTML.render do |h|
+      h.div(id: html_id, style: line_div_style(props)) do
+        h.svg(width: props["x2"], height: props["y2"]) do
+          h.line(x1: props["left"], y1: props["top"], x2: props["x2"], y2: props["y2"], style: line_svg_style(props))
+        end
+      end
+    end
+  end
+
+  def star_element(props, &block)
+    dc = props["draw_context"] || {}
+    fill = dc["fill"]
+    stroke = dc["stroke"]
+    fill = "black" if !fill || fill == ""
+    stroke = "black" if !stroke || stroke == ""
+    HTML.render do |h|
+      h.div(id: html_id, style: star_style(props)) do
+        h.svg(width: props["outer"], height: props["outer"], style: "fill:#{fill}") do
+          h.polygon(points: star_points(props), style: "stroke:#{stroke};stroke-width:2")
+        end
+        block.call(h) if block_given?
+      end
+    end
+  end
+
+  private
+
+  def arc_style(props)
+    drawable_style(props).merge({
+      left: "#{props["left"]}px",
+      top: "#{props["top"]}px",
+      width: "#{props["width"]}px",
+      height: "#{props["height"]}px",
+    })
+  end
+
+  def arc_path(props)
+    center_x = props["width"] / 2
+    center_y = props["height"] / 2
+    radius_x = props["width"] / 2
+    radius_y = props["height"] / 2
+    start_angle_degrees = radians_to_degrees(props["angle1"]) % 360
+    end_angle_degrees = radians_to_degrees(props["angle2"]) % 360
+    large_arc_flag = (end_angle_degrees - start_angle_degrees) % 360 > 180 ? 1 : 0
+
+    "M#{center_x} #{center_y} L#{props["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 line_div_style(props)
+    drawable_style(props).merge({
+      left: "#{props["left"]}px",
+      top: "#{props["top"]}px",
+    })
+  end
+
+  def line_svg_style(props)
+    stroke = if props["draw_context"] && !props["draw_context"]["stroke"].to_s.empty?
+      (props["draw_context"]["stroke"]).to_s
+    else
+      "black"
+    end
+    {
+
+      "stroke": stroke,
+      "stroke-width": "4",
+    }.compact
+  end
+
+  def rect_svg_style(props)
+    {
+      stroke: (props["draw_context"] || {})["stroke"],
+      #"stroke-width": "1",
+    }.compact
+  end
+
+  def star_style(props)
+    drawable_style(props).merge({
+      width: dimensions_length(props["width"]),
+      height: dimensions_length(props["height"]),
+    }).compact
+  end
+
+  def star_points(props)
+    angle = 2 * Math::PI / props["points"]
+    coordinates = []
+
+    props["points"].times do |i|
+      outer_angle = i * angle
+      inner_angle = outer_angle + angle / 2
+
+      coordinates.concat(star_get_coordinates(outer_angle, inner_angle, props))
+    end
+
+    coordinates.join(",")
+  end
+
+  def star_get_coordinates(outer_angle, inner_angle, props)
+    outer_x = props["outer"] / 2 + Math.cos(outer_angle) * props["outer"] / 2
+    outer_y = props["outer"] / 2 + Math.sin(outer_angle) * props["outer"] / 2
+
+    inner_x = props["outer"] / 2 + Math.cos(inner_angle) * props["inner"] / 2
+    inner_y = props["outer"] / 2 + Math.sin(inner_angle) * props["inner"] / 2
+
+    [outer_x, outer_y, inner_x, inner_y]
+  end
+
+  def arrow_element(props)
+    left = props["left"]
+    top = props["top"]
+    width = props["width"]
+    end_x = left + width
+    end_y = top
+    stroke_width = width / 2
+    dc = props["draw_context"] || {}
+    fill = dc["fill"]
+    stroke = dc["stroke"]
+    rotate = dc["rotate"]
+    fill = "black" if !fill || fill == ""
+    stroke = "black" if !stroke || stroke == ""
+
+    stroke_width = width / 4
+
+    HTML.render do |h|
+      h.div(id: html_id, style: arrow_div_style(props)) do
+        h.svg do
+          h.defs do
+            h.marker(
+              id: "head",
+              viewBox: "0 0 70 70",
+              markerWidth: stroke_width.to_s,
+              markerHeight: stroke_width.to_s,
+              refX: "5",
+              refY: "5",
+              orient: "auto-start-reverse",
+            ) do
+              h.path(d: "M 0 0 L 10 5 L 0 10 z", fill: fill.to_s)
+            end
+          end
+
+          h.line(
+            x2: left.to_s,
+            y2: top.to_s,
+            x1: end_x.to_s,
+            y1: end_y.to_s,
+            fill: fill.to_s,
+            stroke: stroke.to_s,
+            "stroke-width" => stroke_width.to_s,
+            "marker-end" => "url(#head)",
+            transform: "rotate(#{rotate}, #{left + width / 2}, #{top})",
+          )
+        end
+      end
+    end
+  end
+  def arrow_div_style(props)
+    drawable_style(props).merge({
+      position: "absolute",
+      left: "#{props["left"]}px",
+      top: "#{props["top"]}px",
+    })
+  end
+end

data/scarpe-components/lib/scarpe/components/calzini/button.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Scarpe::Components::Calzini
+  def button_element(props)
+    HTML.render do |h|
+      h.button(
+        id: html_id,
+        onclick: handler_js_code("click"),
+        onmouseover: handler_js_code("hover"),
+        style: button_style(props),
+        title: props["tooltip"],
+      ) do
+        props["text"]
+      end
+    end
+  end
+
+  private
+
+  def button_style(props)
+    styles = drawable_style(props)
+
+    styles[:"background-color"] = props["color"] if props["color"]
+    styles[:"padding-top"] = props["padding_top"] if props["padding_top"]
+    styles[:"padding-bottom"] = props["padding_bottom"] if props["padding_bottom"]
+    styles[:color] = props["text_color"] if props["text_color"]
+    styles[:width] = dimensions_length(props["width"]) if props["width"]
+    styles[:height] = dimensions_length(props["height"]) if props["height"]
+    styles[:"font-size"] = props["font_size"] if props["font_size"]
+
+    styles[:top] = dimensions_length(props["top"]) if props["top"]
+    styles[:left] = dimensions_length(props["left"]) if props["left"]
+    styles[:position] = "absolute" if props["top"] || props["left"]
+    styles[:"font-size"] = dimensions_length(text_size(props["size"])) if props["size"]
+    styles[:"font-family"] = props["font"] if props["font"]
+
+    styles
+  end
+end

data/scarpe-components/lib/scarpe/components/calzini/misc.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Scarpe::Components::Calzini
+  def check_element(props)
+    HTML.render do |h|
+      h.input type: :checkbox,
+        id: html_id,
+        onclick: handler_js_code("click"),
+        value: props["text"],
+        checked: props["checked"],
+        style: drawable_style(props)
+    end
+  end
+
+  def edit_box_element(props)
+    oninput = handler_js_code("change", "this.value")
+
+    HTML.render do |h|
+      h.textarea(id: html_id, oninput: oninput, style: edit_box_style(props)) { props["text"] }
+    end
+  end
+
+  def edit_line_element(props)
+    oninput = handler_js_code("change", "this.value")
+
+    HTML.render do |h|
+      h.input(id: html_id, oninput: oninput, value: props["text"], style: edit_line_style(props))
+    end
+  end
+
+  def image_element(props)
+    style = image_style(props)
+
+    if props["click"]
+      HTML.render do |h|
+        h.a(id: html_id, href: props["click"]) { h.img(id: html_id, src: props["url"], style:) }
+      end
+    else
+      HTML.render do |h|
+        h.img(id: html_id, src: props["url"], style:)
+      end
+    end
+  end
+
+  def list_box_element(props)
+    onchange = handler_js_code("change", "this.options[this.selectedIndex].value")
+
+    # Is this useful at all? Is it overridden below completely?
+    option_attrs = { value: nil, selected: false }
+
+    HTML.render do |h|
+      h.select(id: html_id, onchange:, style: list_box_style(props)) do
+        (props["items"] || []).each do |item|
+          option_attrs = {
+            value: item,
+          }
+          if item == props["choose"]
+            option_attrs[:selected] = "true"
+          end
+          h.option(**option_attrs) do
+            item
+          end
+        end
+      end
+    end
+  end
+
+  def radio_element(props)
+    # This is wrong - need to default to the parent slot -- maybe its linkable ID?
+    group_name = props["group"] || "no_group"
+
+    HTML.render do |h|
+      h.input(
+        type: :radio,
+        id: html_id,
+        onclick: handler_js_code("click"),
+        name: group_name,
+        value: props["text"],
+        checked: props["checked"],
+        style: drawable_style(props),
+      )
+    end
+  end
+
+  def video_element(props)
+    HTML.render do |h|
+      h.video(id: html_id, style: drawable_style(props), controls: true) do
+        h.source(src: @url, type: props["format"])
+      end
+    end
+  end
+
+  def progress_element(props)
+    HTML.render do |h|
+      h.progress(
+        id: html_id,
+        style: drawable_style(props),
+        role: "progressbar",
+        "aria-valuenow": props["fraction"],
+        "aria-valuemin": 0.0,
+        "aria-valuemax": 1.0,
+        max: 1,
+        value: props["fraction"],
+      )
+    end
+  end
+
+  private
+
+  def edit_box_style(props)
+    drawable_style(props).merge({
+      height: dimensions_length(props["height"]),
+      width: dimensions_length(props["width"]),
+    }.compact)
+  end
+
+  def edit_line_style(props)
+    styles = drawable_style(props)
+
+    styles[:width] = dimensions_length(props["width"]) if props["width"]
+
+    styles
+  end
+
+  def image_style(props)
+    styles = drawable_style(props)
+
+    styles[:width] = dimensions_length(props["width"]) if props["width"]
+    styles[:height] = dimensions_length(props["height"]) if props["height"]
+
+    styles[:top] = dimensions_length(props["top"]) if props["top"]
+    styles[:left] = dimensions_length(props["left"]) if props["left"]
+    styles[:position] = "absolute" if props["top"] || props["left"]
+
+    styles
+  end
+
+  def list_box_style(props)
+    styles = drawable_style(props)
+
+    styles[:height] = dimensions_length(props["height"]) if props["height"]
+    styles[:width] = dimensions_length(props["width"]) if props["width"]
+
+    styles
+  end
+end