scarpe 0.2.1 → 0.3.0

data/lacci/lib/shoes/changelog.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "log"
+# require "scarpe/components/modular_logger"
+
+class Shoes
+  class Changelog
+    # include Shoes::Log
+
+    def initialize
+      #TODO : refer to  https://github.com/scarpe-team/scarpe/pull/400
+      #       and figure out how to use scarpe logger here without getting duplicate or nil error
+      # Shoes::Log.instance = Scarpe::Components::ModularLogImpl.new
+      # log_init("Changelog")
+    end
+
+    def get_latest_release_info
+      root_dir = File.dirname(__FILE__, 4) # this duplicates constants.rb, but how to share?
+
+      git_dir = "#{root_dir}/.git"
+      revision = nil
+      if File.exist?(git_dir)
+        revision = `git rev-parse HEAD`.chomp
+      end
+
+      changelog_file = "#{root_dir}/CHANGELOG.md"
+      if File.exist?(changelog_file)
+        changelog_content = File.read(changelog_file)
+        release_name_pattern = /^## \[(\d+\.\d+\.\d+)\] - (\d{4}-\d{2}-\d{2}) - (\w+)$/m
+        release_matches = changelog_content.scan(release_name_pattern)
+        latest_release = release_matches.max_by { |version, _date, _name| Gem::Version.new(version) }
+
+        if latest_release
+          #puts "Found release #{latest_release[0]} in CHANGELOG.md"
+          # @log.debug("Found release #{latest_release[0]} in CHANGELOG.md") # Logger isn't initialized yet
+          version_parts = latest_release[0].split(".").map(&:to_i)
+          rel_id = ("%02d%02d%02d" % version_parts).to_i
+
+          return({
+            RELEASE_NAME: latest_release[2],
+            RELEASE_BUILD_DATE: latest_release[1],
+            RELEASE_ID: rel_id,
+            REVISION: revision,
+          })
+        end
+      end
+
+      puts "No release found in CHANGELOG.md"
+      { RELEASE_NAME: nil, RELEASE_BUILD_DATE: nil, RELEASE_ID: nil, REVISION: revision }
+    end
+  end
+end

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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-class Scarpe
+class Shoes
   module Colors
+    extend self
+
     COLORS = {
       aliceblue: [240, 248, 255],
       antiquewhite: [250, 235, 215],

data/lacci/lib/shoes/constants.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "changelog"
+class Shoes
+  module Constants
+    def self.find_lib_dir
+      begin
+        require "tmpdir"
+      rescue LoadError
+        return nil
+      end
+      homes = [
+        [ENV["LOCALAPPDATA"], "Shoes"],
+        [ENV["APPDATA"], "Shoes"],
+        [ENV["HOME"], ".shoes"],
+        [Dir.tmpdir, "shoes"],
+      ]
+
+      top, file = homes.detect { |home_top, _| home_top && File.exist?(home_top) }
+      File.join(top, file)
+    end
+
+    # A temp dir for Shoes app files
+    LIB_DIR = find_lib_dir
+
+    # the Shoes library dir
+    DIR = File.dirname(__FILE__, 4)
+
+    # Math constants from Shoes3
+    RAD2PI = 0.01745329251994329577
+    TWO_PI = 6.28318530717958647693
+    HALF_PI = 1.57079632679489661923
+    PI = 3.14159265358979323846
+
+    # This should be set up by the Display Service when it loads
+    FONTS = []
+  end
+
+  # Access and assign the release constants
+  changelog_instance = Shoes::Changelog.new
+  RELEASE_INFO = changelog_instance.get_latest_release_info
+  RELEASE_NAME = RELEASE_INFO[:RELEASE_NAME]
+  RELEASE_ID = RELEASE_INFO[:RELEASE_ID]
+  RELEASE_BUILD_DATE = RELEASE_INFO[:RELEASE_BUILD_DATE]
+  RELEASE_TYPE = "LOOSE_SHOES" # This isn't really a thing any more
+  REVISION = RELEASE_INFO[:REVISION]
+end

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-# Scarpe Shoes apps operate in multiple layers. A Shoes widget tree exists as fairly
-# plain, simple Ruby objects. And then a display-service widget tree integrates with
-# the display technology, initially Webview. This lets us use Ruby as our API while
-# not tying it too closely to the limitations of Webview.
+# Lacci Shoes apps operate in multiple layers. A Shoes drawable tree exists as fairly
+# plain, simple Ruby objects. And then a display-service drawable tree integrates with
+# the display technology. This lets us use Ruby as our API while
+# not tying it too closely to the limitations of Webview, WASM, LibUI, etc.
 #
 # ## Choosing Display Services
 #
-# Before running a Scarpe app, you can set SCARPE_DISPLAY_SERVICE. If you
+# Before running a Lacci app, you can set SCARPE_DISPLAY_SERVICE. If you
 # set it to "whatever_service", Scarpe will require "scarpe/whatever_service",
 # which can be supplied by the Scarpe gem or another Scarpe-based gem.
 # Currently leaving the environment variable empty is equivalent to requesting
@@ -15,36 +15,22 @@
 #
 # ## Events
 #
-# Events are a lot of what tie the Shoes widgets and the display service together.
+# Events are a lot of what tie the Shoes drawables and the display service together.
 #
-# Scarpe widgets *expect* to operate in a fairly "hands off" mode where they record
+# Shoes drawables *expect* to operate in a fairly "hands off" mode where they record
 # to an event queue to send to the display service, and the display service records
 # events to send back.
 #
 # When a Shoes handler takes an action (e.g. some_para.replace(),) the relevant
 # call will be dispatched as a :display event, to be sent to the display service.
 # And when a display-side event occurs (e.g. user pushes a button,) it will be
-# dispatched as a :shoes event, to be sent to the Shoes tree of widgets.
+# dispatched as a :shoes event, to be sent to the Shoes tree of drawables.
 #
-# It is normally assumed that there will only be a single 'real' consumer for each
-# queue. You wouldn't usually want multiple display services sending back click
-# events, for example. But that's not a technical limitation of the system.
-# You could have no display service and not get any events back, or a debug
-# display service that just records what happened. But in real situations,
-# exactly one display service is a reasonable and appropriate assumption.
-#
-# The event types are "queues" in the sense that they're separate from each
-# other. You need to subscribe separately to :shoes and :display events if
-# you want both. But internally they're immediately dispatched as events
-# rather than keeping a literal array of items.
-#
-class Scarpe
+class Shoes
   class DisplayService
     class << self
       # This is in the eigenclass/metaclass, *not* instances of DisplayService
-      include Scarpe::Log
-
-      attr_accessor :json_debug_serialize
+      include Shoes::Log
 
       # An event_target may be nil, to indicate there is no target.
       def dispatch_event(event_name, event_target, *args, **kwargs)
@@ -58,7 +44,8 @@ class Scarpe
 
         @log.debug("Dispatch event: #{event_name.inspect} T: #{event_target.inspect} A: #{args.inspect} KW: #{kwargs.inspect}")
 
-        if DisplayService.json_debug_serialize
+        # When true, this makes sure all events and properties are 100% strings, no symbols.
+        if ENV["SCARPE_DEBUG"]
           args = JSON.parse JSON.dump(args)
           new_kw = {}
           kwargs.each do |k, v|
@@ -139,51 +126,82 @@ class Scarpe
       end
     end
 
-    # This is for objects that can be referred to via events, using their
-    # IDs. There are also convenience functions for binding and sending
-    # events.
-    class Linkable
-      attr_reader :linkable_id
+    # These methods are an interface to DisplayService objects.
 
-      def initialize(linkable_id: object_id)
-        @linkable_id = linkable_id
-      end
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties, is_widget:)
+      raise "Override in DisplayService implementation!"
+    end
 
-      def send_self_event(*args, event_name:, **kwargs)
-        DisplayService.dispatch_event(event_name, self.linkable_id, *args, **kwargs)
+    def set_drawable_pairing(id, display_drawable)
+      if id.nil?
+        raise Shoes::Errors::BadLinkableIdError, "Linkable ID may not be nil!"
       end
 
-      def send_shoes_event(*args, event_name:, target: nil, **kwargs)
-        DisplayService.dispatch_event(event_name, target, *args, **kwargs)
+      @display_drawable_for ||= {}
+      if @display_drawable_for[id]
+        raise Shoes::Errors::DuplicateCreateDrawableError, "There is already a drawable for #{id.inspect}! Not setting a new one."
       end
 
-      def bind_shoes_event(event_name:, target: nil, &handler)
-        DisplayService.subscribe_to_event(event_name, target, &handler)
-      end
+      @display_drawable_for[id] = display_drawable
+      nil
     end
 
-    # These methods are an interface to DisplayService objects.
+    def query_display_drawable_for(id, nil_ok: false)
+      @display_drawable_for ||= {}
+      display_drawable = @display_drawable_for[id]
+      unless display_drawable || nil_ok
+        raise "Could not find display drawable for linkable ID #{id.inspect}!"
+      end
+
+      display_drawable
+    end
 
-    def create_display_widget_for(widget_class_name, widget_id, properties)
+    def destroy
       raise "Override in DisplayService implementation!"
     end
+  end
 
-    def set_widget_pairing(id, display_widget)
-      @display_widget_for ||= {}
-      @display_widget_for[id] = display_widget
+  # This is for objects that can be referred to via events, using their
+  # IDs. There are also convenience functions for binding and sending
+  # events.
+  #
+  # Linkable objects may be event targets. Technically anything, linkable
+  # or not, can be an event subscriber, but linkables get easy convenience
+  # functions for subscription.
+  class Linkable
+    attr_reader :linkable_id
+
+    def initialize(linkable_id: object_id)
+      @linkable_id = linkable_id
+      @subscriptions = {}
+      @display_drawable_for ||= {}
     end
 
-    def query_display_widget_for(id, nil_ok: false)
-      display_widget = @display_widget_for[id]
-      unless display_widget || nil_ok
-        raise "Could not find display widget for linkable ID #{id.inspect}!"
-      end
+    def send_self_event(*args, event_name:, **kwargs)
+      DisplayService.dispatch_event(event_name, self.linkable_id, *args, **kwargs)
+    end
 
-      display_widget
+    def send_shoes_event(*args, event_name:, target: nil, **kwargs)
+      DisplayService.dispatch_event(event_name, target, *args, **kwargs)
     end
 
-    def destroy
-      raise "Override in DisplayService implementation!"
+    def bind_shoes_event(event_name:, target: nil, &handler)
+      sub = DisplayService.subscribe_to_event(event_name, target, &handler)
+      @subscriptions[sub] = true
+      sub
+    end
+
+    def unsub_shoes_event(unsub_id)
+      unless @subscriptions[unsub_id]
+        $stderr.puts "Unsubscribing from event that isn't in subscriptions! #{unsub_id.inspect}"
+      end
+      DisplayService.unsub_from_events(unsub_id)
+      @subscriptions.delete unsub_id
+    end
+
+    def unsub_all_shoes_events
+      @subscriptions.keys.each { |k| DisplayService.unsub_from_events(k) }
+      @subscriptions.clear
     end
   end
 end

data/lacci/lib/shoes/download.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Drawable
+    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