lacci 0.2.1

data/lib/shoes/app.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Shoes
+  class App < Shoes::Widget
+    include Scarpe::Log
+
+    class << self
+      attr_accessor :instance
+    end
+
+    attr_reader :document_root
+
+    display_properties :title, :width, :height, :resizable, :debug
+
+    def initialize(
+      title: "Scarpe!",
+      width: 480,
+      height: 420,
+      resizable: true,
+      debug: ENV["SCARPE_DEBUG"] ? true : false,
+      &app_code_body
+    )
+      if Shoes::App.instance
+        @log.error("Trying to create a second Shoes::App in the same process! Fail!")
+        raise "Cannot create multiple Shoes::App objects!"
+      else
+        Shoes::App.instance = self
+      end
+
+      log_init("Shoes::App")
+
+      @do_shutdown = false
+
+      super
+
+      # This creates the DocumentRoot, including its corresponding display widget
+      @document_root = Scarpe::DocumentRoot.new
+
+      @slots = []
+
+      # Now create the App display widget
+      create_display_widget
+
+      # Set up testing events *after* Display Service basic objects exist
+      if ENV["SCARPE_APP_TEST"]
+        test_code = File.read ENV["SCARPE_APP_TEST"]
+        if test_code != ""
+          self.instance_eval test_code
+        end
+      end
+
+      @app_code_body = app_code_body
+
+      # Try to de-dup as much as possible and not send repeat or multiple
+      # destroy events
+      @watch_for_destroy = bind_shoes_event(event_name: "destroy") do
+        Shoes::DisplayService.unsub_from_events(@watch_for_destroy) if @watch_for_destroy
+        @watch_for_destroy = nil
+        self.destroy(send_event: false)
+      end
+
+      Signal.trap("INT") do
+        @log.warning("App interrupted by signal, stopping...")
+        puts "\nStopping Scarpe app..."
+        destroy
+      end
+    end
+
+    def init
+      send_shoes_event(event_name: "init")
+      return if @do_shutdown
+
+      ::Shoes::App.instance.with_slot(@document_root, &@app_code_body)
+    end
+
+    # "Container" widgets like flows, stacks, masks and the document root
+    # are considered "slots" in Scarpe parlance. When a new slot is created,
+    # we push it here in order to track what widgets are found in that slot.
+    def push_slot(slot)
+      @slots.push(slot)
+    end
+
+    def pop_slot
+      return if @slots.size <= 1
+
+      @slots.pop
+    end
+
+    def current_slot
+      @slots[-1]
+    end
+
+    def with_slot(slot_item, &block)
+      return unless block_given?
+
+      push_slot(slot_item)
+      Shoes::App.instance.instance_eval(&block)
+    ensure
+      pop_slot
+    end
+
+    # This isn't supposed to return. The display service should take control
+    # of the main thread. Local Webview even stops any background threads.
+    def run
+      if @do_shutdown
+        $stderr.puts "Destroy has already been signaled, but we just called Shoes::App.run!"
+        return
+      end
+      send_shoes_event(event_name: "run")
+    end
+
+    def destroy(send_event: true)
+      @do_shutdown = true
+      send_shoes_event(event_name: "destroy") if send_event
+    end
+
+    def all_widgets
+      out = []
+
+      to_add = @document_root.children
+      until to_add.empty?
+        out.concat(to_add)
+        to_add = to_add.flat_map(&:children).compact
+      end
+
+      out
+    end
+
+    # We can add various ways to find widgets here.
+    # These are sort of like Shoes selectors, used for testing.
+    def find_widgets_by(*specs)
+      widgets = all_widgets
+      specs.each do |spec|
+        if spec.is_a?(Class)
+          widgets.select! { |w| spec === w }
+        elsif spec.is_a?(Symbol)
+          s = spec.to_s
+          case s[0]
+          when "$"
+            begin
+              # I'm not finding a global_variable_get or similar...
+              global_value = eval s
+              widgets &= [global_value]
+            rescue
+              raise "Error getting global variable: #{spec.inspect}"
+            end
+          when "@"
+            if app.instance_variables.include?(spec)
+              widgets &= [self.instance_variable_get(spec)]
+            else
+              raise "Can't find top-level instance variable: #{spec.inspect}!"
+            end
+          else
+          end
+        else
+          raise("Don't know how to find widgets by #{spec.inspect}!")
+        end
+      end
+      widgets
+    end
+  end
+end
+
+# DSL methods
+class Shoes::App
+  def background(...)
+    current_slot.background(...)
+  end
+
+  def border(...)
+    current_slot.border(...)
+  end
+
+  def motion(&block)
+    subscription_item(shoes_api_name: "motion", &block)
+  end
+
+  def hover(&block)
+    subscription_item(shoes_api_name: "hover", &block)
+  end
+
+  def click(&block)
+    subscription_item(shoes_api_name: "click", &block)
+  end
+
+  alias_method :info, :puts
+end

data/lib/shoes/constants.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Shoes
+  module Constants
+    def self.find_lib_dir
+      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
+
+    LIB_DIR = find_lib_dir
+
+    # Math constants from Shoes3
+    RAD2PI = 0.01745329251994329577
+    TWO_PI = 6.28318530717958647693
+    HALF_PI = 1.57079632679489661923
+    PI = 3.14159265358979323846
+  end
+end

data/lib/shoes/text_widget.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Scarpe::TextWidget
+
+module Shoes
+  class TextWidget < Shoes::Widget
+    class << self
+      # rubocop:disable Lint/MissingSuper
+      def inherited(subclass)
+        Shoes::Widget.widget_classes ||= []
+        Shoes::Widget.widget_classes << subclass
+      end
+      # rubocop:enable Lint/MissingSuper
+    end
+  end
+
+  class << self
+    def default_text_widget_with(element)
+      class_name = element.capitalize
+
+      widget_class = Class.new(Shoes::TextWidget) do
+        # Can we just change content to text to match the Shoes API?
+        display_property :content
+
+        def initialize(content)
+          @content = content
+
+          super
+
+          create_display_widget
+        end
+
+        def text
+          self.content
+        end
+
+        def text=(new_text)
+          self.content = new_text
+        end
+      end
+      # TODO: move this to Shoes module
+      Scarpe.const_set class_name, widget_class
+      widget_class.class_eval do
+        display_property :content
+      end
+    end
+  end
+end
+
+Shoes.default_text_widget_with(:code)
+Shoes.default_text_widget_with(:em)
+Shoes.default_text_widget_with(:strong)

data/lib/shoes/widget.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+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 Scarpe::Log
+    include Scarpe::Colors
+
+    class << self
+      attr_accessor :widget_classes
+
+      def inherited(subclass)
+        Shoes::Widget.widget_classes ||= []
+        Shoes::Widget.widget_classes << subclass
+        super
+      end
+
+      def dsl_name
+        n = name.split("::").last.chomp("Widget")
+        n.gsub(/(.)([A-Z])/, '\1_\2').downcase
+      end
+
+      def widget_class_by_name(name)
+        widget_classes.detect { |k| k.dsl_name == name.to_s }
+      end
+
+      private
+
+      def linkable_properties
+        @linkable_properties ||= []
+      end
+
+      def linkable_properties_hash
+        @linkable_properties_hash ||= {}
+      end
+
+      public
+
+      # Display properties in Shoes Linkables are automatically sync'd with the display side objects.
+      # TODO: do we want types or other modifiers on specific properties?
+      def display_property(name)
+        name = name.to_s
+
+        return if linkable_properties_hash[name]
+
+        linkable_properties << { name: name }
+        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
+        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] ||
+          (self != Shoes::Widget && superclass.display_property_name?(name))
+      end
+    end
+
+    def initialize(*args, **kwargs)
+      log_init("Widget")
+
+      self.class.display_property_names.each do |prop|
+        if kwargs[prop.to_sym]
+          instance_variable_set("@" + prop, kwargs[prop.to_sym])
+        end
+      end
+
+      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
+
+    def bind_self_event(event_name, &block)
+      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+
+      bind_shoes_event(event_name: event_name, target: linkable_id, &block)
+    end
+
+    def bind_no_target_event(event_name, &block)
+      bind_shoes_event(event_name:, &block)
+    end
+
+    def display_property_values
+      all_property_names = self.class.display_property_names
+
+      properties = {}
+      all_property_names.each do |prop|
+        properties[prop] = instance_variable_get("@" + prop)
+      end
+      properties["shoes_linkable_id"] = self.linkable_id
+      properties
+    end
+
+    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?
+      ::Shoes::DisplayService.display_service.create_display_widget_for(klass_name, self.linkable_id, display_property_values)
+    end
+
+    attr_reader :parent
+    attr_reader :children
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+      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)
+    end
+
+    # Do not call directly, use set_parent
+    def add_child(child)
+      @children ||= []
+      @children << child
+    end
+
+    # 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 :destroy_self, :destroy
+
+    # We use method_missing for widget-creating methods like "button",
+    # and also to auto-create display-property getters and setters.
+    def method_missing(name, *args, **kwargs, &block)
+      name_s = name.to_s
+
+      if name_s[-1] == "="
+        prop_name = name_s[0..-2]
+        if self.class.display_property_name?(prop_name)
+          self.class.define_method(name) do |new_value|
+            raise "Trying to set display properties in an object with no linkable ID!" unless linkable_id
+
+            instance_variable_set("@" + prop_name, new_value)
+            send_shoes_event({ prop_name => new_value }, event_name: "prop_change", target: linkable_id)
+          end
+
+          return self.send(name, *args, **kwargs, &block)
+        end
+      end
+
+      if self.class.display_property_name?(name_s)
+        self.class.define_method(name) do
+          raise "Trying to get display properties in an object with no linkable ID!" unless linkable_id
+
+          instance_variable_get("@" + name_s)
+        end
+
+        return self.send(name, *args, **kwargs, &block)
+      end
+
+      klass = Widget.widget_class_by_name(name)
+      return super unless klass
+
+      ::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?(Shoes::TextWidget)
+          widget_instance.set_parent Shoes::App.instance.current_slot
+        end
+
+        widget_instance
+      end
+
+      send(name, *args, **kwargs, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name_s = name.to_s
+      return true if self.class.display_property_name?(name_s)
+      return true if self.class.display_property_name?(name_s[0..-2]) && name_s[-1] == "="
+      return true if Widget.widget_class_by_name(name_s)
+
+      super
+    end
+  end
+end

data/lib/shoes.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# We're separating Shoes from Scarpe, a little at a time. This should eventually be requirable
+# without using Scarpe at all.
+#
+# This Shoes gem will, if all goes well, be a lot like the old Shoes-core from Shoes4: a way
+# to handle the DSL and command-line parts of Shoes without knowing anything about how the
+# display side works at all.
+
+# This will never be triggered -- we use the (...) feature below, which means this
+# file won't even parse in old Rubies.
+if RUBY_VERSION[0..2] < "3.2"
+  Scarpe::Logger.logger("Scarpe").error("Scarpe requires Ruby 3.2 or higher!")
+  exit(-1)
+end
+
+require_relative "shoes/constants"
+module Kernel
+  include Shoes::Constants
+end
+
+class Shoes::Error < StandardError; end
+
+# 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 << 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.
+    #
+    # @incompatibility In Shoes3, this method will return normally.
+    #   In Scarpe, after the block is executed, the method will not return and Scarpe
+    #   will retain control of execution until the window is closed and the app quits.
+    #
+    # @incompatibility In Shoes3 the parameters were a hash of options, not keyword arguments.
+    #
+    # @example Simple one-button app
+    #   Scarpe.app(title: "Button!", width: 200, height: 200) do
+    #     @p = para "Press it NOW!"
+    #     button("clicky") { @p.replace("You pressed it! CELEBRATION!") }
+    #   end
+    #
+    # @param title [String] The new app window title
+    # @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
+    # @return [void]
+    # @see Shoes::App#new
+    def app(
+      title: "Scarpe!",
+      width: 480,
+      height: 420,
+      resizable: true,
+      &app_code_body
+    )
+      app = Shoes::App.new(title:, width:, height:, resizable:, &app_code_body)
+      app.init
+      app.run
+      app.destroy
+      nil
+    end
+  end
+end

data/logger/debug_web_wrangler.json

@@ -0,0 +1,4 @@
+{
+    "default": "warn",
+    "WV::WebWrangler": ["debug", "logger/web_wrangler.log"]
+}

data/logger/scarpe_wv_test.json

@@ -0,0 +1,4 @@
+{
+    "default": ["debug", "logger/test_failure.log"],
+    "WebviewAPI": ["debug", "logger/test_failure_wv_api.log"]
+}

data/scarpe.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "lib/scarpe/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "scarpe"
+  spec.version = Scarpe::VERSION
+  spec.authors = ["Marco Concetto Rudilosso"]
+  spec.email = ["marcoc.r@outlook.com"]
+
+  spec.summary = "Scarpe - shoes but running on webview"
+  spec.homepage = "https://github.com/Maaarcocr/scarpe"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Maaarcocr/scarpe"
+  spec.metadata["changelog_uri"] = "https://github.com/Maaarcocr/scarpe/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "fastimage"
+  spec.add_dependency "glimmer-dsl-libui"
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "sqlite3"
+
+  spec.add_dependency "bloops", "~>0.5"
+  spec.add_dependency "logging", "~>2.3.1"
+  spec.add_dependency "webview_ruby", "~>0.1.1"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end