scarpe-components 0.2.2 → 0.3.0

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+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)
+    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)
+    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)
+    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
+  end
+
+  private
+
+  def slot_style(props)
+    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"]
+
+    styles
+  end
+
+  def flow_style(props)
+    {
+      display: "flex",
+      "flex-direction": "row",
+      "flex-wrap": "wrap",
+      "align-content": "flex-start",
+      "justify-content": "flex-start",
+      "align-items": "flex-start",
+    }.merge(slot_style(props))
+  end
+
+  def stack_style(props)
+    {
+      display: "flex",
+      "flex-direction": "column",
+      "align-content": "flex-start",
+      "justify-content": "flex-start",
+      "align-items": "flex-start",
+      overflow: props["scroll"] ? "auto" : nil,
+    }.compact.merge(slot_style(props))
+  end
+
+  def border_style(props, styles)
+    bc = props["border_color"]
+    return styles unless bc
+
+    opts = props["options"] || {}
+
+    border_style_hash = case bc
+    when Range
+      { "border-image": "linear-gradient(45deg, #{bc.first}, #{bc.last})" }
+    when Array
+      { "border-color": "rgba(#{bc.join(", ")})" }
+    else
+      { "border-color": bc }
+    end
+    styles.merge(
+      "border-style": "solid",
+      "border-width": "#{opts["strokewidth"] || 1}px",
+      "border-radius": "#{opts["curve"] || 0}px",
+    ).merge(border_style_hash)
+  end
+
+  def background_style(props, styles)
+    bc = props["background_color"]
+    return styles unless bc
+
+    color = case bc
+    when Array
+      "rgba(#{bc.join(", ")})"
+    when Range
+      "linear-gradient(45deg, #{bc.first}, #{bc.last})"
+    when ->(value) { File.exist?(value) }
+      "url(data:image/png;base64,#{encode_file_to_base64(bc)})"
+    else
+      bc
+    end
+
+    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/text_widgets.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Scarpe::Components::Calzini
+  def link_element(props)
+    HTML.render do |h|
+      h.a(**link_attributes(props)) do
+        props["text"]
+      end
+    end
+  end
+
+  def span_element(props, &block)
+    HTML.render do |h|
+      h.span(**span_options(props), &block)
+    end
+  end
+
+  def code_element(props, &block)
+    HTML.render do |h|
+      h.code(&block)
+    end
+  end
+
+  def em_element(props, &block)
+    HTML.render do |h|
+      h.em(&block)
+    end
+  end
+
+  def strong_element(props, &block)
+    HTML.render do |h|
+      h.strong(&block)
+    end
+  end
+
+  private
+
+  def link_attributes(props)
+    {
+      id: html_id,
+      href: props["click"],
+      onclick: (handler_js_code("click") if props["has_block"]),
+      style: drawable_style(props),
+    }.compact
+  end
+
+  def span_style(props)
+    {
+      color: props["stroke"],
+      "font-size": span_font_size(props),
+      "font-family": props["font"],
+    }.compact
+  end
+
+  def span_options(props)
+    (props["html_attributes"] || {}).merge(id: html_id, style: span_style(props))
+  end
+
+  def span_font_size(props)
+    sz = props["size"]
+    font_size = SIZES.key?(sz.to_s.to_sym) ? SIZES[sz.to_s.to_sym] : sz
+
+    dimensions_length(font_size)
+  end
+end

data/lib/scarpe/components/calzini.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "html"
+require_relative "base64"
+require_relative "errors"
+
+# Require all drawable rendering code under calzini directory
+Dir.glob("calzini/*.rb", base: __dir__) do |drawable|
+  require_relative drawable
+end
+
+# The Calzini 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) shoes_styles - the Shoes styles for this object, unless overridden in render()
+module Scarpe::Components::Calzini
+  extend self
+
+  HTML = Scarpe::Components::HTML
+  include Scarpe::Components::Base64
+
+  SIZES = {
+    inscription: 10,
+    ins: 10,
+    para: 12,
+    caption: 14,
+    tagline: 18,
+    subtitle: 26,
+    title: 34,
+    banner: 48,
+  }.freeze
+  private_constant :SIZES
+
+  # Render the Shoes drawable of type `drawable_name` with
+  # the given properties to HTML and return it. If the
+  # drawable type takes a block (e.g. Stack or Flow) then
+  # the block will be properly rendered.
+  #
+  # @param drawable_name [String] the drawable name like "alert", "button" or "rect"
+  # @param properties [Hash] a drawable-specific hash of property names to values
+  # @block the block which, when called, will return the contents for drawable types with contents
+  # @return [String] the rendered HTML
+  def render(drawable_name, properties = shoes_styles, &block)
+    send("#{drawable_name}_element", properties, &block)
+  end
+
+  # Return HTML for an empty page element, to be filled with HTML
+  # renderings of the DOM tree.
+  #
+  # The wrapper-wvroot element is where Scarpe will fill in the
+  # DOM element.
+  #
+  # @return [String] the rendered HTML for the empty page object.
+  def empty_page_element
+    <<~HTML
+      <html>
+        <head id='head-wvroot'>
+          <style id='style-wvroot'>
+            /** Style resets **/
+            body {
+              font-family: arial, Helvetica, sans-serif;
+              margin: 0;
+              height: 100%;
+              overflow: hidden;
+            }
+            p {
+              margin: 0;
+            }
+          </style>
+        </head>
+        <body id='body-wvroot'>
+          <div id='wrapper-wvroot'></div>
+        </body>
+      </html>
+    HTML
+  end
+
+  def text_size(sz)
+    case sz
+    when Numeric
+      sz
+    when Symbol
+      SIZES[sz]
+    when String
+      SIZES[sz.to_sym] || sz.to_i
+    else
+      raise "Unexpected text size object: #{sz.inspect}"
+    end
+  end
+
+  def dimensions_length(value)
+    case value
+    when Integer
+      if value < 0
+        "calc(100% - #{value.abs}px)"
+      else
+        "#{value}px"
+      end
+    when Float
+      "#{value * 100}%"
+    else
+      value
+    end
+  end
+
+  def drawable_style(props)
+    styles = {}
+    if props["hidden"]
+      styles[:display] = "none"
+    end
+    styles
+  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?
+
+    r, g, b, a = *color
+    if r.is_a?(Float)
+      a ||= 1.0
+      r_float = r * a
+      g_float = g * a
+      b_float = b * a
+    else
+      a ||= 255
+      a_float = (a / 255.0)
+      r_float = (r.to_f / 255.0) * a_float
+      g_float = (g.to_f / 255.0) * a_float
+      b_float = (b.to_f / 255.0) * a_float
+    end
+
+    r_int = (r_float * 255.0).to_i.clamp(0, 255)
+    g_int = (g_float * 255.0).to_i.clamp(0, 255)
+    b_int = (b_float * 255.0).to_i.clamp(0, 255)
+
+    "#%0.2X%0.2X%0.2X" % [r_int, g_int, b_int]
+  end
+
+  def degrees_to_radians(degrees)
+    degrees * Math::PI / 180
+  end
+
+  def radians_to_degrees(radians)
+    radians * (180.0 / Math::PI)
+  end
+end

data/lib/scarpe/components/errors.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Also defined in scarpe_core
+class Scarpe::Error < StandardError; end
+
+module Scarpe
+  class InternalError < Scarpe::Error; end
+
+  class FileContentError < Scarpe::Error; end
+
+  class NoOperationError < Scarpe::Error; end
+
+  class DuplicateFileError < Scarpe::Error; end
+
+  class NoSuchFile < Scarpe::Error; end
+
+  class MustOverrideMethod < Scarpe::Error; end
+
+  class InvalidHTMLTag < Scarpe::Error; end
+end

data/lib/scarpe/components/file_helpers.rb

@@ -4,6 +4,7 @@ require "tempfile"
 
 # These can be used for unit tests, but also more generally.
 
+module Scarpe; module Components; end; end
 module Scarpe::Components::FileHelpers
   # Create a temporary file with the given prefix and contents.
   # Execute the block of code with it in place. Make sure

data/lib/scarpe/components/html.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+class Scarpe::Components::HTML
+  CONTENT_TAGS = [
+    :div,
+    :p,
+    :button,
+    :ul,
+    :li,
+    :textarea,
+    :a,
+    :video,
+    :strong,
+    :style,
+    :progress,
+    :em,
+    :code,
+    :defs,
+    :marker,
+    :u,
+    :line,
+    :span,
+    :svg,
+    :h1,
+    :h2,
+    :h3,
+    :h4,
+    :h5,
+  ].freeze
+  VOID_TAGS = [:input, :img, :polygon, :source, :link, :path, :rect].freeze
+
+  TAGS = (CONTENT_TAGS + VOID_TAGS).freeze
+
+  class << self
+    def render(&block)
+      new(&block).value
+    end
+  end
+
+  def initialize(&block)
+    @buffer = ""
+    block.call(self)
+  end
+
+  def value
+    @buffer
+  end
+
+  def respond_to_missing?(name, include_all = false)
+    TAGS.include?(name) || super(name, include_all)
+  end
+
+  def p(*args, &block)
+    method_missing(:p, *args, &block)
+  end
+
+  def option(**attrs, &block)
+    tag(:option, **attrs, &block)
+  end
+
+  def tag(name, **attrs, &block)
+    if VOID_TAGS.include?(name)
+      raise Shoes::Errors::InvalidAttributeValueError, "void tag #{name} cannot have content" if block_given?
+
+      @buffer += "<#{name}#{render_attributes(attrs)} />"
+    else
+      @buffer += "<#{name}#{render_attributes(attrs)}>"
+
+      if block_given?
+        result = block.call(self)
+      else
+        result = attrs[:content]
+        @buffer += result if result.is_a?(String)
+      end
+      @buffer += result if result.is_a?(String)
+
+      @buffer += "</#{name}>"
+    end
+
+    nil
+  end
+
+  def select(**attrs, &block)
+    tag(:select, **attrs, &block)
+  end
+
+  def method_missing(name, *args, &block)
+    raise Scarpe::InvalidHTMLTag, "no method #{name} for #{self.class.name}" unless TAGS.include?(name)
+
+    if VOID_TAGS.include?(name)
+      raise Shoes::Errors::InvalidAttributeValueError, "void tag #{name} cannot have content" if block_given?
+
+      @buffer += "<#{name}#{render_attributes(*args)} />"
+    else
+      @buffer += "<#{name}#{render_attributes(*args)}>"
+
+      if block_given?
+        result = block.call(self)
+      else
+        result = args.first
+        @buffer += result if result.is_a?(String)
+      end
+      @buffer += result if result.is_a?(String)
+
+      @buffer += "</#{name}>"
+    end
+
+    nil
+  end
+
+  private
+
+  def render_attributes(attributes = {})
+    return "" if attributes.empty?
+
+    attributes[:style] = render_style(attributes[:style]) if attributes[:style]
+    attributes.compact!
+
+    return if attributes.empty?
+
+    result = attributes.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+    " #{result}"
+  end
+
+  def render_style(style)
+    return style unless style.is_a?(Hash)
+    return if style.empty?
+
+    style.map { |k, v| "#{k}:#{v}" }.join(";")
+  end
+end

data/lib/scarpe/components/minitest_export_reporter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Have to require this to get DefaultReporter and the Minitest::Reporters namespace.
+ENV["MINITEST_REPORTER"] = "ShoesExportReporter"
+require "minitest/reporters"
+require "json"
+require "json/add/exception"
+
+module Minitest
+  module Reporters
+    # To use this Scarpe component, you'll need minitest-reporters in your Gemfile,
+    # probably in the "test" group. You'll need to require and activate ShoesExportReporter
+    # to register it as Minitest's reporter:
+    #
+    #     require "scarpe/components/minitest_export_reporter"
+    #     Minitest::Reporters::ShoesExportReporter.activate!
+    #
+    # Select a destination to export JSON test results to:
+    #
+    #     export SHOES_MINITEST_EXPORT_FILE=/tmp/shoes_test_export.json
+    #
+    # This class overrides the MINITEST_REPORTER environment variable when you call activate.
+    # If MINITEST_REPORTER isn't set then when you run via Vim, TextMate, RubyMine, etc,
+    # the reporter will be automatically overridden and print to console instead.
+    #
+    # Based on https://gist.github.com/davidwessman/09a13840a8a80080e3842ac3051714c7
+    class ShoesExportReporter < DefaultReporter
+      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
+
+        Minitest::Reporters.use!
+      end
+
+      def serialize_failures(failures)
+        failures.map do |fail|
+          case fail
+          when Minitest::UnexpectedError
+            ["unexpected", fail.to_json, fail.error.to_json]
+          when Exception
+            ["exception", fail.to_json]
+          else
+            raise "Not sure how to serialize failure object! #{fail.inspect}"
+          end
+        end
+      end
+
+      def report
+        super
+
+        results = tests.map do |result|
+          failures = serialize_failures result.failures
+          {
+            name: result.name,
+            klass: test_class(result),
+            assertions: result.assertions,
+            failures: failures,
+            time: result.time,
+            metadata: result.respond_to?(:metadata) ? result.metadata : {},
+            source_location: begin
+              result.source_location
+            rescue
+              ["unknown", -1]
+            end,
+          }
+        end
+
+        out_file = File.expand_path ENV["SHOES_MINITEST_EXPORT_FILE"]
+        puts "Writing Minitest results to #{out_file.inspect}."
+        File.write(out_file, JSON.dump(results))
+      end
+    end
+  end
+end

data/lib/scarpe/components/minitest_import_runnable.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "json"
+require "json/add/exception"
+
+module Scarpe; module Components; end; end
+module Scarpe::Components::ImportRunnables
+  # Minitest Runnables are unusual - we expect to declare a class (like a Test) with
+  # a lot of methods to run. The ImportRunnable is a single Runnable. But whenever
+  # you tell it to import a JSON file, it will add all of the described tests to
+  # its runnable methods.
+  #
+  # Normally that means that your subclass tests will run up front and produce
+  # JSON files, then Minitest will autorun at the end and report all their
+  # results.
+  #
+  # It wouldn't really make sense to create these runnables during the testing
+  # phase, because Minitest has already decided what to run at that point.
+  class ImportRunnable #< Minitest::Runnable
+    # Import JSON from an exported Minitest run. Note that running this multiple
+    # times with overlapping class names may be really bad.
+    def self.import_json_data(data)
+      @imported_classes ||= {}
+      @imported_tests ||= {}
+
+      JSON.parse(data).each do |item|
+        klass = item["klass"]
+        meth = item["name"]
+        @imported_tests[klass] ||= {}
+        @imported_tests[klass][meth] = item
+      end
+
+      @imported_tests.each do |klass_name, test_method_hash|
+        klass = @imported_classes[klass_name]
+        unless klass
+          new_klass = Class.new(Minitest::Runnable)
+          @imported_classes[klass_name] = new_klass
+          ImportRunnable.const_set(klass_name, new_klass)
+          klass = new_klass
+
+          klass.define_singleton_method(:run_one_method) do |klass, method_name, reporter|
+            reporter.prerecord klass, method_name
+            imp = test_method_hash[method_name]
+
+            res = Minitest::Result.new imp["name"]
+            res.klass = imp["klass"]
+            res.assertions = imp["assertions"]
+            res.time = imp["time"]
+            res.failures = ImportRunnable.deserialize_failures imp["failures"]
+            res.metadata = imp["metadata"] if imp["metadata"]
+
+            # Record the synthetic result built from imported data
+            reporter.record res
+          end
+        end
+
+        # Update "runnables" method to reflect all current known runnable tests
+        klass_methods = test_method_hash.keys
+        klass.define_singleton_method(:runnable_methods) do
+          klass_methods
+        end
+      end
+    end
+
+    def self.json_to_err(err_json)
+      klass = begin
+        Object.const_get(err_json["json_class"])
+      rescue
+        nil
+      end
+      if klass && klass <= Minitest::Assertion
+        klass.json_create(err_json)
+      else
+        err = Exception.json_create(err_json)
+        Minitest::UnexpectedError.new(err)
+      end
+    end
+
+    def self.deserialize_failures(failures)
+      failures.map do |fail|
+        # Instantiate the Minitest::Assertion or Minitest::UnexpectedError
+        if fail[0] == "exception"
+          exc_json = JSON.parse(fail[1])
+          json_to_err exc_json
+        elsif fail[0] == "unexpected"
+          unexpected_json = JSON.parse(fail[1])
+          inner_json = JSON.parse(fail[2])
+          outer_err = json_to_err unexpected_json
+          inner_err = json_to_err inner_json
+          outer_err.error = inner_err
+        else
+          raise "Unknown exception data when trying to deserialize! #{fail.inspect}"
+        end
+      end
+    end
+  end
+end