scarpe 0.2.2 → 0.3.0

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class Scarpe; end
+module Scarpe; end
 module Scarpe::Components; end
-class Scarpe
+module Scarpe
   # Scarpe::Promise is a promises library, but one with no form of built-in
   # concurrency. Instead, promise callbacks are executed synchronously.
   # Even execution is usually synchronous, but can also be handled manually
@@ -198,7 +198,7 @@ class Scarpe
       case @state
       when :fulfilled
         # Should this be a no-op instead?
-        raise "Registering an executor on an already fulfilled promise means it will never run!"
+        raise Scarpe::NoOperationError, "Registering an executor on an already fulfilled promise means it will never run!"
       when :rejected
         return
       when :unscheduled
@@ -207,7 +207,7 @@ class Scarpe
         @executor = block
         call_executor
       else
-        raise "Internal error, illegal state!"
+        raise Scarpe::InternalError, "Internal error, illegal state!"
       end
 
       self
@@ -222,16 +222,16 @@ class Scarpe
 
       # First, filter out illegal input
       unless PROMISE_STATES.include?(old_state)
-        raise "Internal Promise error! Internal state was #{old_state.inspect}! Legal states: #{PROMISE_STATES.inspect}"
+        raise Scarpe::InternalError, "Internal Promise error! Internal state was #{old_state.inspect}! Legal states: #{PROMISE_STATES.inspect}"
       end
 
       unless PROMISE_STATES.include?(new_state)
-        raise "Internal Promise error! Internal state was set to #{new_state.inspect}! " +
+        raise Scarpe::InternalError, "Internal Promise error! Internal state was set to #{new_state.inspect}! " +
           "Legal states: #{PROMISE_STATES.inspect}"
       end
 
       if new_state != :fulfilled && new_state != :rejected && !value_or_reason.nil?
-        raise "Internal promise error! Non-completed state transitions should not specify a value or reason!"
+        raise Scarpe::InternalError, "Internal promise error! Non-completed state transitions should not specify a value or reason!"
       end
 
       # Here's our state-transition grid for what we're doing here.
@@ -254,11 +254,11 @@ class Scarpe
 
       # Transitioning to any *different* state after being fulfilled or rejected? Nope. Those states are final.
       if complete?
-        raise "Internal Promise error! Trying to change state from #{old_state.inspect} to #{new_state.inspect}!"
+        raise Scarpe::InternalError, "Internal Promise error! Trying to change state from #{old_state.inspect} to #{new_state.inspect}!"
       end
 
       if old_state == :pending && new_state == :unscheduled
-        raise "Can't change state from :pending to :unscheduled! Scheduling is not reversible!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Can't change state from :pending to :unscheduled! Scheduling is not reversible!"
       end
 
       # The next three checks should all be followed by calling handlers for the newly-changed state.
@@ -341,7 +341,7 @@ class Scarpe
         @on_scheduled.each { |h| h.call(*@parents.map(&:returned_value)) }
         @on_scheduled = []
       else
-        raise "Internal error! Trying to call handlers for #{state.inspect}!"
+        raise Scarpe::InternalError, "Internal error! Trying to call handlers for #{state.inspect}!"
       end
     end
 
@@ -367,7 +367,7 @@ class Scarpe
     end
 
     def call_executor
-      raise("Internal error! Should not call_executor with no executor!") unless @executor
+      raise(Scarpe::InternalError, "Internal error! Should not call_executor with no executor!") unless @executor
 
       begin
         result = @executor.call(*@parents.map(&:returned_value))
@@ -389,7 +389,7 @@ class Scarpe
     # @return [Scarpe::Promise] self
     def on_fulfilled(&handler)
       unless handler
-        raise "You must pass a block to on_fulfilled!"
+        raise Shoes::Errors::InvalidAttributeValueError, "You must pass a block to on_fulfilled!"
       end
 
       case @state
@@ -411,7 +411,7 @@ class Scarpe
     # @return [Scarpe::Promise] self
     def on_rejected(&handler)
       unless handler
-        raise "You must pass a block to on_rejected!"
+        raise Shoes::Errors::InvalidAttributeValueError, "You must pass a block to on_rejected!"
       end
 
       case @state
@@ -434,7 +434,7 @@ class Scarpe
     # @return [Scarpe::Promise] self
     def on_scheduled(&handler)
       unless handler
-        raise "You must pass a block to on_scheduled!"
+        raise Shoes::Errors::InvalidAttributeValueError, "You must pass a block to on_scheduled!"
       end
 
       # Add a pending handler or call it now

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

@@ -14,7 +14,7 @@ module Scarpe::Components
     # @return <void>
     def add_segment_type(type, handler)
       if segment_type_hash.key?(type)
-        raise "Segment type #{type.inspect} already exists!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Segment type #{type.inspect} already exists!"
       end
 
       segment_type_hash[type] = handler
@@ -22,11 +22,23 @@ module Scarpe::Components
 
     # Return an Array of segment type labels, such as "code" and "app_test".
     #
-    # @return Array<String> the segment type labels
+    # @return [Array<String>] the segment type labels
     def segment_types
       segment_type_hash.keys
     end
 
+    # Normally a Shoes application will want to keep the default segment types,
+    # which allow loading a Shoes app and running a test inside. But sometimes
+    # the default handler will be wrong and a library will want to register
+    # its own "shoes" and "app_test" segment handlers, or not have any at all.
+    # For those applications, it makes sense to clear all segment types before
+    # registering its own.
+    #
+    # @return <void>
+    def remove_all_segment_types!
+      @segment_type_hash = {}
+    end
+
     # Load a .sca file with an optional YAML frontmatter prefix and
     # multiple file sections which can be treated differently.
     #
@@ -38,7 +50,7 @@ module Scarpe::Components
     # @param path [String] the file or directory to treat as a Scarpe app
     # @return [Boolean] return true if the file is loaded as a segmented Scarpe app file
     def call(path)
-      return false unless path.end_with?(".scas")
+      return false unless path.end_with?(".scas") || path.end_with?(".sspec")
 
       file_load(path)
       true
@@ -55,14 +67,12 @@ module Scarpe::Components
       @after_load << block
     end
 
-    private
-
-    def gen_name(segmap)
+    def self.gen_name(segmap)
       ctr = (1..10_000).detect { |i| !segmap.key?("%5d" % i) }
       "%5d" % ctr
     end
 
-    def tokenize_segments(contents)
+    def self.front_matter_and_segments_from_file(contents)
       require "yaml" # Only load when needed
       require "English"
 
@@ -90,12 +100,16 @@ module Scarpe::Components
       segments.each do |segment|
         if segment =~ /\A-* +(.*?)\n/
           # named segment with separator
-          segmap[::Regexp.last_match(1)] = ::Regexp.last_match.post_match
+          name = ::Regexp.last_match(1)
+
+          raise("Duplicate segment name: #{name.inspect}!") if segmap.key?(name)
+
+          segmap[name] = ::Regexp.last_match.post_match
         elsif segment =~ /\A-* *\n/
           # unnamed segment with separator
           segmap[gen_name(segmap)] = ::Regexp.last_match.post_match
         else
-          raise "Internal error when parsing segments in segmented app file! seg: #{segment.inspect}"
+          raise Scarpe::InternalError, "Internal error when parsing segments in segmented app file! seg: #{segment.inspect}"
         end
       end
 
@@ -105,19 +119,19 @@ module Scarpe::Components
     def file_load(path)
       contents = File.read(path)
 
-      front_matter, segmap = tokenize_segments(contents)
+      front_matter, segmap = self.class.front_matter_and_segments_from_file(contents)
 
       if segmap.empty?
-        raise "Illegal segmented Scarpe file: must have at least one code segment, not just front matter!"
+        raise Scarpe::FileContentError, "Illegal segmented Scarpe file: must have at least one code segment, not just front matter!"
       end
 
       if front_matter[:segments]
         if front_matter[:segments].size != segmap.size
-          raise "Number of front matter :segments must equal number of file segments!"
+          raise Scarpe::FileContentError, "Number of front matter :segments must equal number of file segments!"
         end
       else
         if segmap.size > 2
-          raise "Segmented files with more than two segments have to specify what they're for!"
+          raise Scarpe::FileContentError, "Segmented files with more than two segments have to specify what they're for!"
         end
 
         # Set to default of shoes code only or shoes code and app test code.
@@ -132,7 +146,7 @@ module Scarpe::Components
       tf_specs = []
       front_matter[:segments].each.with_index do |seg_type, idx|
         unless sth.key?(seg_type)
-          raise "Unrecognized segment type #{seg_type.inspect}! No matching segment type available!"
+          raise Scarpe::FileContentError, "Unrecognized segment type #{seg_type.inspect}! No matching segment type available!"
         end
 
         tf_specs << ["scarpe_#{seg_type}_segment_contents", sv[idx]]
@@ -147,18 +161,23 @@ module Scarpe::Components
         # Need to call @after_load hooks while tempfiles still exist
         if @after_load && !@after_load.empty?
           @after_load.each(&:call)
+          @after_load = []
         end
       end
     end
 
     # The hash of segment type labels mapped to handlers which will be called.
-    # Normal client code shouldn't ever call this.
+    # This could be called by a display service, a test framework or similar
+    # code that wants to define a non-Scarpe-standard file format.
     #
-    # @return Hash<String, Object> the name/handler pairs
+    # @return [Hash<String, Object>] the name/handler pairs
     def segment_type_hash
       @segment_handlers ||= {
         "shoes" => proc { |seg_file| after_load { load seg_file } },
-        "app_test" => proc { |seg_file| ENV["SCARPE_APP_TEST"] = seg_file },
+        "app_test" => proc do |seg_file|
+          ENV["SHOES_SPEC_TEST"] = seg_file
+          ENV["SHOES_MINITEST_EXPORT_FILE"] = "sspec.json"
+        end,
       }
     end
   end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Scarpe; module Components; end; end
+module Scarpe::Components::StringHelpers
+  # Cut down from Rails camelize
+  def self.camelize(string)
+    string = string.sub(/^[a-z\d]*/, &:capitalize)
+    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{::Regexp.last_match(1)}#{::Regexp.last_match(2).capitalize}" }
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+# In Italian, tiranti are bootstraps -- the literal pull-on-a-boot kind, not a step to something better.
+# Tiranti.rb builds on calzini.rb, but renders a Bootstrap-decorated version of the HTML output.
+# You would ordinarily set either Calzini or Tiranti as the top-level HTML renderer, not both.
+# You'll include both if you use Tiranti, because it falls back to Calzini for a lot of its rendering.
+
+require "scarpe/components/calzini"
+
+# The Tiranti module expects to be included by a class defining
+# the following methods:
+#
+#     * html_id - the HTML ID for the specific rendered DOM object
+#     * handler_js_code(event_name) - the JS handler code for this DOM object and event name
+#     * (optional) display_properties - the display properties for this object, unless overridden in render()
+module Scarpe::Components::Tiranti
+  include Scarpe::Components::Calzini
+  extend self
+
+  # Currently we're using Bootswatch 5
+  BOOTSWATCH_THEMES = [
+    "cerulean",
+    "cosmo",
+    "cyborg",
+    "darkly",
+    "flatly",
+    "journal",
+    "litera",
+    "lumen",
+    "lux",
+    "materia",
+    "minty",
+    "morph",
+    "pulse",
+    "quartz",
+    "sandstone",
+    "simplex",
+    "sketchy",
+    "slate",
+    "solar",
+    "spacelab",
+    "superhero",
+    "united",
+    "vapor",
+    "yeti",
+    "zephyr",
+  ]
+
+  BOOTSWATCH_THEME = ENV["SCARPE_BOOTSTRAP_THEME"] || "sketchy"
+
+  def empty_page_element
+    <<~HTML
+      <html>
+        <head id='head-wvroot'>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+          <link rel="stylesheet" href="https://bootswatch.com/5/#{BOOTSWATCH_THEME}/bootstrap.css">
+          <link rel="stylesheet" href="https://bootswatch.com/_vendor/bootstrap-icons/font/bootstrap-icons.min.css">
+          <style id='style-wvroot'>
+            /** Style resets **/
+            body {
+              height: 100%;
+              overflow: hidden;
+            }
+          </style>
+        </head>
+        <body id='body-wvroot'>
+          <div id='wrapper-wvroot'></div>
+
+          <script src="https://bootswatch.com/_vendor/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
+        </body>
+      </html>
+    HTML
+  end
+
+  # def render_stack
+  # end
+  # def render_flow
+  # end
+
+  # How do we want to handle theme-specific colours and primary/secondary buttons in Bootstrap?
+  # "Disabled" could be checked in properties. Is there any way we can/should use "outline" buttons?
+  def button_element(props)
+    HTML.render do |h|
+      h.button(id: html_id, type: "button", class: "btn btn-primary", onclick: handler_js_code("click"), style: button_style(props)) 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
+
+  public
+
+  def alert_element(props)
+    onclick = handler_js_code(props["event_name"] || "click")
+
+    HTML.render do |h|
+      h.div(id: html_id, class: "modal", tabindex: -1, role: "dialog", style: alert_overlay_style(props)) do
+        h.div(class: "modal-dialog", role: "document") do
+          h.div(class: "modal-content", style: alert_modal_style) do
+            h.div(class: "modal-header") do
+              h.h5(class: "modal-title") { "Alert" }
+              h.button(type: "button", class: "close", data_dismiss: "modal", aria_label: "Close") do
+                h.span(aria_hidden: "true") { "&times;" }
+              end
+            end
+            h.div(class: "modal-body") do
+              h.p { props["text"] }
+            end
+            h.div(class: "modal-footer") do
+              h.button(type: "button", onclick:, class: "btn btn-primary") { "OK" }
+              #h.button(type: "button", class: "btn btn-secondary") { "Close" }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def check_element(props)
+    HTML.render do |h|
+      h.div class: "form-check" do
+        h.input type: :checkbox,
+          id: html_id,
+          class: "form-check-input",
+          onclick: handler_js_code("click"),
+          value: props["text"],
+          checked: props["checked"],
+          style: drawable_style(props)
+      end
+    end
+  end
+
+  def progress_element(props)
+    HTML.render do |h|
+      h.div(class: "progress", style: "width: 90%") do
+        pct = "%.1f" % ((props["fraction"] || 0.0) * 100.0)
+        h.div(
+          class: "progress-bar progress-bar-striped progress-bar-animated",
+          role: "progressbar",
+          "aria-valuenow": pct,
+          "aria-valuemin": 0,
+          "aria-valuemax": 100,
+          style: "width: #{pct}%",
+        )
+      end
+    end
+  end
+
+  # para_element is a bit of a hard one, since it does not-entirely-trivial
+  # mapping between display objects and IDs. But we don't want Calzini
+  # messing with the display service or display objects.
+  def para_element(props, &block)
+    tag, opts = para_elt_and_opts(props)
+
+    HTML.render do |h|
+      h.send(tag, **opts, &block)
+    end
+  end
+
+  private
+
+  ELT_AND_SIZE = {
+    inscription: [:p, 10],
+    ins: [:p, 10],
+    para: [:p, 12],
+    caption: [:p, 14],
+    tagline: [:p, 18],
+    subtitle: [:h3, 26],
+    title: [:h2, 34],
+    banner: [:h1, 48],
+  }.freeze
+
+  def para_elt_and_opts(props)
+    elt, size = para_elt_and_size(props)
+    size = dimensions_length(size)
+
+    para_style = drawable_style(props).merge({
+      color: rgb_to_hex(props["stroke"]),
+      "font-size": para_font_size(props),
+      "font-family": props["font"],
+    }.compact)
+
+    opts = (props["html_attributes"] || {}).merge(id: html_id, style: para_style)
+
+    [elt, opts]
+  end
+
+  def para_elt_and_size(props)
+    return [:p, nil] unless props["size"]
+
+    ps = props["size"].to_s.to_sym
+    if ELT_AND_SIZE.key?(ps)
+      ELT_AND_SIZE[ps]
+    else
+      sz = props["size"].to_i
+      if sz > 18
+        [:h2, sz]
+      else
+        [:p, sz]
+      end
+    end
+  end
+end

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

@@ -125,7 +125,7 @@ module Scarpe::Test::LoggedTest
   def log_config_for_test
     {
       "default" => ["debug", "logger/test_failure_#{file_id}.log"],
-      "DisplayService" => ["debug", "logger/test_failure_events_#{file_id}.log"],
+      "DisplayService" => ["debug", "logger/test_failure_display_service_#{file_id}.log"],
     }.merge(@additional_log_config || {})
   end
 
@@ -150,8 +150,8 @@ module Scarpe::Test::LoggedTest
     return if ALREADY_SET_UP_LOGGED_TEST_FAILURES[:setup]
 
     log_dir = self.class.logger_dir
-    raise("Must set logger directory!") unless log_dir
-    raise("Can't find logger directory!") unless File.directory?(log_dir)
+    raise(Scarpe::MustOverrideMethod, "Must set logger directory!") unless log_dir
+    raise(Scarpe::NoSuchFile, "Can't find logger directory!") unless File.directory?(log_dir)
 
     ALREADY_SET_UP_LOGGED_TEST_FAILURES[:setup] = true
     # Delete stale test failures, if any, before starting the first failure-logged test
@@ -181,11 +181,11 @@ module Scarpe::Test::LoggedTest
     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}!"
+      raise Shoes::Errors::InvalidAttributeValueError, "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!"
+      raise Scarpe::DuplicateFileError, "Duplicate test file #{out_loc.inspect}? This file should *not* already exist!"
     end
 
     out_loc
@@ -215,3 +215,43 @@ module Scarpe::Test::LoggedTest
     end
   end
 end
+
+module Scarpe::Test::HTMLAssertions
+  # 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::Components::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::Components::HTML.render do |h|
+      h.public_send(expected_tag, opts, &block)
+    end
+
+    assert_equal expected_html, actual_html
+  end
+
+  # Assert that `actual_html` includes `expected_tag` with `opts`.
+  # This uses Scarpe's HTML tag-based renderer to render the tag and options
+  # into text, and valides that the full HTML contains that tag.
+  #
+  # @see Scarpe::Components::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_contains_html(actual_html, expected_tag, **opts, &block)
+    expected_html = Scarpe::Components::HTML.render do |h|
+      h.public_send(expected_tag, opts, &block)
+    end
+
+    assert actual_html.include?(expected_html), "Expected #{actual_html.inspect} to include #{expected_html.inspect}!"
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
+module Scarpe
   module Components
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end

data/scarpe-components/test/calzini/test_calzini_alert.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class TestCalziniAlert < Minitest::Test
+  def setup
+    @calzini = CalziniRenderer.new
+  end
+
+  def test_alert_defaults
+    assert_equal %{<div id="elt-1" 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">} +
+      %{<div style="min-width:200px;min-height:50px;padding:10px;display:flex;background:#fefefe;} +
+      %{flex-direction:column;justify-content:space-between;border-radius:9px"><div></div>} +
+      %{<button onclick="handle('click')">OK</button></div></div>},
+      @calzini.render("alert", {})
+  end
+
+  def test_alert_hidden
+    # A hidden alert is display:none for the outer div
+    assert_equal %{<div id="elt-1" style="position:fixed;top:0;left:0;width:100%;height:100%;} +
+      %{overflow:auto;z-index:1;background:rgba(0,0,0,0.4);display:none;align-items:center;} +
+      %{justify-content:center">} +
+      %{<div style="min-width:200px;min-height:50px;padding:10px;display:flex;background:#fefefe;} +
+      %{flex-direction:column;justify-content:space-between;border-radius:9px"><div></div>} +
+      %{<button onclick="handle('click')">OK</button></div></div>},
+      @calzini.render("alert", { "hidden" => true })
+  end
+end