scarpe 0.3.0 → 0.4.0

data/lacci/lib/shoes/drawables/stack.rb

@@ -3,23 +3,18 @@
 class Shoes
   class Stack < Shoes::Slot
     include Shoes::Background
-    include Shoes::Border
-    include Shoes::Spacing
 
-    # TODO: sort out various margin and padding properties, including putting stuff into spacing
-    shoes_styles :width, :height, :scroll
+    shoes_styles :scroll
 
-    shoes_events # No Stack-specific events yet
-
-    def initialize(width: nil, height: nil, margin: nil, padding: nil, scroll: false, margin_top: nil, margin_bottom: nil, margin_left: nil,
-      margin_right: nil, **options, &block)
-
-      @options = options
+    shoes_events # No Stack-specific events
 
+    def initialize(*args, **kwargs, &block)
       super
 
       create_display_drawable
-      # Create the display-side drawable *before* running the block, which will add child drawables with their display drawables
+
+      # Create the display-side drawable *before* running the block.
+      # Then child drawables have a parent to add themselves to.
       Shoes::App.instance.with_slot(self, &block) if block_given?
     end
   end

data/lacci/lib/shoes/drawables/star.rb

@@ -8,43 +8,21 @@ class Shoes
     shoes_style(:outer) { |val| convert_to_float(val, "outer") }
     shoes_style(:inner) { |val| convert_to_float(val, "inner") }
 
-    shoes_events # No Star-specific events yet
+    Shoes::Drawable.drawable_default_styles[Shoes::Star][:points] = 10
+    Shoes::Drawable.drawable_default_styles[Shoes::Star][:outer] = 100
+    Shoes::Drawable.drawable_default_styles[Shoes::Star][:inner] = 50
 
-    def initialize(left, top, points = 10, outer = 100, inner = 50)
+    shoes_events # No Star-specific events
+
+    init_args :left, :top
+    opt_init_args :points, :outer, :inner
+    def initialize(*args, **kwargs)
       super
-      self.left = left
-      self.top = top
-      self.points = points
-      self.outer = outer
-      self.inner = inner
 
       @draw_context = Shoes::App.instance.current_draw_context
 
       create_display_drawable
     end
 
-    def self.convert_to_integer(value, attribute_name)
-      begin
-        value = Integer(value)
-        raise Shoes::Errors::InvalidAttributeValueError, "Negative num '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
-
-        value
-      rescue ArgumentError
-        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
-        raise Shoes::Errors::InvalidAttributeValueError, error_message
-      end
-    end
-
-    def self.convert_to_float(value, attribute_name)
-      begin
-        value = Float(value)
-        raise Shoes::Errors::InvalidAttributeValueError, "Negative num '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
-
-        value
-      rescue ArgumentError
-        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
-        raise Shoes::Errors::InvalidAttributeValueError, error_message
-      end
-    end
   end
 end

data/lacci/lib/shoes/drawables/text_drawable.rb

@@ -4,60 +4,119 @@ class Shoes
   # TextDrawable is the parent class of various classes of
   # text that can go inside a para. This includes normal
   # text, but also links, italic text, bold text, etc.
+  #
+  # In Shoes3 this corresponds to cText, and it would
+  # have methods app, contents, children, parent,
+  # style, to_s, text, text= and replace.
+  #
+  # Much of what this does and how is similar to Para.
+  # It's a very similar API.
   class TextDrawable < Shoes::Drawable
-    class << self
-      # rubocop:disable Lint/MissingSuper
-      def inherited(subclass)
-        Shoes::Drawable.drawable_classes ||= []
-        Shoes::Drawable.drawable_classes << subclass
-
-        Shoes::Drawable.drawable_default_styles ||= {}
-        Shoes::Drawable.drawable_default_styles[subclass] = {}
+    shoes_styles :text_items, :size, :stroke, :strokewidth, :fill, :undercolor, :font
+
+    STRIKETHROUGH_VALUES = [nil, "none", "single"]
+    shoes_style :strikethrough do |val, _name|
+      unless STRIKETHROUGH_VALUES.include?(val)
+        raise Shoes::Errors::InvalidAttributeValueError, "Strikethrough must be one of: #{STRIKETHROUGH_VALUES.inspect}!"
+      end
+      val
+    end
+
+    UNDERLINE_VALUES = [nil, "none", "single", "double", "low", "error"]
+    shoes_style :underline do |val, _name|
+      unless UNDERLINE_VALUES.include?(val)
+        raise Shoes::Errors::InvalidAttributeValueError, "Underline must be one of: #{UNDERLINE_VALUES.inspect}!"
       end
-      # rubocop:enable Lint/MissingSuper
+      val
     end
 
     shoes_events # No TextDrawable-specific events yet
-  end
 
-  class << self
-    def default_text_drawable_with(element)
-      class_name = element.capitalize
+    def initialize(*args, **kwargs)
+      # Don't pass text_children args to Drawable#initialize
+      super(*[], **kwargs)
 
-      drawable_class = Class.new(Shoes::TextDrawable) do
-        # Can we just change content to text to match the Shoes API?
-        shoes_style :content
+      # Text_children alternates strings and TextDrawables, so we can't just pass
+      # it as a Shoes style. It won't serialize.
+      update_text_children(args)
 
-        def initialize(content)
-          super
+      create_display_drawable
+    end
 
-          @content = content
+    def text_children_to_items(text_children)
+      text_children.map { |arg| arg.is_a?(TextDrawable) ? arg.linkable_id : arg.to_s }
+    end
 
-          create_display_drawable
-        end
+    # Sets the paragraph text to a new value, which can
+    # include {TextDrawable}s like em(), strong(), etc.
+    #
+    # @param children [Array] the arguments can be Strings and/or TextDrawables
+    # @return [void]
+    def replace(*children)
+      update_text_children(children)
+    end
 
-        def text
-          self.content
-        end
+    # Set the paragraph text to a single String.
+    # To use bold, italics, etc. use {Para#replace} instead.
+    #
+    # @param child [String] the new text to use for this Para
+    # @return [void]
+    def text=(*children)
+      update_text_children(children)
+    end
 
-        def to_s
-          self.content
-        end
+    # Return the text, but not the styling, of the para's
+    # contents. For example, if the contents had strong
+    # and emphasized text, the bold and emphasized would
+    # be removed but the text would be returned.
+    #
+    # @return [String] the text from this para
+    def text
+      @text_children.map(&:to_s).join
+    end
 
-        def text=(new_text)
-          self.content = new_text
-        end
-      end
-      Shoes.const_set class_name, drawable_class
-      drawable_class.class_eval do
-        shoes_style :content
+    # Return the text but not styling from the para. This
+    # is the same as #text.
+    #
+    # @return [String] the text from this para
+    def to_s
+      self.text
+    end
+
+    private
+
+    # Text_children alternates strings and TextDrawables, so we can't just pass
+    # it as a Shoes style. It won't serialize.
+    def update_text_children(children)
+      @text_children = children.flatten
+      # This should signal the display drawable to change
+      self.text_items = text_children_to_items(@text_children)
+    end
+  end
 
+  class << self
+    def default_text_drawable_with(element)
+      class_name = element.capitalize
+
+      drawable_class = Class.new(Shoes::TextDrawable) do
         shoes_events # No specific events
+
+        init_args # We're going to pass an empty array to super
       end
+      Shoes.const_set class_name, drawable_class
     end
   end
 end
 
 Shoes.default_text_drawable_with(:code)
+Shoes.default_text_drawable_with(:del)
 Shoes.default_text_drawable_with(:em)
 Shoes.default_text_drawable_with(:strong)
+Shoes.default_text_drawable_with(:span)
+Shoes.default_text_drawable_with(:sub)
+Shoes.default_text_drawable_with(:sup)
+Shoes.default_text_drawable_with(:ins) # in Shoes3, looks like "ins" is just underline
+
+# Defaults must come *after* classes are defined
+
+Shoes::Drawable.drawable_default_styles[Shoes::Ins][:underline] = "single"

data/lacci/lib/shoes/drawables/video.rb

@@ -5,9 +5,10 @@ class Shoes
     shoes_styles :url
     shoes_events # No specific events yet
 
-    def initialize(url)
+    init_args :url
+    def initialize(*args, **kwargs)
       super
-      @url = url
+
       create_display_drawable
     end
 

data/lacci/lib/shoes/drawables/widget.rb

@@ -37,11 +37,16 @@
 
 class Shoes::Widget < Shoes::Slot
   include Shoes::Background
-  include Shoes::Border
-  include Shoes::Spacing
 
   shoes_events
 
+  def self.inherited(subclass)
+    super
+
+    # Widgets are special - we can't know in advance what sort of initialize args they take
+    subclass.init_args :any
+  end
+
   def self.method_added(name)
     # We're only looking for the initialize() method, and only on subclasses
     # of Shoes::Widget, not Shoes::Widget itself.
@@ -57,7 +62,7 @@ class Shoes::Widget < Shoes::Slot
     @midway_through_adding_initialize = true
     define_method(:initialize) do |*args, **kwargs, &block|
       super(*args, **kwargs, &block)
-      @options = kwargs
+      @options = kwargs # Get rid of options?
       create_display_drawable
       __widget_initialize(*args, **kwargs, &block)
 

data/lacci/lib/shoes/drawables.rb

@@ -15,6 +15,7 @@ require "shoes/drawables/line"
 require "shoes/drawables/rect"
 require "shoes/drawables/shape"
 require "shoes/drawables/star"
+require "shoes/drawables/oval"
 require "shoes/drawables/arrow"
 
 require "shoes/drawables/button"
@@ -26,6 +27,6 @@ require "shoes/drawables/link"
 require "shoes/drawables/list_box"
 require "shoes/drawables/para"
 require "shoes/drawables/radio"
-require "shoes/drawables/span"
 require "shoes/drawables/video"
 require "shoes/drawables/progress"
+require "shoes/drawables/border"

data/lacci/lib/shoes/errors.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Shoes; end
-class Shoes::Errors
+module Shoes::Errors
   class InvalidAttributeValueError < Shoes::Error; end
 
   class TooManyInstancesError < Shoes::Error; end
@@ -16,13 +16,23 @@ class Shoes::Errors
 
   class NoSuchStyleError < Shoes::Error; end
 
-  class NoLinkableIdError < Shoes::Error; end
+  class NoSuchLinkableIdError < Shoes::Error; end
 
   class BadLinkableIdError < Shoes::Error; end
 
-  class UnregisteredShoesEvent < 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/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.rb

@@ -37,8 +37,6 @@ require_relative "shoes/colors"
 require_relative "shoes/builtins"
 
 require_relative "shoes/background"
-require_relative "shoes/border"
-require_relative "shoes/spacing"
 
 require_relative "shoes/drawable"
 require_relative "shoes/app"
@@ -76,6 +74,7 @@ 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(
@@ -83,9 +82,11 @@ class 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

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