scarpe 0.2.1 → 0.2.2

data/lacci/lib/shoes/download.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Widget
+    class ResponseWrapper
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def headers
+        @response.each_header.to_h
+      end
+
+      def body
+        @response.body
+      end
+    end
+
+    def download(url, method: "GET", save: nil, styles: {}, &block)
+      require "net/http"
+      require "openssl"
+      require "nokogiri"
+
+      @block = block
+
+      Thread.new do
+        logger = Shoes::Log.logger("Shoes::App#download")
+        begin
+          uri = URI(url)
+          response = perform_request(uri, method, styles)
+
+          if response.is_a?(Net::HTTPRedirection)
+            new_location = response["location"]
+            new_uri = URI(new_location)
+            response = perform_request(new_uri, method, styles)
+          end
+
+          wrapped_response = ResponseWrapper.new(response) # Wrap the response
+          handle_response(wrapped_response, save, styles)
+        rescue Net::HTTPError, Net::OpenTimeout, Net::ReadTimeout => e
+          handle_error(e, logger)
+        rescue StandardError => e
+          handle_error(e.message, logger) # Pass the error message as a string
+        end
+      end
+    end
+
+    private
+
+    def perform_request(uri, method, styles)
+      port = uri.port || (uri.scheme == "https" ? 443 : 80)
+      http = Net::HTTP.start(uri.host, port, use_ssl: uri.scheme == "https", verify_mode: OpenSSL::SSL::VERIFY_NONE)
+
+      request = Net::HTTP.const_get(method.capitalize).new(uri.request_uri)
+      apply_styles(request, styles)
+
+      http.request(request)
+    end
+
+    def apply_styles(request, styles)
+      headers = styles[:headers]
+      request["Content-Type"] = headers["Content-Type"] if headers && headers["Content-Type"]
+      request.body = styles[:body] if styles[:body]
+      # Add more custom styles to the request as needed
+    end
+
+    def handle_response(response, save, styles)
+      case response.response.code.to_i
+      when 200..299
+        content = response.body
+        # headers = response.headers # Access headers directly
+        if save
+          save_content(content, save)
+          parse_rss(content) # Parse the downloaded XML content
+        else
+          handle_finish_event(response) # Pass response and headers to handle_finish_event
+        end
+      else
+        handle_failure(response.response.code)
+      end
+    end
+
+    def save_content(content, file_name)
+      file = nil
+      begin
+        file = File.open(file_name, "w")
+        file.write(content)
+      rescue Errno::EACCES, Errno::ENOENT => e
+        raise FileError, "File error occurred: #{e.message}"
+      else
+        @block&.call
+      ensure
+        file&.close
+      end
+    end
+
+    def handle_finish_event(response)
+      passed = Struct.new(:response).new(response) # Create a new Struct with response attribute
+      @block&.call(passed) # Pass it ok
+    end
+
+    def handle_failure(code, logger)
+      logger.error("Failed to download content. Response code: #{code}")
+    end
+
+    def handle_error(error, logger)
+      logger.error("An error occurred while downloading: #{error}")
+    end
+
+    def parse_rss(content)
+      doc = Nokogiri::XML(content)
+      items = doc.xpath("//item")
+      items.each do |item|
+        item.xpath("title").text
+        item.xpath("link").text
+        item.xpath("description").text
+        # Do something with the parsed content or use it if needed
+      end
+    end
+  end
+end

data/lacci/lib/shoes/log.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Old-style Shoes logging is really simple. We need more logging for our
+# framework, so we add a not-included-in-old-Shoes module for it. This adds
+# the *possibility* of logging, but Scarpe includes a much more
+# comprehensive solution that plugs into this one.
+
+# If used alone, this will fail because the @instance is nil. It needs
+# an implementation to be plugged in.
+
+module Shoes
+  LOG_LEVELS = [:debug, :info, :warn, :error, :fatal].freeze
+
+  # Include this module to get a @log instance variable to log as your
+  # configured component.
+  module Log
+    # These constants will wind up included in a lot of places. Should they move?
+    DEFAULT_COMPONENT = "default"
+    DEFAULT_LOG_CONFIG = {
+      "default" => "info",
+    }
+    DEFAULT_DEBUG_LOG_CONFIG = {
+      "default" => "debug",
+    }
+
+    class << self
+      attr_reader :instance
+      attr_reader :current_log_config
+
+      def instance=(impl_object)
+        raise(Shoes::Error, "Already have an instance for Shoes::Log!") if @instance
+
+        @instance = impl_object
+      end
+
+      def logger(component = self)
+        @instance.logger_for_component(component)
+      end
+
+      def configure_logger(log_config)
+        @instance.configure_logger(log_config)
+      end
+    end
+
+    def log_init(component = self)
+      @log = Shoes::Log.instance.logger_for_component(component)
+    end
+  end
+
+  class LoggedWrapper
+    include ::Shoes::Log
+    def initialize(instance, component = instance)
+      log_init(component)
+
+      @instance = instance
+    end
+
+    def method_missing(method, ...)
+      self.singleton_class.define_method(method) do |*args, **kwargs, &block|
+        ret = @instance.send(method, *args, **kwargs, &block)
+        @log.info("Method: #{method} Args: #{args.inspect} KWargs: #{kwargs.inspect} Block: #{block ? "y" : "n"} Return: #{ret.inspect}")
+        ret
+      end
+      send(method, ...)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @instance.respond_to_missing?(method_name, include_private)
+    end
+  end
+end

data/lacci/lib/shoes/spacing.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Shoes
+  module Spacing
+    def self.included(includer)
+      includer.display_properties :margin, :padding, :margin_top, :margin_left, :margin_right, :margin_bottom, :options
+    end
+  end
+end

data/{lib/scarpe → lacci/lib/shoes}/widget.rb

@@ -1,26 +1,25 @@
 # frozen_string_literal: true
 
-# Scarpe::Widget
-#
-# Interface:
-# A Scarpe::Widget defines the "element" method to indicate that it has custom markup of
-# some kind. A Widget with no element method renders as its children's markup, joined.
-
-class Scarpe
-  class Widget < DisplayService::Linkable
-    include Scarpe::Log
-    include Scarpe::Colors
+module Shoes
+  # Shoes::Widget
+  #
+  # This is the display-service portable Shoes Widget interface. Visible Shoes
+  # widgets like buttons inherit from this. Compound widgets made of multiple
+  # different smaller Widgets inherit from it in their various apps or libraries.
+  # The Shoes Widget helps build a Shoes-side widget tree, with parents and
+  # children. Any API that applies to all widgets (e.g. remove) should be
+  # defined here.
+  #
+  class Widget < Shoes::Linkable
+    include Shoes::Log
+    include Shoes::Colors
 
     class << self
-      attr_accessor :widget_classes, :alias_name
-
-      def alias_as(name)
-        self.alias_name = name
-      end
+      attr_accessor :widget_classes
 
       def inherited(subclass)
-        self.widget_classes ||= []
-        self.widget_classes << subclass
+        Shoes::Widget.widget_classes ||= []
+        Shoes::Widget.widget_classes << subclass
         super
       end
 
@@ -30,7 +29,7 @@ class Scarpe
       end
 
       def widget_class_by_name(name)
-        widget_classes.detect { |k| k.dsl_name == name.to_s || k.alias_name.to_s == name.to_s }
+        widget_classes.detect { |k| k.dsl_name == name.to_s }
       end
 
       private
@@ -56,19 +55,26 @@ class Scarpe
         linkable_properties_hash[name] = true
       end
 
+      # Add these names as display properties
       def display_properties(*names)
         names.each { |n| display_property(n) }
       end
 
       def display_property_names
-        linkable_properties.map { |prop| prop[:name] }
+        parent_prop_names = self != Shoes::Widget ? self.superclass.display_property_names : []
+
+        parent_prop_names | linkable_properties.map { |prop| prop[:name] }
       end
 
       def display_property_name?(name)
-        linkable_properties_hash[name.to_s]
+        linkable_properties_hash[name.to_s] ||
+          (self != Shoes::Widget && superclass.display_property_name?(name))
       end
     end
 
+    # Shoes uses a "hidden" style property for hide/show
+    display_property :hidden
+
     def initialize(*args, **kwargs)
       log_init("Widget")
 
@@ -81,6 +87,14 @@ class Scarpe
       super() # linkable_id defaults to object_id
     end
 
+    def inspect
+      "#<#{self.class}:#{self.object_id} " +
+        "@linkable_id=#{@linkable_id.inspect} @parent=#{@parent.inspect} " +
+        "@children=#{@children.inspect} properties=#{display_property_values.inspect}>"
+    end
+
+    private
+
     def bind_self_event(event_name, &block)
       raise("Widget has no linkable_id! #{inspect}") unless linkable_id
 
@@ -91,24 +105,31 @@ class Scarpe
       bind_shoes_event(event_name:, &block)
     end
 
-    def display_properties
+    public
+
+    def display_property_values
+      all_property_names = self.class.display_property_names
+
       properties = {}
-      self.class.display_property_names.each do |prop|
+      all_property_names.each do |prop|
         properties[prop] = instance_variable_get("@" + prop)
       end
       properties["shoes_linkable_id"] = self.linkable_id
       properties
     end
 
+    private
+
     def create_display_widget
       klass_name = self.class.name.delete_prefix("Scarpe::").delete_prefix("Shoes::")
 
       # Should we save a reference to widget for later reference?
-      DisplayService.display_service.create_display_widget_for(klass_name, self.linkable_id, display_properties)
+      ::Shoes::DisplayService.display_service.create_display_widget_for(klass_name, self.linkable_id, display_property_values)
     end
 
+    public
+
     attr_reader :parent
-    attr_reader :children
 
     def set_parent(new_parent)
       @parent&.remove_child(self)
@@ -117,28 +138,27 @@ class Scarpe
       send_shoes_event(new_parent.linkable_id, event_name: "parent", target: linkable_id)
     end
 
-    # Do not call directly, use set_parent
-    def remove_child(child)
-      @children ||= []
-      unless @children.include?(child)
-        @log.warn("remove_child: no such child(#{child.inspect}) for parent(#{parent.inspect})!")
-      end
-      @children.delete(child)
+    # Removes the element from the Shoes::Widget tree
+    def destroy
+      @parent&.remove_child(self)
+      send_shoes_event(event_name: "destroy", target: linkable_id)
     end
+    alias_method :remove, :destroy
 
-    # Do not call directly, use set_parent
-    def add_child(child)
-      @children ||= []
-      @children << child
+    # Hide the widget.
+    def hide
+      self.hidden = true
     end
 
-    # Removes the element from the Scarpe::Widget tree
-    def destroy
-      @parent&.remove_child(self)
-      send_shoes_event(event_name: "destroy", target: linkable_id)
+    # Show the widget.
+    def show
+      self.hidden = false
     end
 
-    alias_method :destroy_self, :destroy
+    # Hide the widget if it is currently shown. Show it if it is currently hidden.
+    def toggle
+      self.hidden = !self.hidden
+    end
 
     # We use method_missing for widget-creating methods like "button",
     # and also to auto-create display-property getters and setters.
@@ -172,12 +192,12 @@ class Scarpe
       klass = Widget.widget_class_by_name(name)
       return super unless klass
 
-      ::Scarpe::Widget.define_method(name) do |*args, **kwargs, &block|
+      ::Shoes::Widget.define_method(name) do |*args, **kwargs, &block|
         # Look up the Shoes widget and create it...
         widget_instance = klass.new(*args, **kwargs, &block)
 
-        unless klass.ancestors.include?(Scarpe::TextWidget)
-          widget_instance.set_parent(self)
+        unless klass.ancestors.include?(Shoes::TextWidget)
+          widget_instance.set_parent Shoes::App.instance.current_slot
         end
 
         widget_instance

data/{lib/scarpe → lacci/lib/shoes/widgets}/alert.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class Alert < Scarpe::Widget
+module Shoes
+  class Alert < Shoes::Widget
     display_property :text
 
     def initialize(text)
@@ -10,7 +10,7 @@ class Scarpe
       super
 
       bind_self_event("click") do
-        destroy_self
+        remove
       end
 
       create_display_widget

data/{lib/scarpe → lacci/lib/shoes/widgets}/arc.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class InvalidAttributeValueError < Scarpe::Error; end
+module Shoes
+  class InvalidAttributeValueError < Shoes::Error; end
 
-  class Arc < Scarpe::Widget
-    display_properties :left, :top, :width, :height, :angle1, :angle2
+  class Arc < Shoes::Widget
+    display_properties :left, :top, :width, :height, :angle1, :angle2, :draw_context
 
     def initialize(*args)
       @left, @top, @width, @height, @angle1, @angle2 = args
@@ -16,7 +16,9 @@ class Scarpe
       @angle1 = convert_to_float(@angle1, "angle1")
       @angle2 = convert_to_float(@angle2, "angle2")
 
-      super()
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
       create_display_widget
     end
 

data/{lib/scarpe → lacci/lib/shoes/widgets}/button.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class Button < Scarpe::Widget
-    include Scarpe::Log
+module Shoes
+  class Button < Shoes::Widget
+    include Shoes::Log
     display_properties :text, :width, :height, :top, :left, :color, :padding_top, :padding_bottom, :text_color, :size, :font_size
 
     def initialize(text, width: nil, height: nil, top: nil, left: nil, color: nil, padding_top: nil, padding_bottom: nil, size: 12, text_color: nil,

data/lacci/lib/shoes/widgets/check.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Check < Shoes::Widget
+    display_properties :checked
+
+    def initialize(checked = nil, &block)
+      @block = block
+      super
+
+      bind_self_event("click") { click }
+      create_display_widget
+    end
+
+    def click(&block)
+      @block = block
+      self.checked = !checked?
+    end
+
+    def checked?
+      @checked ? true : false
+    end
+
+    def checked(value)
+      self.checked = value
+    end
+  end
+end

data/lacci/lib/shoes/widgets/document_root.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Shoes
+  class DocumentRoot < Shoes::Flow
+    def initialize
+      @height = "100%"
+      @width = @margin = @padding = nil
+      @options = {}
+
+      super
+
+      create_display_widget
+    end
+
+    # The default inspect string can be absolutely huge in console output, and it's frequently printed.
+    def inspect
+      "<Shoes::DocumentRoot>"
+    end
+  end
+end

data/{lib/scarpe → lacci/lib/shoes/widgets}/edit_box.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class EditBox < Scarpe::Widget
+module Shoes
+  class EditBox < Shoes::Widget
     display_properties :text, :height, :width
 
-    def initialize(text = nil, height: nil, width: nil, &block)
-      @text = text.nil? ? block&.call : text || ""
+    def initialize(text = "", height: nil, width: nil, &block)
+      @text = text
+      @callback = block
 
       super
 
       bind_self_event("change") do |new_text|
         self.text = new_text
-        @callback&.call(new_text)
+        @callback&.call(self)
       end
 
       create_display_widget
@@ -20,5 +21,9 @@ class Scarpe
     def change(&block)
       @callback = block
     end
+
+    def append(new_text)
+      self.text = self.text + new_text
+    end
   end
 end

data/{lib/scarpe → lacci/lib/shoes/widgets}/edit_line.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class EditLine < Scarpe::Widget
+module Shoes
+  class EditLine < Shoes::Widget
     display_properties :text, :width
 
     def initialize(text = "", width: nil, &block)

data/lacci/lib/shoes/widgets/flow.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Flow < Shoes::Slot
+    include Shoes::Background
+    include Shoes::Border
+    include Shoes::Spacing
+
+    display_properties :width, :height, :margin, :padding
+
+    def initialize(width: "100%", height: nil, margin: nil, padding: nil, **options, &block)
+      @options = options
+
+      super
+
+      # Create the display-side widget *before* instance_eval, which will add child widgets with their display widgets
+      create_display_widget
+
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+  end
+end

data/lacci/lib/shoes/widgets/font.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Font < Shoes::Widget
+    display_properties :font
+
+    def initialize(font)
+      @font = font
+      super
+
+      create_display_widget
+    end
+  end
+end

data/{lib/scarpe → lacci/lib/shoes/widgets}/image.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require "fastimage"
-require "open-uri"
-
-class Scarpe
-  class Image < Scarpe::Widget
+module Shoes
+  class Image < Shoes::Widget
     display_properties :url, :width, :height, :top, :left, :click
 
     def initialize(url, width: nil, height: nil, top: nil, left: nil, click: nil)
@@ -21,10 +18,9 @@ class Scarpe
     def replace(url)
       self.url = url
     end
-  end
 
-  class Widget
     def size
+      require "fastimage"
       width, height = FastImage.size(@url)
 
       [width, height]

data/lacci/lib/shoes/widgets/line.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Shoes
+  class Line < Shoes::Widget
+    display_properties :left, :top, :x2, :y2, :draw_context
+
+    def initialize(left, top, x2, y2)
+      @left = left
+      @top = top
+      @x2 = x2
+      @y2 = y2
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+      create_display_widget
+    end
+  end
+end

data/{lib/scarpe → lacci/lib/shoes/widgets}/link.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class Link < Scarpe::TextWidget
+module Shoes
+  class Link < Shoes::TextWidget
     display_properties :text, :click, :has_block
 
     def initialize(text, click: nil, &block)

data/{lib/scarpe → lacci/lib/shoes/widgets}/list_box.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class ListBox < Scarpe::Widget
+module Shoes
+  class ListBox < Shoes::Widget
     display_properties :selected_item, :items, :height, :width
 
     def initialize(args = {}, &block)