scarpe 0.2.2 → 0.4.0

data/lacci/lib/shoes/errors.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Shoes; end
+module Shoes::Errors
+  class InvalidAttributeValueError < Shoes::Error; end
+
+  class TooManyInstancesError < Shoes::Error; end
+
+  class NoSuchListItemError < Shoes::Error; end
+
+  class DuplicateCreateDrawableError < Shoes::Error; end
+
+  class MultipleDrawablesFoundError < Shoes::Error; end
+
+  class NoDrawablesFoundError < Shoes::Error; end
+
+  class NoSuchStyleError < Shoes::Error; end
+
+  class NoSuchLinkableIdError < Shoes::Error; end
+
+  class BadLinkableIdError < Shoes::Error; end
+
+  class UnregisteredShoesEventError < Shoes::Error; end
+
+  class BadArgumentListError < Shoes::Error; end
+
+  class SingletonError < Shoes::Error; end
+
+  class MultipleShoesSpecRunsError < Shoes::Error; end
+
+  class UnsupportedFeatureError < Shoes::Error; end
+
+  class BadFilenameError < Shoes::Error; end
+
+  class UnknownEventsForClassError < Shoes::Error; end
+
+  class DoubleRegisteredShoesEventError < Shoes::Error; end
+end

data/lacci/lib/shoes/log.rb

@@ -8,7 +8,7 @@
 # If used alone, this will fail because the @instance is nil. It needs
 # an implementation to be plugged in.
 
-module Shoes
+class Shoes
   LOG_LEVELS = [:debug, :info, :warn, :error, :fatal].freeze
 
   # Include this module to get a @log instance variable to log as your
@@ -28,7 +28,7 @@ module Shoes
       attr_reader :current_log_config
 
       def instance=(impl_object)
-        raise(Shoes::Error, "Already have an instance for Shoes::Log!") if @instance
+        raise(Shoes::Errors::TooManyInstancesError, "Already have an instance for Shoes::Log!") if @instance
 
         @instance = impl_object
       end

data/lacci/lib/shoes/margin_helper.rb

@@ -0,0 +1,79 @@
+module MarginHelper
+
+  def margin_parse(kwargs)
+
+      if kwargs[:margin]
+
+        if kwargs[:margin].is_a?(Numeric)
+
+          if !kwargs[:margin_top]
+            kwargs[:margin_top] = kwargs[:margin]
+          end
+          if !kwargs[:margin_bottom]
+            kwargs[:margin_bottom] = kwargs[:margin]
+          end
+          if !kwargs[:margin_left]
+            kwargs[:margin_left] = kwargs[:margin]
+          end
+          if !kwargs[:margin_right]
+            kwargs[:margin_right] = kwargs[:margin]
+          end
+
+        elsif kwargs[:margin].is_a?(Hash)
+
+          kwargs[:margin].each do |key,value|
+            kwargs[:"margin_#{key}"] = value
+          end
+
+        else
+          margin_props = kwargs[:margin].is_a?(String) ? kwargs[:margin].split(/\s+|\,|-/) : kwargs[:margin]
+          if margin_props.length == 1
+
+            if !kwargs[:margin_top]
+              kwargs[:margin_top] = margin_props[0]
+            end
+            if !kwargs[:margin_bottom]
+              kwargs[:margin_bottom] = margin_props[0]
+            end
+            if !kwargs[:margin_left]
+              kwargs[:margin_left] = margin_props[0]
+            end
+            if !kwargs[:margin_right]
+              kwargs[:margin_right] = margin_props[0]
+            end
+
+          elsif margin_props.length == 2
+  
+            raise(Shoes::Errors::InvalidAttributeValueError, "Margin don't support 2-3 values as Array/string input for using 2-3 input you can use the hash input method like '{left:value, right:value, top:value, bottom:value}'")
+  
+          elsif margin_props.length == 3
+  
+            raise(Shoes::Errors::InvalidAttributeValueError, "Margin don't support 2-3 values as Array/string input for using 2-3 input you can use the hash input method like '{left:value,right:value,top:value,bottom:value}'")
+          
+          else
+  
+            if !kwargs[:margin_top]
+              kwargs[:margin_top] = margin_props[1]
+            end
+            if !kwargs[:margin_bottom]
+              kwargs[:margin_bottom] = margin_props[3]
+            end
+            if !kwargs[:margin_left]
+              kwargs[:margin_left] = margin_props[0]
+            end
+            if !kwargs[:margin_right]
+              kwargs[:margin_right] = margin_props[2]
+            end
+  
+          end
+        end
+        kwargs[:margin] = nil
+      end
+      if kwargs["options"] && !kwargs[:margin] && !kwargs[:margin_left] && !kwargs[:margin_right] && !kwargs[:margin_top] && !kwargs[:margin_bottom]
+        kwargs[options].each do |key,value|
+          kwargs[key] = value
+        end
+      end
+      kwargs
+  end
+end

data/lacci/lib/shoes/ruby_extensions.rb

@@ -0,0 +1,15 @@
+
+class Range
+  def rand
+    conv = (Integer === self.end && Integer === self.begin ? :to_i : :to_f)
+    ((Kernel.rand * (self.end - self.begin)) + self.begin).send(conv)
+  end
+end
+
+unless Time.respond_to? :today
+  def Time.today
+    t = Time.now
+    t - (t.to_i % 86_400)
+  end
+end
+

data/lacci/lib/shoes-spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+class Shoes
+  # A Scarpe-compatible display service can set Shoes::Spec.instance to
+  # a ShoesSpec testing class, and use it to run Shoes-Spec code.
+  # A Shoes application should never do this. It's intended to be used
+  # by display services.
+  module Spec
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(spec_inst)
+      if @instance && @instance != spec_inst
+        raise "Lacci can only use a single ShoesSpec implementation at one time!"
+      end
+
+      @instance = spec_inst
+    end
+  end
+
+  # ShoesSpec testing objects can optionally inherit from this object,
+  # which shows the ShoesSpec testing API.
+  #
+  # @see {Shoes::Spec.instance=}
+  class SpecInstance
+    # Once a Shoes app has been created, this method can be called to
+    # execute Shoes-Spec testing code for that application. Shoes-Spec
+    # uses Minitest for most of its APIs, and Minitest generally reports
+    # results with a class name and test name. If those aren't passed
+    # explicitly, the SpecInstance can choose reasonable defaults.
+    #
+    # The test code should be set up to run automatically from the
+    # display service's existing hooks. For instance, the code might
+    # run in response to the first heartbeat, if the display service
+    # uses heartbeats.
+    #
+    # The test code will export assertion data in its native format.
+    # Multiple display services choose to use the Scarpe-Component
+    # for Minitest data export, which is straightforward to import
+    # into the Shoes-Spec test harness.
+    #
+    # @param code [String] the ShoesSpec code to execute
+    # @param class_name [String|NilClass] the Minitest class name for reporting or nil
+    # @param test_name [String|NilClass] the Minitest test name for reporting or nil
+    # @return [void]
+    def run_shoes_spec_test_code(code, class_name: nil, test_name: nil)
+      raise "Child class should override this!"
+    end
+  end
+
+  # ShoesSpec instances support finder methods like button() that return
+  # a proxy to the corresponding drawable. Those proxies should support
+  # standard Shoes::Drawable methods, including the ones appropriate to
+  # the same drawable object. They should also support certain other
+  # testing-specific methods like "trigger_click" that are used to
+  # simulate display-side events during testing.
+  #
+  # Keep in mind that a proxy will often be in a different process from
+  # the Shoes app. So the proxy can't portably return the object or
+  # display object, though it could possibly return another proxy for such
+  # a thing.
+  class SpecProxy
+    # The proxy will have finder methods for all drawables, such as
+    # button(), edit_line(), etc. How to document those?
+
+    # Trigger a click on a button or button-like drawable. Not every
+    # drawable will support this operation.
+    def trigger_click()
+      raise "Child class should override this!"
+    end
+
+    # Trigger a hover over a hoverable drawable. Not every
+    # drawable will support this operation. A drawable that supports
+    # hover should support leave and vice-versa.
+    def trigger_hover()
+      raise "Child class should override this!"
+    end
+
+    # Trigger ending hover over a hoverable drawable. Not every
+    # drawable will support this operation. A drawable that supports
+    # hover should support leave and vice-versa.
+    def trigger_leave()
+      raise "Child class should override this!"
+    end
+
+    # Trigger a change in value for a drawable like a list_box
+    # with multiple values.
+    def trigger_change(value)
+      raise "Child class should override this!"
+    end
+  end
+end

data/lacci/lib/shoes.rb

@@ -12,38 +12,51 @@ if RUBY_VERSION[0..2] < "3.2"
   exit(-1)
 end
 
-module Shoes; end
+class Shoes; end
 class Shoes::Error < StandardError; end
+require_relative "shoes/errors"
 
 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/log"
 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/builtins"
+
 require_relative "shoes/background"
-require_relative "shoes/border"
-require_relative "shoes/spacing"
 
-require_relative "shoes/widget"
+require_relative "shoes/drawable"
 require_relative "shoes/app"
-require_relative "shoes/widgets"
+require_relative "shoes/drawables"
 
 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"
+
 # The module containing Shoes in all its glory.
 # Shoes is a platform-independent GUI library, designed to create
 # small visual applications in Ruby.
 #
-module Shoes
+class Shoes
   class << self
     # Creates a Shoes app with a new window. The block parameter is used to create
-    # widgets and set up handlers. Arguments are passed to Shoes::App.new internally.
+    # drawables and set up handlers. Arguments are passed to Shoes::App.new internally.
     #
     # @incompatibility In Shoes3, this method will return normally.
     #   In Scarpe, after the block is executed, the method will not return and Scarpe
@@ -61,6 +74,7 @@ module 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(
@@ -68,9 +82,11 @@ module 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)
       app.init
       app.run
       nil
@@ -81,11 +97,16 @@ module Shoes
     # more loaders, a Lacci-based display library can accept new file formats as
     # well, not just raw Shoes .rb files.
     #
-    # @param path [String] The current-dir-relative path to the file
+    # @param relative_path [String] The current-dir-relative path to the file
     # @return [void]
     # @see Shoes.add_file_loader
     def run_app(relative_path)
       path = File.expand_path relative_path
+      dir = File.dirname(path)
+
+      # Shoes assumes we're starting from the app code's path
+      Dir.chdir(dir)
+
       loaded = false
       file_loaders.each do |loader|
         if loader.call(path)

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

@@ -3,7 +3,88 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "shoes"
 
+require "scarpe/components/unit_test_helpers"
+require "scarpe/components/minitest_result"
+
 require "minitest/autorun"
 
 require "minitest/reporters"
 Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
+
+# For testing Lacci, it's kind of silly to start a Webview application.
+# They're slow, unreliable and memory-hungry. So instead we start a
+# Niente do-nothing application for a simple API test. It's a lot like
+# mocking.
+class NienteTest < Minitest::Test
+  include ::Scarpe::Test::Helpers
+
+  SCARPE_EXE = File.expand_path("../../exe/scarpe", __dir__)
+
+  def run_test_niente_code(
+    scarpe_app_code,
+    test_extension: ".rb",
+    **opts
+  )
+    with_tempfile(["scarpe_test_app", test_extension], scarpe_app_code) do |test_app_location|
+      run_test_niente_app(test_app_location, **opts)
+    end
+  end
+
+  def run_test_niente_app(
+    test_app_location,
+    app_test_code: "",
+    timeout: 5.0,
+    class_name: self.class,
+    method_name: self.name,
+    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=#{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, "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