lacci 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef2126246f0ffc9b764bb40b2a3e4b020702b25a8198a6ba62dfbda69fe5db32
-  data.tar.gz: 61272a70f2591a4ed0b24aeedc8c3c2cfdfdc132fbcf0aea8c6816674c792d57
+  metadata.gz: e32d4245e4dc24e8098d8626ca2ad9ba7d4417b6e392d0c0d43c1b003dece24e
+  data.tar.gz: dea4cd304311e63c498e2c679e8d61ec9b550c56c5a87d33bb4c7b499a08b875
 SHA512:
-  metadata.gz: 97fa624c1e77eb7a54087d76dafc3c0ee2938bfdc99a60c56594061572860777c439b776f47de4a64f237ceaec215fe9561dc984e2b6aca3f3b8bec670dc4959
-  data.tar.gz: 485654866460c26497c49613d24a8fd6cc68ce8580f49246766b524c6c81cab77aa9b6a5a92733333d3ba39b70d7a7433337e2d1145a94f7f54f36eeb6219a38
+  metadata.gz: 360b04b248cc6011c5a37ca50d284d37d1aebd42f60aa15b7eb3f8b47933faca0d5b6738ae462b3cc67bf9b56b3bd426cb375fa8640111ec00a42a01a5aeaf55
+  data.tar.gz: 7ef67d55690c0b3ffe845edf747a86a1561dd2aced210d2a870df87f0140eb8aaaab8abbe03212da9557488de655944ecc9d54637679420dc1d8b5594143a5a6

data/Gemfile

@@ -2,10 +2,10 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in scarpe.gemspec
 gemspec
 
-gem "bloops", "~> 0.5" #path: "../bloopsaphone" #git: "https://github.com/scarpe-team/bloopsaphone"
+gem "scarpe-components", path: "../scarpe-components"
+
 gem "rake", "~> 13.0"
 
 group :test do

data/Gemfile.lock

@@ -0,0 +1,79 @@
+PATH
+  remote: ../scarpe-components
+  specs:
+    scarpe-components (0.3.0)
+
+PATH
+  remote: .
+  specs:
+    lacci (0.3.0)
+      scarpe-components
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    debug (1.8.0)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
+    io-console (0.6.0)
+    irb (1.7.2)
+      reline (>= 0.3.6)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    minitest (5.18.1)
+    minitest-reporters (1.6.0)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    redcarpet (3.6.0)
+    regexp_parser (2.8.1)
+    reline (0.3.6)
+      io-console (~> 0.5)
+    rexml (3.2.5)
+    rubocop (1.54.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-shopify (2.14.0)
+      rubocop (~> 1.51)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (2.4.2)
+    yard (0.9.34)
+
+PLATFORMS
+  x86_64-darwin-22
+
+DEPENDENCIES
+  debug
+  lacci!
+  minitest (~> 5.0)
+  minitest-reporters
+  rake (~> 13.0)
+  redcarpet
+  rubocop (~> 1.21)
+  rubocop-shopify
+  scarpe-components!
+  yard
+
+BUNDLED WITH
+   2.4.10

data/Rakefile

@@ -2,7 +2,6 @@
 
 require "bundler/gem_tasks"
 require "rake/testtask"
-require "rubocop/rake_task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -10,6 +9,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
-RuboCop::RakeTask.new
-
-task default: [:test, :rubocop]
+task default: [:test]

data/lib/lacci/scarpe_cli.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Scarpe
+  module CLI
+    DEFAULT_USAGE = <<~'USAGE'
+      Usage: scarpe_core [OPTIONS] <scarpe app file>           # Same as "scarpe run"
+             scarpe_core [OPTIONS] run <scarpe app file>
+             scarpe_core [OPTIONS] env                         # print Scarpe environment settings
+             scarpe_core -v                                    # print the Scarpe gem version and exit
+        Options:
+            --dev                          Use development local scarpe, not an installed gem
+            --debug                        Turn on application debug mode
+    USAGE
+
+    def version_check
+      if RUBY_VERSION[0..2] < "3.2"
+        raise "Scarpe and Lacci require Ruby 3.2 or higher!"
+      end
+    end
+
+    def env_or_default(env_var, default_val)
+      [env_var, ENV[env_var] ? ENV[env_var].inspect : default_val]
+    end
+
+    def default_env_categories
+      require "shoes"
+      {
+        "Lacci" => [
+          env_or_default("SCARPE_DISPLAY_SERVICE", "(none)"),
+          env_or_default("SCARPE_LOG_CONFIG", "(default)#{Shoes::Log::DEFAULT_LOG_CONFIG.inspect}"),
+          env_or_default("SCARPE_APP_TEST", "(none)"),
+        ],
+        "Ruby and Shell" => [
+          ["RUBY_DESCRIPTION", RUBY_DESCRIPTION],
+          ["RUBY_PLATFORM", RUBY_PLATFORM],
+          ["RUBY_ENGINE", RUBY_ENGINE],
+          env_or_default("SHELL", "(none)"),
+          env_or_default("PATH", "(none)"),
+          env_or_default("LD_LIBRARY_PATH", "(none)"),
+          env_or_default("DYLD_LIBRARY_PATH", "(none)"),
+          env_or_default("GEM_ROOT", "(none)"),
+          env_or_default("GEM_HOME", "(none)"),
+          env_or_default("GEM_PATH", "(none)"),
+        ],
+      }
+    end
+
+    def env_categories
+      @env_categories ||= default_env_categories
+      @env_categories
+    end
+
+    def add_env_categories(categories)
+      unless categories.is_a?(Hash)
+        raise("Please supply a hash with categories names as keys and an array of two-elt arrays as values!")
+      end
+
+      # Try to get categories into the *start* of the hash, insertion-order-wise
+      @env_categories = categories.merge(env_categories)
+    end
+
+    def print_env
+      env_categories.each do |category, entries|
+        puts "#{category} environment:"
+        entries.each do |name, val|
+          puts "  #{name}: #{val}"
+        end
+      end
+    end
+  end
+end

data/lib/lacci/scarpe_core.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Lacci is one place we put components that have no hard gem requirements.
+# It needs to connect to Scarpe, mostly via the Shoes DisplayService.
+# Some display services, like Wasm, cannot install or otherwise tolerate
+# Scarpe's need for a variety of gems, especially those with native extensions.
+# So we need a simple require-able Scarpe core here in Lacci that can be
+# required from display services that cannot link with the base Scarpe gem.
+
+if RUBY_VERSION[0..2] < "3.2"
+  Shoes::Log.logger("Scarpe").error("Scarpe requires Ruby 3.2 or higher!")
+  exit(-1)
+end
+
+module Scarpe; end
+
+# The base error class for Scarpe errors, but not necessarily {Shoes::Error}s
+class Shoes::Error < StandardError; end
+class Scarpe::Error < StandardError; end
+
+require "lacci/version"
+require "scarpe/components/version"

data/lib/lacci/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# The name "scarpe" means "shoes" in Italian. "Lacci"
+# means "laces." Lacci is the display-independent part
+# of Scarpe, tying the Shoes API to the display service
+# of your choice.
+#
+# Almost nothing is called Lacci in your program. It's
+# mostly invisible. Instead, look at the {Shoes} module
+# to see what's in Lacci.
+module Lacci
+  VERSION = "0.3.0"
+end

data/lib/scarpe/niente/app.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Niente
+  class App < Drawable
+    def initialize(properties)
+      super
+
+      bind_shoes_event(event_name: "init") { init }
+      bind_shoes_event(event_name: "run") { run }
+      bind_shoes_event(event_name: "destroy") { destroy }
+    end
+
+    def init
+    end
+
+    def run
+      send_shoes_event("wait", event_name: "custom_event_loop")
+    end
+
+    def destroy
+    end
+  end
+end

data/lib/scarpe/niente/display_service.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Niente
+  # This is a "null" DisplayService, doing as little as it
+  # can get away with.
+  class DisplayService < Shoes::DisplayService
+    include Shoes::Log
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def initialize
+      if Niente::DisplayService.instance
+        raise Shoes::SingletonError, "ERROR! This is meant to be a singleton!"
+      end
+
+      Niente::DisplayService.instance = self
+
+      log_init("Niente::DisplayService")
+      super()
+    end
+
+    # Create a fake display drawable for a specific Shoes drawable, and pair it with
+    # the linkable ID for this Shoes drawable.
+    #
+    # @param drawable_class_name [String] The class name of the Shoes drawable, e.g. Shoes::Button
+    # @param drawable_id [String] the linkable ID for drawable events
+    # @param properties [Hash] a JSON-serialisable Hash with the drawable's Shoes styles
+    # @param is_widget [Boolean] whether the class is a user-defined Shoes::Widget subclass
+    # @return [Webview::Drawable] the newly-created Webview drawable
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties, is_widget:)
+      existing = query_display_drawable_for(drawable_id, nil_ok: true)
+      if existing
+        @log.warn("There is already a display drawable for #{drawable_id.inspect}! Returning #{existing.class.name}.")
+        return existing
+      end
+
+      if drawable_class_name == "App"
+        @app = Niente::App.new(properties)
+        set_drawable_pairing(drawable_id, @app)
+
+        return @app
+      end
+
+      display_drawable = Niente::Drawable.new(properties)
+      display_drawable.shoes_type = drawable_class_name
+      set_drawable_pairing(drawable_id, display_drawable)
+
+      return display_drawable
+    end
+
+    # Destroy the display service and the app. Quit the process (eventually.)
+    #
+    # @return [void]
+    def destroy
+      @app.destroy
+      DisplayService.instance = nil
+    end
+  end
+end
+

data/lib/scarpe/niente/drawable.rb

@@ -0,0 +1,57 @@
+module Niente
+  class Drawable < Shoes::Linkable
+    attr_reader :shoes_linkable_id
+    attr_reader :parent
+    attr_reader :children
+
+    attr_accessor :shoes_type
+
+    def initialize(props)
+      @shoes_linkable_id = props.delete("shoes_linkable_id") || props.delete(:shoes_linkable_id)
+      @data = props
+
+      super(linkable_id: @shoes_linkable_id)
+
+      bind_shoes_event(event_name: "parent", target: shoes_linkable_id) do |new_parent_id|
+        display_parent = DisplayService.instance.query_display_drawable_for(new_parent_id)
+        if @parent != display_parent
+          set_parent(display_parent)
+        end
+      end
+
+      # When Shoes drawables change properties, we get a change notification here
+      bind_shoes_event(event_name: "prop_change", target: shoes_linkable_id) do |prop_changes|
+        prop_changes.each do |k, v|
+          instance_variable_set("@" + k, v)
+        end
+        properties_changed(prop_changes) if respond_to?(:properties_changed)
+      end
+
+      bind_shoes_event(event_name: "destroy", target: shoes_linkable_id) do
+      end
+    end
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+    end
+
+    # Do not call directly, use set_parent
+    def remove_child(child)
+      @children ||= []
+      unless @children.include?(child)
+        STDERR.puts("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
+  end
+end
+

data/lib/scarpe/niente/logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "shoes/log"
+require "json"
+
+module Niente; end
+class Niente::LogImpl
+  include Shoes::Log # for constants
+
+  class PrintLogger
+    def initialize(_)
+    end
+
+    [:error, :warn, :debug, :info].each do |level|
+      define_method(level) do |msg|
+        puts "#{level}: #{msg}"
+      end
+    end
+  end
+
+  def logger_for_component(component)
+    PrintLogger.new(component.to_s)
+  end
+
+  def configure_logger(log_config)
+  end
+end
+
+#Shoes::Log.instance = Niente::LogImpl.new

data/lib/scarpe/niente/shoes_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "scarpe/components/string_helpers"
+
+module Niente; end
+
+class Niente::Test
+  def self.run_shoes_spec_test_code(code, class_name: nil, test_name: nil)
+    if @shoes_spec_init
+      raise Shoes::Errors::MultipleShoesSpecRunsError, "Scarpe-Webview can only run a single Shoes spec per process!"
+    end
+    @shoes_spec_init = true
+
+    require "scarpe/components/minitest_export_reporter"
+    Minitest::Reporters::ShoesExportReporter.activate!
+
+    class_name ||= ENV["SHOES_MINITEST_CLASS_NAME"] || "TestShoesSpecCode"
+    test_name ||= ENV["SHOES_MINITEST_METHOD_NAME"] || "test_shoes_spec"
+
+    Shoes::DisplayService.subscribe_to_event("heartbeat", nil) do
+      unless @hb_init
+        Minitest.run []
+        Shoes::App.instance.destroy
+      end
+      @hb_init = true
+    end
+
+    test_class = Class.new(Niente::ShoesSpecTest)
+    Object.const_set(Scarpe::Components::StringHelpers.camelize(class_name), test_class)
+    test_name = "test_" + test_name unless test_name.start_with?("test_")
+    test_class.define_method(test_name) do
+      STDERR.puts "Started running #{class_name.inspect}::#{test_name.inspect}"
+      eval(code)
+    end
+  end
+end
+
+class Niente::ShoesSpecTest < Minitest::Test
+  Shoes::Drawable.drawable_classes.each do |drawable_class|
+    finder_name = drawable_class.dsl_name
+
+    define_method(finder_name) do |*args|
+      app = Shoes::App.instance
+
+      drawables = app.find_drawables_by(drawable_class, *args)
+      raise Shoes::Errors::MultipleDrawablesFoundError, "Found more than one #{finder_name} matching #{args.inspect}!" if drawables.size > 1
+      raise Shoes::Errors::NoDrawablesFoundError, "Found no #{finder_name} matching #{args.inspect}!" if drawables.empty?
+
+      Niente::ShoesSpecProxy.new(drawables[0])
+    end
+  end
+end
+
+class Niente::ShoesSpecProxy
+  attr_reader :obj
+  attr_reader :linkable_id
+  attr_reader :display
+
+  def initialize(obj)
+    @obj = obj
+    @linkable_id = obj.linkable_id
+    @display = ::Shoes::DisplayService.display_service.query_display_drawable_for(obj.linkable_id)
+  end
+
+  def method_missing(method, ...)
+    if @obj.respond_to?(method)
+      self.singleton_class.define_method(method) do |*args, **kwargs, &block|
+        @obj.send(method, *args, **kwargs, &block)
+      end
+      send(method, ...)
+    else
+      super # raise an exception
+    end
+  end
+
+  JS_EVENTS = [:click, :hover, :leave]
+  JS_EVENTS.each do |event|
+    define_method("trigger_#{event}") do |*args, **kwargs|
+      ::Shoes::DisplayService.dispatch_event(event.to_s, @linkable_id, *args, **kwargs)
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @obj.respond_to_missing?(method_name, include_private)
+  end
+end

data/lib/scarpe/niente.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Niente -- Italian for "nothing" -- is a null display service
+# that doesn't display anything. It does very little, while
+# keeping a certain amount of "mental model" or schema of
+# how a real display service should act.
+module Niente; end
+
+require_relative "niente/logger"
+Shoes::Log.instance = Niente::LogImpl.new
+
+require_relative "niente/drawable"
+require_relative "niente/app"
+require_relative "niente/display_service"
+
+require_relative "niente/shoes_spec"
+Shoes::Spec.instance = Niente::Test
+
+Shoes::DisplayService.set_display_service_class(Niente::DisplayService)
+