scarpe 0.3.0 → 0.5.0

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

@@ -7,15 +7,19 @@ class TestCalziniPara < Minitest::Test
     @calzini = CalziniRenderer.new
   end
 
-  # Note that Calzini doesn't render the text items for itself.
   def test_para_simple
     assert_equal %{<p id="elt-1">OK</p>},
       @calzini.render("para", {}) { "OK" }
   end
 
+  def test_para_with_align
+    assert_equal %{<div id=\"elt-1\" style=\"text-align:right;width:100%\"><p>OK</p></div>},
+      @calzini.render("para", { "align" => "right" }) { "OK" }
+  end
+
   def test_para_with_stroke_and_font
     assert_equal %{<p id="elt-1" style="color:#FF0000;font-family:Lucida">OK</p>},
-      @calzini.render("para", { "stroke" => [1.0, 0.0, 0.0], "font" => "Lucida" }) { "OK" }
+      @calzini.render("para", { "stroke" => [1.0, 0.0, 0.0], "family" => "Lucida" }) { "OK" }
   end
 
   def test_para_with_string_banner
@@ -27,11 +31,4 @@ class TestCalziniPara < Minitest::Test
     assert_equal %{<p id="elt-1" style="font-size:48px"></p>},
       @calzini.render("para", { "size" => :banner })
   end
-
-  # Eventually this should probably need to be marked as a Scarpe extension, here or
-  # elsewhere.
-  def test_para_with_html_attributes
-    assert_equal %{<p avocado="true" class="avocado_bearing" id="elt-1"></p>},
-      @calzini.render("para", { "html_attributes" => { "avocado" => true, "class" => "avocado_bearing" } })
-  end
 end

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

@@ -7,124 +7,79 @@ class TestCalziniSlots < Minitest::Test
     @calzini = CalziniRenderer.new
     @stack_default_style = %{display:flex;flex-direction:column;align-content:flex-start;justify-content:flex-start;align-items:flex-start}
     @flow_default_style = %{display:flex;flex-direction:row;flex-wrap:wrap;align-content:flex-start;justify-content:flex-start;align-items:flex-start}
+    @inner_div_tag = %{<div style="height:100%;width:100%;position:relative">}
   end
 
   def test_stack_simple
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style}">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", {}) { "contents" }
   end
 
   def test_flow_simple
     assert_equal %{<div id="elt-1" } +
       %{style="#{@flow_default_style}">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("flow", {}) { "contents" }
   end
 
   def test_docroot_simple
     assert_equal %{<div id="elt-1" } +
       %{style="#{@flow_default_style}">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("documentroot", {}) { "contents" }
   end
 
   def test_stack_border_plain_color
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};border-style:solid;border-width:1px;border-radius:0px;border-color:red">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "border_color" => "red" }) { "contents" }
   end
 
   def test_stack_border_gradient
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};border-style:solid;border-width:1px;border-radius:0px;border-image:linear-gradient(45deg, red, green)">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "border_color" => ("red".."green") }) { "contents" }
   end
 
   def test_stack_border_rgba
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};border-style:solid;border-width:1px;border-radius:0px;border-color:rgba(1.0, 0.0, 0.0, 1.0)">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "border_color" => [1.0, 0.0, 0.0, 1.0] }) { "contents" }
   end
 
   def test_stack_border_attrs
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};border-style:solid;border-width:3px;border-radius:2px;border-color:red">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "border_color" => "red", "options" => { "strokewidth" => 3, "curve" => 2 } }) { "contents" }
   end
 
-  def test_stack_margin
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin:25px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "margin" => 25 }) { "contents" }
-  end
-
-  def test_stack_options_margin
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin:15px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "options" => { "margin" => 15 } }) { "contents" }
-  end
-
-  def test_stack_margin_overrides_options
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin:25px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "margin" => 25, "options" => { "margin" => 15 } }) { "contents" }
-  end
 
   def test_stack_padding
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};padding:25px">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "padding" => 25 }) { "contents" }
   end
 
   def test_stack_options_padding
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};padding:15px">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "options" => { "padding" => 15 } }) { "contents" }
   end
 
   def test_stack_padding_overrides_options
     assert_equal %{<div id="elt-1" } +
       %{style="#{@stack_default_style};padding:25px">} +
-      %{contents</div>},
+      %{#{@inner_div_tag}contents</div></div>},
       @calzini.render("stack", { "padding" => 25, "options" => { "padding" => 15 } }) { "contents" }
   end
 
-  def test_stack_options_hash_margin
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin-left:5px;margin-right:10px;margin-top:15px;margin-bottom:20px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "margin" => { left: 5, right: 10, top: 15, bottom: 20 } }) { "contents" }
-  end
-
-  def test_stack_options_array_margin
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin-left:5px;margin-right:10px;margin-top:15px;margin-bottom:20px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "margin" => [5, 10, 15, 20] }) { "contents" }
-  end
-
-  def test_stack_options_margin_left_overrides_options
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin-left:25px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "margin_left" => 25, "options" => { "margin" => 15 } }) { "contents" }
-  end
-
-  def test_stack_margin_left_overrides_margin
-    assert_equal %{<div id="elt-1" } +
-      %{style="#{@stack_default_style};margin:25px;margin-left:15px">} +
-      %{contents</div>},
-      @calzini.render("stack", { "margin" => 25, "margin_left" => 15 }) { "contents" }
-  end
+ 
 end

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

@@ -7,35 +7,100 @@ class TestCalziniTextDrawables < Minitest::Test
     @calzini = CalziniRenderer.new
   end
 
-  def test_link_simple
-    assert_equal %{<a id="elt-1" href="https://google.com">click here</a>},
-      @calzini.render("link", { "click" => "https://google.com", "text" => "click here" })
+  def trim_html_ids(s)
+    s.gsub(/ class="id_\d+"/, "")
   end
 
-  def test_link_block
-    assert_equal %{<a id="elt-1" onclick="handle('click')">click here</a>},
-      @calzini.render("link", { "has_block" => true, "text" => "click here" })
+  def test_text_only_drawable
+    assert_equal %{this is text},
+      @calzini.render("text_drawable", ["this ", "is", " text"])
   end
 
-  def test_span_simple
-    assert_equal %{<span id="elt-1" style="color:red;font-size:48px;font-family:Lucida">big red</span>},
-      @calzini.render("span", { "stroke" => "red", "size" => :banner, "font" => "Lucida" }) { "big red" }
+  def test_simple_text_drawable_with_em
+    assert_equal %{this <em class="id_1">is</em> text},
+      @calzini.render("text_drawable",
+        ["this ", { tag: "em", html_id: "1", items: ["is"], props: {}}, " text"])
   end
 
-  def test_span_html_attributes
-    assert_equal %{<span class="biggreen" id="elt-1" style="color:green;font-size:48px">big green</span>},
-      @calzini.render("span", { "stroke" => "green", "size" => "banner", "html_attributes" => { "class" => "biggreen" } }) { "big green" }
+  # Span doesn't have default properties, so it's good for testing how a property is rendered
+  def test_simple_text_drawable_with_span_styles
+    assert_equal %{this <span style="color:#FF00FF;background-color:#0000FF;font-size:13px;font-family:Lucida">is</span> text},
+      trim_html_ids(@calzini.render("text_drawable",
+        ["this ", {
+          tag: "span",
+          html_id: "1",
+          items: ["is"],
+          props: {
+            "family" => "Lucida",
+            "size" => 13,
+            "stroke" => "#FF00FF",
+            "fill" => "#0000FF"
+          }
+        }, " text"]))
   end
 
-  def test_code_simple
-    assert_equal %{<code>Hello</code>}, @calzini.render("code", {}) { "Hello" }
+  def test_link_with_has_block
+    assert_equal %{this <a onclick="handle('click')">is</a> text},
+      trim_html_ids(@calzini.render("text_drawable",
+        ["this ", {
+          tag: "a",
+          html_id: "1",
+          items: ["is"],
+          props: {
+            "has_block" => true,
+          }
+        }, " text"]))
   end
 
-  def test_em_simple
-    assert_equal %{<em>Hello</em>}, @calzini.render("em", {}) { "Hello" }
+  def test_link_with_click
+    assert_equal %{this <a href="#" onclick="handle('click')">is</a> text},
+      trim_html_ids(@calzini.render("text_drawable",
+        ["this ", {
+          tag: "a",
+          html_id: "1",
+          items: ["is"],
+          props: {
+            "has_block" => true,
+            "click" => "#",
+          }
+        }, " text"]))
   end
 
-  def test_strong_simple
-    assert_equal %{<strong>Hello</strong>}, @calzini.render("strong", {}) { "Hello" }
+  def test_del_tag
+    assert_equal %{this <del>is</del> text},
+      trim_html_ids(@calzini.render("text_drawable",
+        ["this ", {
+          tag: "del",
+          html_id: "1",
+          items: ["is"],
+          props: {
+          }
+        }, " text"]))
+  end
+
+  def test_single_strikethrough
+    assert_equal %{this <span style="text-decoration-line:line-through">is</span> text},
+      trim_html_ids(@calzini.render("text_drawable",
+        ["this ", {
+          tag: "span",
+          html_id: "1",
+          items: ["is"],
+          props: {
+            "strikethrough" => "single",
+          }
+        }, " text"]))
+  end
+
+  def test_single_strikethrough_none
+    assert_equal %{this <span>is</span> text},
+      trim_html_ids(@calzini.render("text_drawable",
+        ["this ", {
+          tag: "span",
+          html_id: "1",
+          items: ["is"],
+          props: {
+            "strikethrough" => "none",
+          }
+        }, " text"]))
   end
 end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+# Some tests don't cover just a single drawable.
+class TestVariousCalzini < Minitest::Test
+  def setup
+    @calzini = CalziniRenderer.new
+  end
+
+  # Test data. For each drawable, include
+  # a minimal set of properties to create something
+  # basic and default. Then we can add to it and
+  # test the resulting HTML.
+  #
+  # In Shoes3, the vast majority of drawables support
+  # both stroke and fill. Here's the list from the
+  # Shoes manual minus the ones we already test here:
+  #
+  # background, banner, caption,
+  # code, del, em, flow, image, ins, inscription,
+  # link, mask, para, shape, span, stack,
+  # strong, sub, sup, subtitle, tagline, title
+  #
+  # Scarpe doesn't yet support the property on everything.
+  # but as we support it, we should add the drawables
+  # here.
+  #
+  CALZINI_ART_DRAWABLES = {
+    arc: {
+      has_stroke: false,
+      has_fill: false,
+      props: {
+        "width" => 200,
+        "height" => 150,
+        "left" => 17,
+        "top" => 42,
+        "angle1" => 3.14 / 2,
+        "angle2" => 3.14 / 4,
+      },
+    },
+    arrow: {
+      has_stroke: true,
+      has_fill: true,
+      props: {
+        "left" => 10,
+        "top" => 20,
+        "width" => 5,
+      },
+    },
+    line: {
+      has_stroke: true,
+      has_fill: false,
+      props: {
+        "top" => "4",
+        "left" => "7",
+        "x1" => "20",
+        "y1" => "17",
+        "x2" => "100",
+        "y2" => "104",
+      },
+    },
+    rect: {
+      has_stroke: true,
+      has_fill: true,
+      props: {
+        "top" => "9",
+        "left" => "12",
+        "width" => "147",
+        "height" => "91",
+        "draw_context" => {},
+      },
+    },
+    star: {
+      has_stroke: true,
+      has_fill: true,
+      props: {
+        "points" => 5,
+        "outer" => 2.0,
+        "inner" => 1.0,
+      },
+    },
+    oval: {
+      has_stroke: true,
+      has_fill: true,
+      props: {
+        "left" => 10,
+        "top" => 7,
+        "radius" => 5,
+      },
+    },
+  }
+
+  # This method tests some basic ways of setting strokes and fills and makes sure they
+  # work for different drawables. TODO: add more drawables. TODO: either add testing for
+  # setting stroke and fill directly vs. draw-context, or remove draw-context.
+  def test_color_conversion
+    CALZINI_ART_DRAWABLES.each do |name, h|
+      basic = @calzini.render(name.to_s, h[:props])
+      assert !basic.include?("#FF0000"), "Un-colored #{name} shouldn't already have red or we'll get a false positive!"
+
+      if h[:has_stroke]
+        red_stroke = @calzini.render(name.to_s, h[:props].merge("stroke" => [255, 0, 0, 255]))
+        assert_includes red_stroke, "#FF0000", "With integer-array red stroke, #{name} should contain red color!"
+
+        red_stroke = @calzini.render(name.to_s, h[:props].merge("draw_context" => { "stroke" => [255, 0, 0, 255] }))
+        assert_includes red_stroke, "#FF0000", "With integer-array red stroke, #{name} should contain red color!"
+
+        red_stroke = @calzini.render(name.to_s, h[:props].merge("stroke" => [255, 0, 0, 255], "draw_context" => { "stroke" => [0, 255, 0, 255] }))
+        assert_includes red_stroke, "#FF0000", "Red stroke should take precedence over green, #{name} should contain red color!"
+
+        # TODO: later, after issue #504 is fixed, colors should turn into their hex equivalent
+        red_stroke = @calzini.render(name.to_s, h[:props].merge("stroke" => "red"))
+        assert_includes red_stroke, "red", "With integer-array red stroke, #{name} should contain red color!"
+      end
+
+      if h[:has_fill]
+        red_fill = @calzini.render(name.to_s, h[:props].merge("fill" => [255, 0, 0, 255]))
+        assert_includes red_fill, "#FF0000", "With integer-array red fill, #{name} should contain red color!"
+
+        red_fill = @calzini.render(name.to_s, h[:props].merge("draw_context" => { "fill" => [255, 0, 0, 255] }))
+        assert_includes red_fill, "#FF0000", "With integer-array red fill, #{name} should contain red color!"
+
+        red_fill = @calzini.render(name.to_s, h[:props].merge("fill" => [255, 0, 0, 255], "draw_context" => { "fill" => [0, 255, 0, 255] }))
+        assert_includes red_fill, "#FF0000", "Red fill should take precedence over green, #{name} should contain red color!"
+
+        # TODO: later, after issue #504 is fixed, colors should turn into their hex equivalent
+        red_fill = @calzini.render(name.to_s, h[:props].merge("fill" => "red"))
+        assert_includes red_fill, "red", "With integer-array red fill, #{name} should contain red color!"
+      end
+    end
+  end
+end

data/scarpe-components/test/test_asset_server.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+require "scarpe/components/asset_server"
+
+class TestAssetServer < Minitest::Test
+  def teardown
+    @server = nil # Don't keep the same server object from run to run, just in case
+  end
+
+  def fake_server
+    # We don't need to check HTTP connections, we just want to generate URLs
+    @server ||= Scarpe::Components::AssetServer.new port: 4444, app_dir: __dir__, never_start_server: true
+  end
+
+  def weird_dir_server
+    # Use a deeper app root to test files outside the app's directory
+    @server ||= Scarpe::Components::AssetServer.new port: 4444, app_dir: "#{__dir__}/subdir", never_start_server: true
+  end
+
+  def test_small_image_explicit_data_url
+    url = fake_server.asset_url("#{__dir__}/assets/little-image.png", url_type: :data)
+    assert url.start_with?("data:image/png;base64,"), "Data URL for image should start with image/png! #{url.inspect}"
+  end
+
+  def test_small_css_explicit_data_url
+    url = fake_server.asset_url("#{__dir__}/assets/little-stylesheet.css", url_type: :data)
+    assert url.start_with?("data:text/css;base64,"), "Data URL for CSS should start with text/css! #{url.inspect}"
+  end
+
+  def test_small_css_auto_data_url
+    url = fake_server.asset_url("#{__dir__}/assets/little-stylesheet.css")
+    assert url.start_with?("data:text/css;base64,"), "Small CSS files should get a data URL by default! #{url.inspect}"
+  end
+
+  def test_small_css_explicit_app_dir_asset_url
+    url = fake_server.asset_url("#{__dir__}/assets/little-stylesheet.css", url_type: :asset)
+    assert_equal "http://127.0.0.1:4444/app/assets/little-stylesheet.css", url, "Small CSS files should get an asset URL by request!"
+  end
+
+  def test_small_css_explicit_component_asset_url
+    url = weird_dir_server.asset_url("#{__dir__}/assets/little-stylesheet.css", url_type: :asset)
+    assert_equal "http://127.0.0.1:4444/comp/test/assets/little-stylesheet.css", url, "Small CSS files should get an asset URL by request!"
+  end
+
+  def test_large_app_file_auto_asset_url
+    url = fake_server.asset_url("#{__dir__}/assets/big-image.png")
+    assert_equal "http://127.0.0.1:4444/app/assets/big-image.png", url, "Big image files should get an asset URL by default!"
+  end
+
+  def test_large_app_file_explicit_asset_url
+    url = fake_server.asset_url("#{__dir__}/assets/big-image.png", url_type: :asset)
+    assert_equal "http://127.0.0.1:4444/app/assets/big-image.png", url, "Big image files should get an asset URL by default!"
+  end
+
+  def test_large_app_file_explicit_data_url
+    url = fake_server.asset_url("#{__dir__}/assets/big-image.png", url_type: :data)
+    assert url.start_with?("data:image/png;base64,"), "Big image files should get a data URL by request! #{url.inspect}"
+  end
+
+  def test_large_file_outside_dirs
+    url = fake_server.asset_url("#{__dir__}/../../docs/static/man-builds.png")
+    assert url.start_with?("data:image/png;base64,"), "Large files outside dirs should still use data URLs"
+  end
+
+  def test_large_file_outside_dirs_with_exception
+    assert_raises Scarpe::OperationNotAllowedError do
+      url = fake_server.asset_url("#{__dir__}/../../docs/static/man-builds.png", url_type: :asset)
+    end
+  end
+end

data/scarpe-components/test/test_components.rb

@@ -3,7 +3,36 @@
 require_relative "test_helper"
 
 class TestScarpeComponents < Minitest::Test
-  def test_truth
-    assert_equal true, true
+  # Top-level tests go here?
+end
+
+require "scarpe/components/process_helpers"
+class TestComponentHelpers < Minitest::Test
+  include Scarpe::Components::ProcessHelpers
+
+  def test_process_runner_stdout
+    out, err, success = run_out_err_result("echo ok")
+    assert success, "Echoing okay should succeed!"
+    assert_equal "", err
+    assert_includes out, "ok"
+  end
+
+  def test_process_runner_stderr
+    out, err, success = run_out_err_result("echo ok 1>&2")
+    assert success, "Echoing okay to stderr should succeed!"
+    assert_equal "", out
+    assert_includes err, "ok"
+  end
+
+  def test_process_runner_fail
+    out, err, success = run_out_err_result("ls no_such_file_exists")
+    assert !success, "ls on nonexistent file should return failure!"
+    assert_equal "", out
+    assert err != "", "ls on nonexistent file should give non-empty error output"
+  end
+
+  def test_process_runner_command_array
+    out, err, success = run_out_err_result(["echo", "ok"])
+    assert success, "Echoing okay via command array should succeed!"
   end
 end

data/scarpe-components/test/test_helper.rb

@@ -39,5 +39,4 @@ class CalziniRenderer
 end
 
 class Minitest::Test
-  include Scarpe::Test::Helpers
 end

data/scarpe-components/test/test_minitest_result.rb

@@ -58,4 +58,11 @@ class TestMinitestResult < Minitest::Test
     refute res.passed?
     assert_equal "Just skipping", res.skip_message
   end
+
+  def test_mtr_console_summary
+    path = File.join __dir__, "mtr_data/skipped_w_msg.json"
+    res = Scarpe::Components::MinitestResult.new(path)
+
+    assert res.console_summary.include?("Skip:")
+  end
 end

data/scarpe-components/test/test_port_helpers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+require "scarpe/components/port_helpers"
+class TestPortHelpers < Minitest::Test
+  include Scarpe::Components::PortHelpers
+
+  def test_port_finder
+    assert_equal false, port_working?("127.0.0.1", 9832), "Port 9832 should be unused!"
+  end
+end

data/scarpe-components/test/test_segmented_app_files.rb

@@ -7,6 +7,8 @@ require "scarpe/components/segmented_file_loader"
 SEG_TEST_DATA = {}
 
 class TestSegmentedAppFiles < Minitest::Test
+  include Scarpe::Test::Helpers
+
   def setup
     @orig_file_loaders = Shoes.file_loaders
     Shoes.reset_file_loaders # create new loaders array with no overlap with @orig_file_loaders