scarpe-components 0.3.0 → 0.4.0

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

@@ -16,20 +16,20 @@ module Scarpe::Components::Calzini
     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"] }
+      h.textarea(id: html_id, oninput: oninput,onmouseover: handler_js_code("hover"), style: edit_box_style(props),title: props["tooltip"]) { 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))
+      h.input(id: html_id, oninput: oninput, onmouseover: handler_js_code("hover"), value: props["text"], style: edit_line_style(props),title: props["tooltip"])
     end
   end
 
   def image_element(props)
-    style = image_style(props)
+    style = drawable_style(props)
 
     if props["click"]
       HTML.render do |h|
@@ -111,26 +111,16 @@ module Scarpe::Components::Calzini
     drawable_style(props).merge({
       height: dimensions_length(props["height"]),
       width: dimensions_length(props["width"]),
+      font: props["font"]? parse_font(props) : nil
     }.compact)
   end
 
   def edit_line_style(props)
     styles = drawable_style(props)
 
+    styles[:font] = props["font"]? parse_font(props) : nil
     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[:color] =  rgb_to_hex(props["stroke"])
 
     styles
   end

data/lib/scarpe/components/calzini/para.rb

@@ -1,27 +1,166 @@
 # frozen_string_literal: true
 
 module Scarpe::Components::Calzini
-  # 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)
+    # Align requires an extra wrapping div.
+
+    # Stacking strikethrough with underline requires multiple elements.
+    # We handle this by making strikethrough part of the main element,
+    # but using an extra wrapping element for underline.
+
+    tag = props["tag"] || "p"
+
+    para_styles, extra_styles = para_style(props)
+
     HTML.render do |h|
-      h.p(**para_options(props), &block)
+      if extra_styles.empty?
+        h.send(tag, id: html_id, style: para_styles, &block)
+      else
+        h.div(id: html_id, style: extra_styles.merge(width: "100%")) do
+          h.send(tag, style: para_styles, &block)
+        end
+      end
     end
   end
 
   private
 
-  def para_options(props)
-    (props["html_attributes"] || {}).merge(id: html_id, style: para_style(props))
+  def para_style(props)
+  
+    ds = drawable_style(props)
+    s1, s2 = text_specific_styles(props)
+    [ds.merge(s1), s2]
   end
 
-  def para_style(props)
-    drawable_style(props).merge({
-      color: rgb_to_hex(props["stroke"]),
+  def text_specific_styles(props)
+    # Shoes3 allows align: right on TextDrawables like em(), but it does
+    # nothing. We can ignore it or (maybe in future?) warn if we see it.
+
+    strikethrough = props["strikethrough"]
+    strikethrough = nil if strikethrough == "" || strikethrough == "none"
+    s1 = {
+      "font-variant": props["font_variant"],
+      "color": rgb_to_hex(props["stroke"]),
+      "background-color": rgb_to_hex(props["fill"]),
       "font-size": para_font_size(props),
-      "font-family": props["font"],
-    }.compact)
+      "font-family": props["family"],
+      "text-decoration-line": strikethrough ? "line-through" : nil,
+      "text-decoration-color": props["strikecolor"] ? rgb_to_hex(props["strikecolor"]) : nil,
+      "font-weight": props["font_weight"]? props["font_weight"] : nil,
+      :'font-style' => case props["emphasis"]
+            when "normal"
+                "normal"
+            when "oblique"
+                "oblique"
+            when "italic"
+                "italic"
+            else
+                nil
+            end,
+      :'letter-spacing' => props["kerning"] ? "#{props["kerning"]}px" : nil,
+      :'vertical-align' => props["rise"] ? "#{props["rise"]}px" : nil
+    }.compact
+
+    s2 = {}
+    if props["align"] && props["align"] != ""
+      s2[:"text-align"] = props["align"]
+    end
+
+    unless [nil, "none"].include?(props["underline"])
+      undercolor = rgb_to_hex props["undercolor"]
+      s2["text-decoration-color"] = undercolor if undercolor
+    end
+
+    # [nil, "none", "single", "double", "low", "error"]
+    case props["underline"]
+    when nil, "none"
+      # Do nothing
+    when "single"
+      s2["text-decoration-line"] = "underline"
+    when "double"
+      s2["text-decoration-line"] = "underline"
+      s2["text-decoration-style"] = "double"
+    when "error"
+      s2["text-decoration-line"] = "underline"
+      s2["text-decoration-style"] = "wavy"
+    when "low"
+      s2["text-decoration-line"] = "underline"
+      s2["text-underline-offset"] = "0.3rem"
+    else
+      # This should normally be unreachable
+      raise Shoes::Errors::InvalidAttributeValueError, "Unexpected underline type #{props["underline"].inspect}!"
+    end
+
+    [s1, s2]
+  end
+
+
+  def parse_font(props)
+
+    def contains_number?(str)
+      !!(str =~ /\d/)
+    end
+    def contains_only_numbers?(string)
+      /^\d+\z/ =~ string
+    end
+  
+
+    input = props["font"]
+    regex = /\s+(?=(?:[^']*'[^']*')*[^']*$)(?![^']*,[^']*')/
+    result = input.split(regex)
+   
+    fs = "normal"
+    fv = "normal"
+    fw = "normal"
+    fss = "medium"
+    ff = "Arial"
+    
+    fos = ["italic", "oblique"]
+    fov = ["small-caps", "initial", "inherit"]
+    fow = ["bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"]
+    foss = ["xx-small", "x-small", "small","large", "x-large", "xx-large", "smaller", "larger"]
+    
+    result.each do |i|
+      if fos.include?(i)
+        fs = i
+        next
+      elsif fov.include?(i)
+        fv = i
+        next
+      elsif fow.include?(i)
+        fw = i
+        next
+      elsif foss.include?(i)
+        fss = i
+        next
+      else
+        if contains_number?(i)
+
+          if contains_only_numbers?(i)
+              fss = i + "px"
+          else
+              fss = i
+          end
+
+        elsif i != "normal" && i != "medium" && i.strip != ""
+
+          if ff == "Arial"
+
+            ff = i
+
+          else
+            
+            ff = ff+ i
+
+          end
+        end
+      end
+      
+    end
+    
+
+    "#{fs} #{fv} #{fw} #{fss} #{ff}"
+    
   end
 
   def para_font_size(props)
@@ -32,4 +171,67 @@ module Scarpe::Components::Calzini
 
     dimensions_length(font_size)
   end
+
+  public
+
+  # The text element is used to render the equivalent of Shoes cText,
+  # which includes em, strong, span, link and so on. We use a
+  # "content" tag for it which alternates plaintext with a hash of
+  # properties.
+  def text_drawable_element(prop_array)
+    out = String.new # Need unfrozen string
+
+    # Each item should be a String or a property Hash
+    # :items, :html_id, :tag, :props
+    prop_array.each do |item|
+      if item.is_a?(String)
+        out << item.gsub("\n", "<br/>")
+      else
+        s, extra = text_drawable_style(item[:props])
+        out << HTML.render do |h|
+          if extra.empty?
+            h.send(
+              item[:tag] || "span",
+              class: "id_#{item[:html_id]}",
+              style: s,
+              **text_drawable_attrs(item[:props])
+            ) do
+              text_drawable_element(item[:items])
+            end
+          else
+            h.span(class: "id_#{item[:html_id]}", style: extra) do
+              h.send(
+                item[:tag] || "span",
+                class: "id_#{item[:html_id]}",
+                style: s,
+                **text_drawable_attrs(item[:props])
+              ) do
+                text_drawable_element(item[:items])
+              end
+            end
+          end
+        end
+      end
+    end
+
+    out
+  end
+
+  private
+
+  def text_drawable_attrs(props)
+    {
+      # These properties will normally only be set by link()
+      href: props["click"],
+      onclick: props["has_block"] ? handler_js_code("click") : nil,
+    }.compact
+  end
+
+  def text_drawable_style(props)
+    s, extra_s = text_specific_styles(props)
+
+    # Add hover styles, perhaps with CSS pseudo-class
+
+    [drawable_style(props).merge(s), extra_s]
+  end
 end

data/lib/scarpe/components/calzini/slots.rb

@@ -3,27 +3,30 @@
 module Scarpe::Components::Calzini
   def slot_element(props, &block)
     HTML.render do |h|
-      h.div((props["html_attributes"] || {}).merge(id: html_id, style: slot_style(props)), &block)
+      h.div((props["html_attributes"] || {}).merge(id: html_id, style: slot_style(props))) do
+        h.div(style: { height: "100%", width: "100%" }, &block)
+      end
     end
   end
 
   def flow_element(props, &block)
     HTML.render do |h|
-      h.div((props["html_attributes"] || {}).merge(id: html_id, style: flow_style(props)), &block)
+      h.div((props["html_attributes"] || {}).merge(id: html_id, style: flow_style(props))) do
+        h.div(style: { height: "100%", width: "100%", position: "relative" }, &block)
+      end
     end
   end
 
   def stack_element(props, &block)
     HTML.render do |h|
-      h.div((props["html_attributes"] || {}).merge(id: html_id, style: stack_style(props)), &block)
+      h.div((props["html_attributes"] || {}).merge(id: html_id, style: stack_style(props))) do
+        h.div(style: { height: "100%", width: "100%", position: "relative" }, &block)
+      end
     end
   end
 
   def documentroot_element(props, &block)
-    HTML.render do |h|
-      # DocumentRoot rendering intentionally uses flow styles.
-      h.div((props["html_attributes"] || {}).merge(id: html_id, style: flow_style(props)), &block)
-    end
+    flow_element(props, &block)
   end
 
   private
@@ -32,12 +35,14 @@ module Scarpe::Components::Calzini
     styles = drawable_style(props)
     styles = background_style(props, styles)
     styles = border_style(props, styles)
-    styles = spacing_styles_for_attr("margin", props, styles)
-    styles = spacing_styles_for_attr("padding", props, styles)
 
     styles[:width] = dimensions_length(props["width"]) if props["width"]
     styles[:height] = dimensions_length(props["height"]) if props["height"]
 
+    ## A new slot defines a new coordinate system, so absolutely-positioned children
+    ## are relative to it. But that's going to need a lot of testing and Shoes3 comparison.
+    #styles[:position] = "relative"
+
     styles
   end
 
@@ -101,55 +106,4 @@ module Scarpe::Components::Calzini
 
     styles.merge(background: color)
   end
-
-  SPACING_DIRECTIONS = [:left, :right, :top, :bottom]
-
-  # We extract the appropriate margin and padding from the margin and
-  # padding properties. If there are no margin or padding properties,
-  # we fall back to props["options"] margin or padding, if it exists.
-  #
-  # Margin or padding (in either props or props["options"]) can be
-  # a Hash with directions as keys, or an Array of left/right/top/bottom,
-  # or a constant, which means all four are that constant. You can
-  # also specify a "margin" plus "margin-top" which is constant but
-  # margin-top is overridden, or similar.
-  #
-  # If any margin or padding property exists in props then we don't
-  # check props["options"].
-  def spacing_styles_for_attr(attr, props, styles, with_options: true)
-    spacing_styles = {}
-
-    case props[attr]
-    when Hash
-      props[attr].each do |dir, value|
-        spacing_styles[:"#{attr}-#{dir}"] = dimensions_length value
-      end
-    when Array
-      SPACING_DIRECTIONS.zip(props[attr]).to_h.compact.each do |dir, value|
-        spacing_styles[:"#{attr}-#{dir}"] = dimensions_length(value)
-      end
-    when String, Numeric
-      spacing_styles[attr.to_sym] = dimensions_length(props[attr])
-    end
-
-    SPACING_DIRECTIONS.each do |dir|
-      if props["#{attr}_#{dir}"]
-        spacing_styles[:"#{attr}-#{dir}"] = dimensions_length props["#{attr}_#{dir}"]
-      end
-    end
-
-    unless spacing_styles.empty?
-      return styles.merge(spacing_styles)
-    end
-
-    # We should see if there are spacing properties in props["options"],
-    # unless we're currently doing that.
-    if with_options && props["options"]
-      spacing_styles = spacing_styles_for_attr(attr, props["options"], {}, with_options: false)
-      styles.merge spacing_styles
-    else
-      # No "options" or we already checked it? Return the styles we were given.
-      styles
-    end
-  end
 end

data/lib/scarpe/components/calzini.rb

@@ -68,6 +68,10 @@ module Scarpe::Components::Calzini
             p {
               margin: 0;
             }
+            #wrapper-wvroot {
+              height: 100%;
+              width: 100%;
+            }
           </style>
         </head>
         <body id='body-wvroot'>
@@ -110,13 +114,96 @@ module Scarpe::Components::Calzini
     if props["hidden"]
       styles[:display] = "none"
     end
+
+    # Do we need to set CSS positioning here, especially if displace is set? Position: relative maybe?
+    # We need some Shoes3 screenshots and HTML-based tests here...
+
+    if props["top"] || props["left"]
+      styles[:position] = "absolute"
+    end
+
+    styles[:top] = dimensions_length(props["top"]) if props["top"]
+    styles[:left] = dimensions_length(props["left"]) if props["left"]
+    styles[:width] = dimensions_length(props["width"]) if props["width"]
+    styles[:height] = dimensions_length(props["height"]) if props["height"]
+    styles[:"margin-left"] = dimensions_length(props["margin_left"]) if props["margin_left"]
+    styles[:"margin-right"] = dimensions_length(props["margin_right"]) if props["margin_right"]
+    styles[:"margin-top"] = dimensions_length(props["margin_top"]) if props["margin_top"]
+    styles[:"margin-bottom"] = dimensions_length(props["margin_bottom"]) if props["margin_bottom"]
+
+
+    
+    styles = spacing_styles_for_attr("padding", props, styles)
+
     styles
   end
 
+  SPACING_DIRECTIONS = [:left, :right, :top, :bottom]
+
+  # We extract the appropriate margin and padding from the margin and
+  # padding properties. If there are no margin or padding properties,
+  # we fall back to props["options"] margin or padding, if it exists.
+  #
+  # Margin or padding (in either props or props["options"]) can be
+  # a Hash with directions as keys, or an Array of left/right/top/bottom,
+  # or a constant, which means all four are that constant. You can
+  # also specify a "margin" plus "margin-top" which is constant but
+  # margin-top is overridden, or similar.
+  #
+  # If any margin or padding property exists in props then we don't
+  # check props["options"].
+  def spacing_styles_for_attr(attr, props, styles, with_options: true)
+    spacing_styles = {}
+
+    case props[attr]
+    when Hash
+      props[attr].each do |dir, value|
+        spacing_styles[:"#{attr}-#{dir}"] = dimensions_length value
+      end
+    when Array
+      SPACING_DIRECTIONS.zip(props[attr]).to_h.compact.each do |dir, value|
+        spacing_styles[:"#{attr}-#{dir}"] = dimensions_length(value)
+      end
+    when String, Numeric
+      spacing_styles[attr.to_sym] = dimensions_length(props[attr])
+    end
+
+    SPACING_DIRECTIONS.each do |dir|
+      if props["#{attr}_#{dir}"]
+        spacing_styles[:"#{attr}-#{dir}"] = dimensions_length props["#{attr}_#{dir}"]
+      end
+    end
+
+    unless spacing_styles.empty?
+      return styles.merge(spacing_styles)
+    end
+
+    # We should see if there are spacing properties in props["options"],
+    # unless we're currently doing that.
+    if with_options && props["options"]
+      spacing_styles = spacing_styles_for_attr(attr, props["options"], {}, with_options: false)
+      styles.merge spacing_styles
+    else
+      # No "options" or we already checked it? Return the styles we were given.
+      styles
+    end
+  end
+
+  def first_color_of(*colors)
+    colors.compact!
+    colors.select! { |c| c != "" }
+    rgb_to_hex(colors[0])
+  end
+
   # Convert an [r, g, b, a] array to an HTML hex color code
   # Arrays support alpha. HTML hex does not. So premultiply.
   def rgb_to_hex(color)
-    return color if color.nil?
+    return nil if color.nil?
+    return "#000000" if color == ""
+
+    # TODO: need to figure out if it's a color name like "aquamarine"
+    # or a hex code or an image file to use as a pattern or what.
+    return color if color.is_a?(String)
 
     r, g, b, a = *color
     if r.is_a?(Float)

data/lib/scarpe/components/errors.rb

@@ -3,9 +3,13 @@
 # Also defined in scarpe_core
 class Scarpe::Error < StandardError; end
 
+# TODO: this should be under Scarpe::Errors, and also probably merged into the normal
+# Scarpe errors file.
 module Scarpe
   class InternalError < Scarpe::Error; end
 
+  class OperationNotAllowedError < Scarpe::Error; end
+
   class FileContentError < Scarpe::Error; end
 
   class NoOperationError < Scarpe::Error; end

data/lib/scarpe/components/html.rb

@@ -20,6 +20,9 @@ class Scarpe::Components::HTML
     :u,
     :line,
     :span,
+    :sub,
+    :sup,
+    :del,
     :svg,
     :h1,
     :h2,
@@ -27,7 +30,7 @@ class Scarpe::Components::HTML
     :h4,
     :h5,
   ].freeze
-  VOID_TAGS = [:input, :img, :polygon, :source, :link, :path, :rect].freeze
+  VOID_TAGS = [:input, :img, :polygon, :source, :link, :path, :rect, :ellipse].freeze
 
   TAGS = (CONTENT_TAGS + VOID_TAGS).freeze
 

data/lib/scarpe/components/minitest_export_reporter.rb

@@ -24,11 +24,18 @@ module Minitest
     # the reporter will be automatically overridden and print to console instead.
     #
     # Based on https://gist.github.com/davidwessman/09a13840a8a80080e3842ac3051714c7
-    class ShoesExportReporter < DefaultReporter
+    class ShoesExportReporter < BaseReporter
+      class << self
+        attr_accessor :metadata
+        attr_accessor :export_file
+      end
+
       def self.activate!
         unless ENV["SHOES_MINITEST_EXPORT_FILE"]
           raise "ShoesExportReporter is available, but no export file was specified! Set SHOES_MINITEST_EXPORT_FILE!"
         end
+        ShoesExportReporter.export_file = File.expand_path(ENV["SHOES_MINITEST_EXPORT_FILE"])
+        ShoesExportReporter.metadata ||= {}
 
         Minitest::Reporters.use!
       end
@@ -58,6 +65,7 @@ module Minitest
             failures: failures,
             time: result.time,
             metadata: result.respond_to?(:metadata) ? result.metadata : {},
+            exporter_metadata: ShoesExportReporter.metadata,
             source_location: begin
               result.source_location
             rescue
@@ -66,8 +74,8 @@ module Minitest
           }
         end
 
-        out_file = File.expand_path ENV["SHOES_MINITEST_EXPORT_FILE"]
-        puts "Writing Minitest results to #{out_file.inspect}."
+        out_file = ShoesExportReporter.export_file
+        #puts "Writing Minitest results to #{out_file.inspect}."
         File.write(out_file, JSON.dump(results))
       end
     end

data/lib/scarpe/components/minitest_result.rb

@@ -56,6 +56,47 @@ class Scarpe::Components::MinitestResult
     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

data/lib/scarpe/components/print_logger.rb

@@ -11,26 +11,41 @@ class Scarpe::Components::PrintLogImpl
   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)
-      puts "#{@comp_name} error: #{msg}" unless PrintLogger.silence
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:error]
+      puts "#{@comp_name} error: #{msg}"
     end
 
     def warn(msg)
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:warn]
       puts "#{@comp_name} warn: #{msg}" unless PrintLogger.silence
     end
 
     def debug(msg)
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:debug]
       puts "#{@comp_name} debug: #{msg}" unless PrintLogger.silence
     end
 
     def info(msg)
-      puts "#{@comp_name} info: #{msg}" unless PrintLogger.silence
+      return if PrintLogger.silence || PrintLogger.min_level > LEVELS[:info]
+      puts "#{@comp_name} info: #{msg}"
     end
   end