scarpe 0.2.2 → 0.4.0

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "json"
+#require "json/add/exception"
+
+module Scarpe; module Components; end; end
+
+# A MinitestResult imports a JSON file from a minitest_export_reporter.
+# But instead of creating a Minitest::Test to report the result, the
+# MinitestResult is just a queryable Ruby object.
+#
+# MinitestResult assumes there will be only one class and one method
+# in the JSON, which is true for Scarpe but not necessarily in general.
+class Scarpe::Components::MinitestResult
+  attr_reader :assertions
+  attr_reader :method_name
+  attr_reader :class_name
+
+  def initialize(filename)
+    data = JSON.parse File.read(filename)
+
+    unless data.size == 1
+      # We would want a different interface to support this in general. For now we don't
+      # need it to work in general.
+      raise "Scarpe::Components::MinitestResult only supports one class and method in results!"
+    end
+
+    item = data.first
+
+    @assertions = item["assertions"]
+    @method_name = item["name"]
+    @class_name = item["klass"]
+    @time = item["time"]
+    @metadata = item.key?("metadata") ? item["metadata"]: {}
+
+    @skip = false
+    @exceptions = []
+    @failures = []
+    item["failures"].each do |f|
+      # JSON.parse ignores json_class and won't create an arbitrary object. That's good
+      # because Minitest::UnexpectedError seems to load in a bad way, so we don't want
+      # it to auto-instantiate.
+      d = JSON.parse f[1]
+      msg = d["m"]
+      case d["json_class"]
+      when "Minitest::UnexpectedError"
+        @exceptions << msg
+      when "Minitest::Skip"
+        @skip = msg
+      when "Minitest::Assertion"
+        @failures << msg
+      else
+        raise Scarpe::InternalError, "Didn't expect type #{t.inspect} as exception type when importing Minitest tests!"
+      end
+    end
+  end
+
+  def one_word_result
+    return "error" if self.error?
+    return "fail" if self.fail?
+    return "skip" if self.skip?
+    "success"
+  end
+
+  def result_and_message
+    return ["error", error_message] if self.error?
+    return ["fail", fail_message] if self.fail?
+    return ["skip", skip_message] if self.skip?
+    ["success", "OK"]
+  end
+
+  def console_summary
+    return "Error(s): #{@exceptions.inspect}" if self.error?
+    return "Failure: #{@failures.inspect}" if self.fail?
+    return "Skip: #{skip_message.inspect}" if self.skip?
+    "Success!"
+  end
+
+  def check(expect_result: :success, min_asserts: nil, max_asserts: nil)
+    unless [:error, :fail, :skip, :success].include?(expect_result)
+      raise Scarpe::InternalError, "Expected test result should be one of [:success, :fail, :error, :skip]!"
+    end
+
+    res, msg = result_and_message
+    if expect_result.to_s != res
+      return [false, "Expected #{expect_result} but got #{res}: #{msg}!"]
+    end
+
+    if min_asserts && @assertions < min_asserts
+      return [false, "Expected success with at least #{min_asserts} assertions but found only #{@assertions}!"]
+    end
+    if max_asserts && @assertions > max_asserts
+      return [false, "Expected success with no more than #{max_asserts} assertions but found only #{@assertions}!"]
+    end
+
+    [true, ""]
+  end
+
+  def error?
+    !@exceptions.empty?
+  end
+
+  def fail?
+    !@failures.empty?
+  end
+
+  def skip?
+    @skip ? true : false
+  end
+
+  def passed?
+    @exceptions.empty? && @failures.empty? && !@skip
+  end
+
+  def error_message
+    @exceptions[0]
+  end
+
+  def fail_message
+    @failures[0]
+  end
+
+  def skip_message
+    @skip
+  end
+end

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

@@ -7,9 +7,9 @@ require "shoes/log"
 
 # Requires the logging gem
 
-class Scarpe; end
+module Scarpe; end
 module Scarpe::Components; end
-class Scarpe
+module Scarpe
   class Components::ModularLogImpl
     include Shoes::Log # for constants
 
@@ -32,7 +32,7 @@ class Scarpe
       when "fatal"
         :fatal
       else
-        raise "Don't know how to treat #{data.inspect} as a logger severity!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to treat #{data.inspect} as a logger severity!"
       end
     end
 
@@ -45,7 +45,7 @@ class Scarpe
       when String
         Logging.appenders.file data, layout: @custom_log_layout
       else
-        raise "Don't know how to convert #{data.inspect} to an appender!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to convert #{data.inspect} to an appender!"
       end
     end
 
@@ -64,7 +64,7 @@ class Scarpe
 
         logger.level = name_to_severity(level)
       else
-        raise "Don't know how to use #{data.inspect} to specify a logger!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to use #{data.inspect} to specify a logger!"
       end
     end
 

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

@@ -3,29 +3,48 @@
 require "shoes/log"
 require "json"
 
-class Scarpe; end
+module Scarpe; end
 module Scarpe::Components; end
 class Scarpe::Components::PrintLogImpl
   include Shoes::Log # for constants
 
   class PrintLogger
+    class << self
+      attr_accessor :silence
+      attr_accessor :min_level
+    end
+
+    LEVELS = {
+      :never => 1000,
+      :error => 4,
+      :warn => 3,
+      :info => 2,
+      :debug => 1,
+      :always => -1,
+    }
+    PrintLogger.min_level = LEVELS[:always]
+
     def initialize(component_name)
       @comp_name = component_name
     end
 
     def error(msg)
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:error]
       puts "#{@comp_name} error: #{msg}"
     end
 
     def warn(msg)
-      puts "#{@comp_name} warn: #{msg}"
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:warn]
+      puts "#{@comp_name} warn: #{msg}" unless PrintLogger.silence
     end
 
     def debug(msg)
-      puts "#{@comp_name} debug: #{msg}"
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:debug]
+      puts "#{@comp_name} debug: #{msg}" unless PrintLogger.silence
     end
 
     def info(msg)
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:info]
       puts "#{@comp_name} info: #{msg}"
     end
   end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# These can be used for unit tests, but also more generally.
+
+require_relative "file_helpers"
+
+module Scarpe::Components::ProcessHelpers
+  include Scarpe::Components::FileHelpers
+
+  # Run the command and capture its stdout and stderr output, and whether
+  # it succeeded or failed. Return after the command has completed.
+  # The awkward name is because this is normally a component of another
+  # library. Ordinarily you'd want to raise a library-specific exception
+  # on failure, print a library-specific message or delimiter, or otherwise
+  # handle success and failure. This is too general as-is.
+  #
+  # @param cmd [String,Array<String>] the command to run in Kernel#spawn format
+  # @return [Array(String,String,bool)] the stdout output, stderr output and success/failure of the command in a 3-element Array
+  def run_out_err_result(cmd)
+    out_str = ""
+    err_str = ""
+    success = nil
+
+    with_tempfiles([
+      ["scarpe_cmd_stdout", ""],
+      ["scarpe_cmd_stderr", ""],
+    ]) do |stdout_file, stderr_file|
+      pid = Kernel.spawn(cmd, out: stdout_file, err: stderr_file)
+      Process.wait(pid)
+      success = $?.success?
+      out_str = File.read stdout_file
+      err_str = File.read stderr_file
+    end
+
+    [out_str, err_str, success]
+  end
+end

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,167 @@
+# 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 can set Tiranti as your HTML renderer and you'll get Bootstrap versions of all the drawables.
+# Tiranti requires Calzini's files 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 downloaded from https://bootswatch.com/5/THEME_NAME/bootstrap.css
+
+  def empty_page_element(theme: ENV["SCARPE_BOOTSTRAP_THEME"] || "sketchy")
+    comp_dir = File.expand_path("#{__dir__}/../../..")
+    bootstrap_js_url = Scarpe::Webview.asset_server.asset_url("#{comp_dir}/assets/bootstrap-themes/bootstrap.bundle.min.js", url_type: :asset)
+    theme_url = Scarpe::Webview.asset_server.asset_url("#{comp_dir}/assets/bootstrap-themes/bootstrap-#{theme}.css", url_type: :asset)
+    icons_url = Scarpe::Webview.asset_server.asset_url("#{comp_dir}/assets/bootstrap-themes/bootstrap-icons.min.css", url_type: :asset)
+
+    <<~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=#{theme_url.inspect}>
+          <link rel="stylesheet" href=#{icons_url.inspect}>
+          <style id='style-wvroot'>
+            /** Style resets **/
+            body {
+              height: 100%;
+              overflow: hidden;
+            }
+          </style>
+        </head>
+        <body id='body-wvroot'>
+          <div id='wrapper-wvroot'></div>
+
+          <script src=#{bootstrap_js_url}></script>
+        </body>
+      </html>
+    HTML
+  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: props["html_class"] ? "btn #{props["html_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"]
+
+    # How do we want to handle font size?
+    styles[:"font-size"] = props["font_size"] if props["font_size"]
+    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)
+    progress_style = drawable_style(props).merge({
+      width: "90%",
+    })
+    HTML.render do |h|
+      h.div(id: html_id, class: "progress", style: progress_style) 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
+
+  def para_element(props, &block)
+    ps, _extra = para_style(props)
+    size = ps[:"font-size"] || "12px"
+    size_int = size.to_i # Mostly useful if it's something like "12px"
+    if size.include?("calc") || size.end_with?("%")
+      # Very big text!
+      props["tag"] = "h2"
+    elsif size_int >= 48
+      props["tag"] = "h1"
+    elsif size_int >= 34
+      props["tag"] = "h2"
+    elsif size_int >= 26
+      props["tag"] = "h3"
+    else
+      props["tag"] = "p"
+    end
+
+    super
+  end
+end