scarpe 0.3.0 → 0.5.0

data/lacci/lib/shoes.rb

@@ -7,49 +7,47 @@
 # to handle the DSL and command-line parts of Shoes without knowing anything about how the
 # display side works at all.
 
-if RUBY_VERSION[0..2] < "3.2"
-  Shoes::Log.logger("Shoes").error("Lacci (Scarpe, Shoes) requires Ruby 3.2 or higher!")
+if RUBY_VERSION[0..2] < '3.2'
+  Shoes::Log.logger('Shoes').error('Lacci (Scarpe, Shoes) requires Ruby 3.2 or higher!')
   exit(-1)
 end
 
 class Shoes; end
 class Shoes::Error < StandardError; end
-require_relative "shoes/errors"
+require_relative 'shoes/errors'
 
-require_relative "shoes/constants"
-require_relative "shoes/ruby_extensions"
+require_relative 'shoes/constants'
+require_relative 'shoes/ruby_extensions'
 
 # Shoes adds some top-level methods and constants that can be used everywhere. Kernel is where they go.
 module Kernel
   include Shoes::Constants
 end
 
-require_relative "shoes/display_service"
+require_relative 'shoes/display_service'
 
 # Pre-declare classes that get referenced outside their own require file
 class Shoes::Drawable < Shoes::Linkable; end
 class Shoes::Slot < Shoes::Drawable; end
 class Shoes::Widget < Shoes::Slot; end
 
-require_relative "shoes/log"
-require_relative "shoes/colors"
+require_relative 'shoes/log'
+require_relative 'shoes/colors'
 
-require_relative "shoes/builtins"
+require_relative 'shoes/builtins'
 
-require_relative "shoes/background"
-require_relative "shoes/border"
-require_relative "shoes/spacing"
+require_relative 'shoes/background'
 
-require_relative "shoes/drawable"
-require_relative "shoes/app"
-require_relative "shoes/drawables"
+require_relative 'shoes/drawable'
+require_relative 'shoes/app'
+require_relative 'shoes/drawables'
 
-require_relative "shoes/download"
+require_relative 'shoes/download'
 
 # No easy way to tell at this point whether
 # we will later load Shoes-Spec code, e.g.
 # by running a segmented app with test code.
-require_relative "shoes-spec"
+require_relative 'shoes-spec'
 
 # The module containing Shoes in all its glory.
 # Shoes is a platform-independent GUI library, designed to create
@@ -57,6 +55,40 @@ require_relative "shoes-spec"
 #
 class Shoes
   class << self
+    attr_accessor :APPS
+
+    # Track the most recently defined Shoes subclass for the inheritance pattern
+    # e.g., class Book < Shoes; end; Shoes.app
+    attr_accessor :pending_app_class
+
+    # When someone does `class MyApp < Shoes`, track it
+    def inherited(subclass)
+      # Only track direct subclasses of Shoes, not Shoes::App, Shoes::Drawable, etc.
+      # Those have their own inheritance tracking
+      if self == ::Shoes
+        Shoes.pending_app_class = subclass
+      end
+      super
+    end
+
+    # Class-level url method for defining routes in Shoes subclasses
+    # e.g., class Book < Shoes; url '/', :index; end
+    def url(path, method_name)
+      @class_routes ||= {}
+      if path.is_a?(String) && path.include?('(')
+        # Convert string patterns like '/page/(\d+)' to regex
+        regex = Regexp.new("^#{path.gsub(/\(.*?\)/, '(.*?)')}$")
+        @class_routes[regex] = method_name
+      else
+        @class_routes[path] = method_name
+      end
+    end
+
+    # Get the routes defined on this class
+    def class_routes
+      @class_routes ||= {}
+    end
+
     # Creates a Shoes app with a new window. The block parameter is used to create
     # drawables and set up handlers. Arguments are passed to Shoes::App.new internally.
     #
@@ -76,16 +108,60 @@ class Shoes
     # @param width [Integer] The new app window width
     # @param height [Integer] The new app window height
     # @param resizable [Boolean] Whether the app window should be resizeable
+    # @param features [Symbol,Array<Symbol>] Additional Shoes extensions requested by the app
     # @return [void]
     # @see Shoes::App#new
     def app(
-      title: "Shoes!",
+      title: 'Shoes!',
       width: 480,
       height: 420,
       resizable: true,
+      features: [],
       &app_code_body
     )
-      app = Shoes::App.new(title:, width:, height:, resizable:, &app_code_body)
+      f = [features].flatten # Make sure this is a list, not a single symbol
+      app = Shoes::App.new(title:, width:, height:, resizable:, features: f, &app_code_body)
+
+      # If there's a pending Shoes subclass (e.g., class Book < Shoes), use it
+      if Shoes.pending_app_class
+        subclass = Shoes.pending_app_class
+        Shoes.pending_app_class = nil  # Clear it so it doesn't affect future apps
+
+        # Include the subclass as a module to get its instance methods
+        # This works because we're extending the singleton class
+        methods_to_copy = subclass.instance_methods(false)
+
+        methods_to_copy.each do |method_name|
+          # Get source location and use eval to redefine - but that's fragile
+          # Instead, let's use a delegation pattern with the app as context
+
+          # Read the method's arity and create a proper wrapper
+          um = subclass.instance_method(method_name)
+
+          # Define a wrapper that will eval the original method body in app's context
+          # This is a bit hacky but works: we store the subclass and call via instance_eval
+          app.define_singleton_method(method_name) do |*args, &block|
+            # Create a temporary subclass instance that delegates to app for Shoes methods
+            temp = subclass.allocate
+            temp.instance_variable_set(:@__shoes_app__, self)
+
+            # Define method_missing on the temp to delegate Shoes DSL calls to the app
+            temp.define_singleton_method(:method_missing) do |name, *a, **kw, &b|
+              @__shoes_app__.send(name, *a, **kw, &b)
+            end
+            temp.define_singleton_method(:respond_to_missing?) { |*| true }
+
+            # Call the original method on temp (which delegates DSL calls to app)
+            temp.send(method_name, *args, &block)
+          end
+        end
+
+        # Copy routes from the subclass to the app
+        subclass.class_routes.each do |path, method_name|
+          app.url(path, method_name)
+        end
+      end
+
       app.init
       app.run
       nil
@@ -124,7 +200,7 @@ class Shoes
         proc do |path|
           load path
           true
-        end,
+        end
       ]
     end
 
@@ -144,4 +220,6 @@ class Shoes
       @file_loaders = loaders
     end
   end
+
+  Shoes.APPS ||= []
 end

data/lacci/test/.gitignore

@@ -0,0 +1 @@
+niente_test.json

data/lacci/test/test_draw_context.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestDrawContext < NienteTest
+  # need tests for:
+  # default values vs draw context values
+  # setting value explicitly w/ positional or keyword arg
+
+  # Test w/ color string names for now. This reveals a
+  # problem - our highly-variable color handling makes it
+  # hard to be sure about what comes through in a style.
+
+  # We do a bunch of wacky stuff with colors. We need some kind of
+  # equality check. This is good enough for this test until we
+  # have a proper color object backing up what we do in Scarpe.
+  def assert_color_equal(c1, c2)
+    if c1.nil? && c2.nil?
+      raise "Is this an expected use case?"
+    end
+
+    if (c1.is_a?(String) || c1.is_a?(Symbol)) && (c2.is_a?(String) || c2.is_a?(Symbol))
+      return assert_equal c1.to_s, c2.to_s, "Expected color #{c1.inspect} to equal #{c2.inspect}"
+    end
+
+    if c1.is_a?(Array) && c2.is_a?(Array)
+      return assert_equal c1, c2, "Expected color #{c1.inspect} to equal #{c2.inspect}"
+    end
+
+    raise "Oopsie! We got an unexpected comparison between colors #{c1.inspect}"
+  end
+
+  def test_draw_context_default
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        oval 5, 10, 25 # circle with radius 25 with its upper-left point at 5, 10
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal "black", ov.style["fill"]
+      assert_equal "black", ov.style["stroke"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_basic
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        fill darkgreen
+        stroke blue
+        oval 5, 10, 25 # circle with radius 25 with its upper-left point at 5, 10
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal [0, 100, 0, 255], ov.style["fill"]
+      assert_equal [0, 0, 255, 255], ov.style["stroke"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_explicit
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        fill blue
+        stroke blue
+        oval 5, 10, 25, fill: darkgreen
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal [0, 100, 0, 255], ov.style["fill"]
+      assert_equal [0, 0, 255, 255], ov.style["stroke"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_basic_nofill
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        nofill
+        oval 5, 10, 25
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal [0, 0, 0, 0], ov.style["fill"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_inherited_nofill
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        nofill
+        nostroke
+        stack do
+          oval 5, 10, 25
+        end
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal [0, 0, 0, 0], ov.style["fill"]
+      assert_equal [0, 0, 0, 0], ov.style["stroke"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_inherited_no_sibling
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        fill yellow
+        stroke yellow
+        stack do
+          fill blue
+          stroke darkgreen
+          stack do
+            fill aquamarine
+            stroke aquamarine
+          end
+          stack do
+            oval 5, 10, 25
+          end
+        end
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal [0, 0, 255, 255], ov.style["fill"]
+      assert_equal [0, 100, 0, 255], ov.style["stroke"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_inherited_nil_props
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        stack do
+          fill blue
+          stroke darkgreen
+          stack do
+            fill nil
+            stroke nil
+            oval 5, 10, 25
+          end
+        end
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal [0, 0, 255, 255], ov.style["fill"]
+      assert_equal [0, 100, 0, 255], ov.style["stroke"]
+    SHOES_SPEC
+  end
+
+  def test_draw_context_inherited_cancel_default
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        stack do
+          fill blue
+          stroke darkgreen
+          stack do
+            fill yellow
+            stroke yellow
+            oval 5, 10, 25
+            fill nil
+            stroke nil
+            @o2 = oval 5, 10, 25
+          end
+        end
+      end
+    SHOES_APP
+      ov = oval("@o2")
+      assert_equal [0, 0, 255, 255], ov.style["fill"]
+      assert_equal [0, 100, 0, 255], ov.style["stroke"]
+    SHOES_SPEC
+  end
+end

data/lacci/test/test_font_helper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+
+class TestFontHelper < Minitest::Test
+include FontHelper
+    def test_parse_full_font
+
+        string = "Pacifico 20px bold italic small-caps"
+
+        assert_equal(["italic", "small-caps" , "bold" , "20px" , "Pacifico"],parse_font(string))
+
+    end
+
+    def test_parse_quotesFamily
+        string = "'Times new roman', serif 20px bold italic small-caps"
+    
+        assert_equal(["italic", "small-caps", "bold", "20px", "'Times new roman', serif"],parse_font(string))
+    end
+
+    def test_parse_empty
+        string = ""
+
+        assert_equal([nil,nil,nil,nil,""],parse_font(string))
+    end
+
+    def test_parse_onlyFamily
+        string = "arial"
+
+        assert_equal([nil,nil,nil,nil,"arial"],parse_font(string))
+    end
+
+    def test_parse_onlySize
+        string = "40px"
+
+        assert_equal([nil,nil,nil,"40px",""],parse_font(string))
+    end
+
+    def test_parse_onlyFontStyle
+        string = "italic"
+
+        assert_equal(["italic",nil,nil,nil,""],parse_font(string))
+    end
+
+    def test_parse_onlyFontVariant
+        string = "small-caps"
+
+        assert_equal([nil,"small-caps",nil,nil,""],parse_font(string))
+    end
+
+    def test_parse_onlyFontWeight
+        string = "900"
+
+        assert_equal([nil,nil,"900",nil,""],parse_font(string))
+    end
+end

data/lacci/test/test_helper.rb

@@ -4,6 +4,7 @@ $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "shoes"
 
 require "scarpe/components/unit_test_helpers"
+require "scarpe/components/minitest_result"
 
 require "minitest/autorun"
 
@@ -35,29 +36,55 @@ class NienteTest < Minitest::Test
     timeout: 5.0,
     class_name: self.class,
     method_name: self.name,
-    display_service: "niente"
+    expect_process_fail: false,
+    expect_minitest_exception: false,
+    display_service: "niente",
+    log_level: "warn"
   )
+    sspec_file = File.expand_path(File.join __dir__, "niente_test.json")
+    File.unlink sspec_file rescue nil
+
     with_tempfiles([
       #["scarpe_log_config.json", JSON.dump(log_config_for_test)],
       [["shoes_spec_code", ".rb"], app_test_code],
     ]) do |shoes_spec_path,_|
       system(
         "LOCALAPPDATA=\"#{Dir.tmpdir}\" " +
+        "NIENTE_LOG_LEVEL=#{log_level} " +
         "SHOES_SPEC_TEST=\"#{shoes_spec_path}\" " +
         "SCARPE_DISPLAY_SERVICE=\"#{display_service}\" " +
-        "SHOES_MINITEST_EXPORT_FILE=niente_test.json " +
+        "SHOES_MINITEST_EXPORT_FILE=#{sspec_file} " +
         "SHOES_MINITEST_CLASS_NAME=\"#{class_name}\" " +
         "SHOES_MINITEST_METHOD_NAME=\"#{method_name}\" " +
         "ruby #{SCARPE_EXE} --dev #{test_app_location}"
       )
     end
 
+    if expect_process_fail
+      assert(false, "Expected app to fail but it succeeded!") if $?.success?
+      return
+    end
+
     # Check if the process exited normally or crashed (segfault, failure, timeout)
     unless $?.success?
-      assert(false, "Niente app failed with exit code: #{$?.exitstatus}")
+      assert(false, "App failed with exit code: #{$?.exitstatus}")
       return
     end
 
-
+    result = Scarpe::Components::MinitestResult.new(sspec_file)
+    if result.error?
+      if expect_minitest_exception
+        assert_equal true, true
+      else
+        raise result.error_message
+      end
+    elsif result.fail?
+      assert false, result.fail_message
+    elsif result.skip?
+      skip
+    else
+      # Count out the correct number of assertions
+      result.assertions.times { assert true }
+    end
   end
 end

data/lacci/test/test_lacci.rb

@@ -5,14 +5,101 @@ require_relative "test_helper"
 class TestLacci < NienteTest
   def test_simple_button_click
     run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
-    Shoes.app do
-      @b = button "OK" do
-        @b.text = "Yup"
+      Shoes.app do
+        @b = button "OK" do
+          @b.text = "Yup"
+        end
       end
-    end
     SHOES_APP
-    button().trigger_click
-    assert_equal "Yup", button().text
+      button().trigger_click
+      assert_equal "Yup", button().text
+    SHOES_SPEC
+  end
+
+  def test_positional_default_values
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        star 15, 35
+      end
+    SHOES_APP
+      s = star()
+      assert_equal 10, s.points
+      assert_equal 50, s.inner
+    SHOES_SPEC
+  end
+
+  def test_positional_args
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        star 10, 25, 8 # Leave outer and inner as default
+      end
+    SHOES_APP
+      s = star()
+      assert_equal 10, s.left
+      assert_equal 25, s.top
+      assert_equal 8, s.points
+      assert_equal 50, s.inner
+    SHOES_SPEC
+  end
+
+  def test_keyword_args
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        star 5, 6, points: 8, inner: 30
+      end
+    SHOES_APP
+      s = star()
+      assert_equal 5, s.left
+      assert_equal 6, s.top
+      assert_equal 8, s.points
+      assert_equal 100, s.outer
+      assert_equal 30, s.inner
+    SHOES_SPEC
+  end
+
+  def test_too_many_positional_args
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s = stack {}
+      end
+    SHOES_APP
+      s = stack("@s")
+      assert_raises Shoes::Errors::BadArgumentListError do
+        s.star 5, 6, 7, 8, 9, 10, 11
+      end
+    SHOES_SPEC
+  end
+
+  def test_too_few_positional_args
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s = stack {}
+      end
+    SHOES_APP
+      s = stack("@s")
+      assert_raises Shoes::Errors::BadArgumentListError do
+        s.star 5
+      end
+    SHOES_SPEC
+  end
+
+  def test_unsupported_feature
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC, expect_process_fail: true)
+      Shoes.app(features: :html) do
+        para "Not supported by Niente, though."
+      end
+    SHOES_APP
+      assert true
+    SHOES_SPEC
+  end
+
+  def test_unknown_feature
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app(features: :squid) do
+        para "No such feature, though."
+      end
+    SHOES_APP
+      assert true
     SHOES_SPEC
   end
 end

data/lacci/test/test_margin_helper.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../lib/shoes/margin_helper"
+
+
+class TestMarginHelper < Minitest::Test
+include MarginHelper
+
+    def test_one_Number_margin
+
+        kwargs = {:margin => 20}
+
+        assert_equal({:margin => nil, :margin_left => 20, :margin_top => 20, :margin_right => 20, :margin_bottom => 20},margin_parse(kwargs))
+
+    end
+
+    def test_Array_four_margin
+
+        kwargs = {:margin => [20,20,30,40]}
+
+        assert_equal({:margin => nil, :margin_left => 20, :margin_top => 20, :margin_right => 30, :margin_bottom => 40},margin_parse(kwargs))
+
+    end
+
+    def test_Array_one_margin
+
+        kwargs = {:margin => [20]}
+
+        assert_equal({:margin => nil, :margin_left => 20, :margin_top => 20, :margin_right => 20, :margin_bottom => 20},margin_parse(kwargs))
+
+    end
+
+
+    def test_String_four_margin
+
+        kwargs = {:margin => "20 30 40 50"}
+
+        assert_equal({:margin => nil, :margin_left => "20", :margin_top => "30", :margin_right => "40", :margin_bottom => "50"},margin_parse(kwargs))
+
+    end
+
+    def test_String_one_margin
+
+        kwargs = {:margin => "20"}
+
+        assert_equal({:margin => nil, :margin_left => "20", :margin_top => "20", :margin_right => "20", :margin_bottom => "20"},margin_parse(kwargs))
+
+    end
+
+    def test_Hash_four_margin
+
+        kwargs = {:margin => {left:20,top:20,right:30,bottom:30}}
+
+        assert_equal({:margin => nil, :margin_left => 20, :margin_top => 20, :margin_right => 30, :margin_bottom => 30},margin_parse(kwargs))
+
+    end
+
+    def test_Hash_three_margin
+
+        kwargs = {:margin => {top:20,right:30,bottom:30}}
+
+        assert_equal({:margin => nil, :margin_top => 20, :margin_right => 30, :margin_bottom => 30},margin_parse(kwargs))
+
+    end
+
+    def test_Hash_two_margin
+
+        kwargs = {:margin => {left:20,top:20}}
+
+        assert_equal({:margin => nil, :margin_left => 20, :margin_top => 20},margin_parse(kwargs))
+
+    end
+
+    def test_Hash_one_margin
+
+        kwargs = {:margin => {bottom:30}}
+
+        assert_equal({:margin => nil, :margin_bottom => 30},margin_parse(kwargs))
+
+    end
+
+end