scarpe-components 0.2.2 → 0.3.0

data/lib/scarpe/components/minitest_result.rb

@@ -0,0 +1,86 @@
+# 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 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/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/lib/scarpe/components/print_logger.rb

@@ -3,30 +3,34 @@
 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
+    end
+
     def initialize(component_name)
       @comp_name = component_name
     end
 
     def error(msg)
-      puts "#{@comp_name} error: #{msg}"
+      puts "#{@comp_name} error: #{msg}" unless PrintLogger.silence
     end
 
     def warn(msg)
-      puts "#{@comp_name} warn: #{msg}"
+      puts "#{@comp_name} warn: #{msg}" unless PrintLogger.silence
     end
 
     def debug(msg)
-      puts "#{@comp_name} debug: #{msg}"
+      puts "#{@comp_name} debug: #{msg}" unless PrintLogger.silence
     end
 
     def info(msg)
-      puts "#{@comp_name} info: #{msg}"
+      puts "#{@comp_name} info: #{msg}" unless PrintLogger.silence
     end
   end
 

data/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/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/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/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