lacci 0.3.0 → 0.5.0

data/lib/shoes/drawables/slot.rb

@@ -1,10 +1,31 @@
 # frozen_string_literal: true
 
 class Shoes::Slot < Shoes::Drawable
-  # @incompatibility Shoes uses #content, not #children, for this
+  # @incompatibility Shoes uses #content, not #children, for this. Scarpe does both.
   attr_reader :children
 
-  shoes_events # No Slot-specific events yet
+  shoes_events # No Slot-specific events
+
+  # This only shows this specific slot's settings, not its parent's.
+  # Use current_draw_context to allow inheritance.
+  attr_reader :draw_context
+
+
+  def initialize(...)
+    # The draw context tracks current settings like fill and stroke,
+    # plus potentially other current state that changes from drawable
+    # to drawable and slot to slot.
+    @draw_context = {
+      "fill" => nil,
+      "stroke" => nil,
+      "strokewidth" => nil,
+      "rotate" => nil,
+      # "transform" => nil, # "corner",
+      # "translate" => nil, # [0, 0],
+    }
+
+    super
+  end
 
   # Do not call directly, use set_parent
   def remove_child(child)
@@ -29,30 +50,101 @@ class Shoes::Slot < Shoes::Drawable
 
   # We use method_missing for drawable-creating methods like "button".
   # The parent's method_missing will auto-create Shoes style getters and setters.
+  # This is similar to the method_missing in Shoes::App, but differs in where
+  # the new drawable will appear.
   def method_missing(name, *args, **kwargs, &block)
     klass = ::Shoes::Drawable.drawable_class_by_name(name)
     return super unless klass
 
     ::Shoes::Slot.define_method(name) do |*args, **kwargs, &block|
-      # Look up the Shoes drawable and create it...
-      drawable_instance = klass.new(*args, **kwargs, &block)
+      instance = nil
 
-      unless klass.ancestors.include?(::Shoes::TextDrawable)
-        drawable_instance.set_parent self # Create drawable in THIS SLOT, not current app slot
+      # Look up the Shoes drawable and create it. But first set
+      # this slot as the current one so that draw context
+      # is handled properly.
+      @app.with_slot(self) do
+        Shoes::Drawable.with_current_app(self.app) do
+          instance = klass.new(*args, **kwargs, &block)
+        end
       end
 
-      drawable_instance
+      instance
     end
 
     send(name, *args, **kwargs, &block)
   end
 
   def respond_to_missing?(name, include_private = false)
-    return true if Drawable.drawable_class_by_name(name.to_s)
+    return true if ::Shoes::Drawable.drawable_class_by_name(name.to_s)
 
     false
   end
 
+  # Draw context methods
+
+  # Set the default fill color in this slot and child slots.
+  # Pass nil for "no setting", so that it can inherit defaults.
+  #
+  # @param color [Nil,Color] a Shoes color for the fill color or nil to use parent setting
+  # @return [void]
+  def fill(color)
+    @draw_context["fill"] = color
+  end
+
+  # Set the default fill in this slot and child slots to transparent.
+  #
+  # @return [void]
+  def nofill
+    @draw_context["fill"] = rgb(0, 0, 0, 0)
+  end
+
+  # Set the default stroke color in this slot and child slots.
+  # Pass nil for "no setting" so it can inherit defaults.
+  #
+  # @param color [Nil,Color] a Shoes color for the stroke color or nil to use parent setting
+  # @return [void]
+  def stroke(color)
+    @draw_context["stroke"] = color
+  end
+
+  # Set the default strokewidth in this slot and child slots.
+  # Pass nil for "no setting".
+  #
+  # @param width [Numeric,Nil] the new width, or nil to use parent setting
+  # @return [void]
+  def strokewidth(width)
+    @draw_context["strokewidth"] = width
+  end
+
+  # Set the default stroke in this slot and child slots
+  # to transparent.
+  #
+  # @return [void]
+  def nostroke
+    @draw_context["stroke"] = rgb(0, 0, 0, 0)
+  end
+
+  # Set the current rotation in this slot and any child slots.
+  # Pass nil to reset the angle to default.
+  #
+  # @param angle [Numeric,Nil] the new default rotation for shapes or nil to use parent setting
+  # @return [void]
+  def rotate(angle)
+    @draw_context["rotate"] = angle
+  end
+
+  # Get the current draw context styles, based on this slot and its parent slots.
+  #
+  # @return [Hash] a hash of Shoes styles for the context
+  def current_draw_context
+    s = @parent ? @parent.current_draw_context : {}
+    @draw_context.each { |k, v| s[k] = v unless v.nil? }
+
+    s
+  end
+
+  # Methods to add or remove children
+
   # Remove all children from this drawable. If a block
   # is given, call the block to replace the children with
   # new contents from that block.
@@ -65,6 +157,7 @@ class Shoes::Slot < Shoes::Drawable
   # @yield The block to call to replace the contents of the drawable (optional)
   # @return [void]
   def clear(&block)
+    @children ||= []
     @children.dup.each(&:destroy)
     append(&block) if block_given?
     nil
@@ -82,6 +175,6 @@ class Shoes::Slot < Shoes::Drawable
     raise(Shoes::Errors::InvalidAttributeValueError, "append requires a block!") unless block_given?
     raise(Shoes::Errors::InvalidAttributeValueError, "Don't append to something that isn't a slot!") unless self.is_a?(Shoes::Slot)
 
-    Shoes::App.instance.with_slot(self, &block)
+    @app.with_slot(self, &block)
   end
 end

data/lib/shoes/drawables/stack.rb

@@ -3,24 +3,19 @@
 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
-      Shoes::App.instance.with_slot(self, &block) if block_given?
+
+      # Create the display-side drawable *before* running the block.
+      # Then child drawables have a parent to add themselves to.
+      @app.with_slot(self, &block) if block_given?
     end
   end
 end

data/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
+      @draw_context = @app.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/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/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/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,12 +62,12 @@ 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)
 
       # Do Widgets do this?
-      Shoes::App.instance.with_slot(self, &block) if block
+      @app.with_slot(self, &block) if block
     end
     @midway_through_adding_initialize = false
   end

data/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/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/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