scarpe 0.1.0 → 0.2.0

data/lib/scarpe/logger.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "logging"
+require "json"
+
+class Scarpe
+  LOG_LEVELS = [:debug, :info, :warning, :error, :fatal].freeze
+
+  # Include this module to get a @log instance variable to log as your
+  # configured component.
+  module Log
+    DEFAULT_LOG_CONFIG = {
+      "default" => "info",
+    }
+    DEFAULT_DEBUG_LOG_CONFIG = {
+      "default" => "debug",
+    }
+
+    def log_init(component = self)
+      @log = Logging.logger[component]
+    end
+  end
+
+  class Logger
+    DEFAULT_COMPONENT = "default"
+
+    class << self
+      attr_reader :current_log_config
+
+      def logger(component = self)
+        Logging.logger[component]
+      end
+
+      private
+
+      def name_to_severity(data)
+        case data
+        when "debug"
+          :debug
+        when "info"
+          :info
+        when "warn", "warning"
+          :warn
+        when "err", "error"
+          :error
+        when "fatal"
+          :fatal
+        else
+          raise "Don't know how to treat #{data.inspect} as a logger severity!"
+        end
+      end
+
+      def json_to_appender(data)
+        case data.downcase
+        when "stdout"
+          Logging.appenders.stdout layout: @custom_log_layout
+        when "stderr"
+          Logging.appenders.stderr layout: @custom_log_layout
+        when String
+          Logging.appenders.file data, layout: @custom_log_layout
+        else
+          raise "Don't know how to convert #{data.inspect} to an appender!"
+        end
+      end
+
+      def json_configure_logger(logger, data)
+        case data
+        in String
+          sev = name_to_severity(data)
+          logger.level = sev
+        in [level, *locations]
+          if logger.name != "root"
+            # The Logging gem doesn't have an additive property on the root logger
+            logger.additive = false # Don't also log to parent/root loggers
+          end
+
+          logger.appenders = locations.map { |where| json_to_appender(where) }
+
+          logger.level = name_to_severity(level)
+        else
+          raise "Don't know how to use #{data.inspect} to specify a logger!"
+        end
+      end
+
+      def freeze_log_config(log_config)
+        log_config.each do |k, v|
+          k.freeze
+          v.freeze
+          v.each(&:freeze) if v.is_a?(Array)
+        end
+        log_config.freeze
+      end
+
+      public
+
+      def configure_logger(log_config)
+        # TODO: custom coloring? https://github.com/TwP/logging/blob/master/examples/colorization.rb
+        @custom_log_layout = Logging.layouts.pattern pattern: '[%r] %-5l %c: %m\n'
+
+        if log_config.is_a?(String) && File.exist?(log_config)
+          log_config = JSON.load_file(log_config)
+        end
+
+        log_config = freeze_log_config(log_config) unless log_config.nil?
+        @current_log_config = log_config # Save a copy for later
+
+        Logging.reset # Reset all Logging settings to defaults
+        Logging.reopen # For log-reconfig (e.g. test failures), often important to *not* store an open handle to a moved file
+        return if log_config.nil?
+
+        Logging.logger.root.appenders = [Logging.appenders.stdout]
+
+        default_logger = log_config[DEFAULT_COMPONENT] || "info"
+        json_configure_logger(Logging.logger.root, default_logger)
+
+        log_config.each do |component, logger_data|
+          next if component == DEFAULT_COMPONENT
+
+          sublogger = Logging.logger[component]
+          json_configure_logger(sublogger, logger_data)
+        end
+      end
+    end
+  end
+
+  class LoggedWrapper
+    include ::Scarpe::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
+  end
+end
+
+class Logging::Logger
+  alias_method :warning, :warn
+end
+
+log_config = if ENV["SCARPE_LOG_CONFIG"]
+  JSON.load_file(ENV["SCARPE_LOG_CONFIG"])
+else
+  ENV["SCARPE_DEBUG"] ? Scarpe::Log::DEFAULT_DEBUG_LOG_CONFIG : Scarpe::Log::DEFAULT_LOG_CONFIG
+end
+
+Scarpe::Logger.configure_logger(log_config)

data/lib/scarpe/para.rb

@@ -1,18 +1,90 @@
-module Scarpe
-  class Para
-    def initialize(app, text)
-      @app = app
-      @text = text
-      @app.append(render)
+# frozen_string_literal: true
+
+class Scarpe
+  class Para < Scarpe::Widget
+    class << self
+      def inherited(subclass)
+        Scarpe::Widget.widget_classes ||= []
+        Scarpe::Widget.widget_classes << subclass
+        super
+      end
+    end
+
+    display_properties :text_items, :stroke, :size, :font, :html_attributes, :hidden
+
+    def initialize(*args, stroke: nil, size: :para, font: nil, hidden: false, **html_attributes)
+      @text_children = args || []
+      if hidden
+        @hidden_text_items = text_children_to_items(@text_children)
+        @text_items = []
+      else
+        # Text_children alternates strings and TextWidgets, so we can't just pass
+        # it as a display property. It won't serialize.
+        @text_items = text_children_to_items(@text_children)
+        @hidden_text_items = []
+      end
+      stroke = to_rgb(stroke)
+
+      @html_attributes = html_attributes || {}
+
+      super
+
+      create_display_widget
+    end
+
+    def text_children_to_items(text_children)
+      text_children.map { |arg| arg.is_a?(String) ? arg : arg.linkable_id }
+    end
+
+    def replace(*children)
+      @text_children = children
+
+      # This should signal the display widget to change
+      self.text_items = text_children_to_items(@text_children)
+    end
+
+    def hide
+      # idempotent
+      return unless @hidden_text_items.empty?
+
+      @hidden_text_items = self.text_items
+      self.text_items = []
+    end
+
+    def show
+      # idempotent
+      return unless self.text_items.empty?
+
+      self.text_items = @hidden_text_items
+      @hidden_text_items = []
+    end
+  end
+
+  class Widget
+    def banner(*args, **kwargs)
+      para(*args, **{ size: :banner }.merge(kwargs))
     end
 
-    def render
-      "<p id=#{object_id}>#{@text}</p>"
+    def title(*args, **kwargs)
+      para(*args, **{ size: :title }.merge(kwargs))
     end
 
-    def replace(text)
-      @text = text
-      @app.window.eval("document.getElementById(#{object_id}).innerText = \"#{text}\"")
+    def subtitle(*args, **kwargs)
+      para(*args, **{ size: :subtitle }.merge(kwargs))
     end
+
+    def tagline(*args, **kwargs)
+      para(*args, **{ size: :tagline }.merge(kwargs))
+    end
+
+    def caption(*args, **kwargs)
+      para(*args, **{ size: :caption }.merge(kwargs))
+    end
+
+    def inscription(*args, **kwargs)
+      para(*args, **{ size: :inscription }.merge(kwargs))
+    end
+
+    alias_method :ins, :inscription
   end
-end
+end

data/lib/scarpe/promises.rb

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+# Funny thing... We need promises as an API concept since we have a JS event
+# loop doing its thing, and we need to respond to actions that it takes.
+# But there's not really a Ruby implementation of Promises *without* an
+# attached form of concurrency. So here we are, writing our own :-/
+#
+# In theory you could probably write some kind of "no-op thread pool"
+# for the ruby-concurrency gem, pass it manually to every promise we
+# created and then raise an exception any time we tried to do something
+# in the background. That's probably more code than writing our own, though,
+# and we'd be fighting it constantly.
+#
+# This class is inspired by concurrent-ruby [Promise](https://ruby-concurrency.github.io/concurrent-ruby/1.1.5/Concurrent/Promise.html)
+# which is inspired by Javascript Promises, which is what we actually need
+# for our use case. We can't easily tell when our WebView begins processing
+# our request, which removes the :processing state. This can be used for
+# executing JS, but also generally waiting on events.
+#
+# We don't fully control ordering here, so it *is* conceivable that a
+# child waiting on a parent can be randomly fulfilled, even if we didn't
+# expect it. We don't consider that an error. Similarly, we'll call
+# on_scheduled callbacks if a promise is fulfilled, even though we
+# never explicitly scheduled it. If a promise is *rejected* without
+# ever being scheduled, we won't call those callbacks.
+
+class Scarpe
+  class Promise
+    include Scarpe::Log
+
+    PROMISE_STATES = [:unscheduled, :pending, :fulfilled, :rejected]
+
+    attr_reader :state
+    attr_reader :parents
+    attr_reader :returned_value
+    attr_reader :reason
+
+    # These methods are meant to be a prettier interface to promises,
+    # suitable for day-to-day usage.
+
+    # Create a promise and then instantly fulfill it.
+    def self.fulfilled(return_val = nil, parents: [], &block)
+      p = Promise.new(parents: parents, &block)
+      p.fulfilled!(return_val)
+      p
+    end
+
+    # Create a promise and then instantly reject it.
+    def self.rejected(reason = nil, parents: [])
+      p = Promise.new(parents: parents)
+      p.rejected!(reason)
+      p
+    end
+
+    # Instance methods
+
+    def fulfilled!(value = nil)
+      set_state(:fulfilled, value)
+    end
+
+    def rejected!(reason = nil)
+      set_state(:rejected, reason)
+    end
+
+    def then(&block)
+      # Create a new promise. It's waiting on us. It runs the
+      # specified code when scheduled.
+      Promise.new(parents: [self], &block)
+    end
+
+    # The Promise.new method, along with all the various handlers,
+    # are pretty raw. They'll do what promises do, but they're not
+    # the prettiest. However, they ensure that guarantees are made
+    # and so on, so they're great as plumbing under the syntactic
+    # sugar above.
+
+    def initialize(state: nil, parents: [], &scheduler)
+      log_init("Promise")
+
+      # These are as initially specified, and effectively immutable
+      @state = state
+      @parents = parents
+
+      # These are what we're waiting on, and will be
+      # removed as time goes forward.
+      @waiting_on = parents.select { |p| !p.complete? }
+      @on_fulfilled = []
+      @on_rejected = []
+      @on_scheduled = []
+      @scheduler = scheduler
+      @executor = nil
+      @returned_value = nil
+      @reason = nil
+
+      if complete?
+        # Did we start out already fulfilled or rejected?
+        # If so, we can skip a lot of fiddly checking.
+        # Don't need a scheduler or to care about parents
+        # or anything.
+        @waiting_on = []
+        @scheduler = nil
+      elsif @parents.any? { |p| p.state == :rejected }
+        @state = :rejected
+        @waiting_on = []
+        @scheduler =  nil
+      elsif @state == :pending
+        # Did we get an explicit :pending? Then we don't need
+        # to schedule ourselves, or care about the scheduler
+        # in general.
+        @scheduler = nil
+      elsif @state.nil? || @state == :unscheduled
+        # If no state was given or we're unscheduled, we'll
+        # wait until our parents have all completed to
+        # schedule ourselves.
+
+        if @waiting_on.empty?
+          # No further dependencies, we can schedule ourselves
+          @state = :pending
+
+          # We have no on_scheduled handlers yet, but this will
+          # call and clear the scheduler.
+          call_handlers_for(:pending)
+        else
+          # We're still waiting on somebody, no scheduling yet
+          @state = :unscheduled
+          @waiting_on.each do |dep|
+            dep.on_fulfilled { parent_fulfilled!(dep) }
+            dep.on_rejected { parent_rejected!(dep) }
+          end
+        end
+      end
+    end
+
+    def complete?
+      @state == :fulfilled || @state == :rejected
+    end
+
+    # These promises are mostly designed for external execution.
+    # You could put together your own thread-pool, or use RPC,
+    # a WebView, a database or similar source of external calculation.
+    # But in some cases, sure, it's reasonable to execute locally.
+    # In those cases, you can register an executor, which will be
+    # called when the promise is ready to execute but has not yet
+    # done so. Registering an executor on a promise that is
+    # already fulfilled is an error. Registering an executor on
+    # a promise that has already rejected is a no-op.
+    def to_execute(&block)
+      case @state
+      when :fulfilled
+        # Should this be a no-op instead?
+        raise "Registering an executor on an already fulfilled promise means it will never run!"
+      when :rejected
+        return
+      when :unscheduled
+        @executor = block # save for later
+      when :pending
+        @executor = block
+        call_executor
+      else
+        raise "Internal error, illegal state!"
+      end
+
+      self
+    end
+
+    private
+
+    # set_state looks at the old and new states of the promise. It calls handlers and updates tracking
+    # data accordingly.
+    def set_state(new_state, value_or_reason = nil)
+      old_state = @state
+
+      # First, filter out illegal input
+      unless PROMISE_STATES.include?(old_state)
+        raise "Internal Promise error! Internal state was #{old_state.inspect}! Legal states: #{PROMISE_STATES.inspect}"
+      end
+
+      unless PROMISE_STATES.include?(new_state)
+        raise "Internal Promise error! Internal state was set to #{new_state.inspect}! " +
+          "Legal states: #{PROMISE_STATES.inspect}"
+      end
+
+      if new_state != :fulfilled && new_state != :rejected && !value_or_reason.nil?
+        raise "Internal promise error! Non-completed state transitions should not specify a value or reason!"
+      end
+
+      # Here's our state-transition grid for what we're doing here.
+      # "From" state is on the left, "to" state is on top.
+      #
+      #    U P F R
+      #
+      # U  - 1 . .
+      # P  X - . .
+      # F  X X - X
+      # R  X X X -
+      #
+      # -  Change from same to same, no effect
+      # X  Illegal for one reason or another, raise error
+      # .  Great, no problem, run handlers but not @scheduler or @executor
+      # 1  Interesting case - if we have an executor, actually change to a *different* state instead
+
+      # Transitioning from our state to our same state? No-op.
+      return if new_state == old_state
+
+      # Transitioning to any *different* state after being fulfilled or rejected? Nope. Those states are final.
+      if complete?
+        raise "Internal Promise error! Trying to change state from #{old_state.inspect} to #{new_state.inspect}!"
+      end
+
+      if old_state == :pending && new_state == :unscheduled
+        raise "Can't change state from :pending to :unscheduled! Scheduling is not reversible!"
+      end
+
+      # The next three checks should all be followed by calling handlers for the newly-changed state.
+      # See call_handlers_for below.
+
+      # Okay, we're getting scheduled.
+      if old_state == :unscheduled && new_state == :pending
+        @state = new_state
+        call_handlers_for(new_state)
+
+        # It's not impossible for the scheduler to do something that fulfills or rejects the promise.
+        # In that case it *also* called the appropriate handlers. Let's get out of here.
+        return if @state == :fulfilled || @state == :rejected
+
+        if @executor
+          # In this case we're still pending, but we have a synchronous executor. Let's do it.
+          call_executor
+        end
+
+        return
+      end
+
+      # Setting to rejected calls the rejected handlers. But no scheduling ever occurs, so on_scheduled handlers
+      # will never be called.
+      if new_state == :rejected
+        @state = :rejected
+        @reason = value_or_reason
+        call_handlers_for(new_state)
+      end
+
+      # If we go straight from :unscheduled to :fulfilled we *will* run the on_scheduled callbacks,
+      # because we pretend the scheduling *did* occur at some point. Normally that'll be no callbacks,
+      # of course.
+      #
+      # Fun-but-unfortunate trivia: you *can* fulfill a promise before all its parents are fulfilled.
+      # If you do, the unfinished parents will result in nil arguments to the on_fulfilled handler,
+      # because we have no other value to provide. The scheduler callback will never be called, but
+      # the on_scheduled callbacks, if any, will be.
+      if new_state == :fulfilled
+        @state = :fulfilled
+        @returned_value = value_or_reason
+        call_handlers_for(new_state)
+      end
+    end
+
+    # This private method calls handlers for a new state, removing those handlers
+    # since they have now been called. This interacts subtly with set_state()
+    # above, particularly in the case of fulfilling a promise without it ever being
+    # properly scheduled.
+    #
+    # The rejected handlers will be cleared if the promise is fulfilled and vice-versa.
+    # After rejection, no on_fulfilled handler should ever be called and vice-versa.
+    #
+    # When we go from :unscheduled to :pending, the scheduler, if any, should be
+    # called and cleared. That should *not* happen when going from :unscheduled to
+    # :fulfilled.
+    def call_handlers_for(state)
+      case state
+      when :fulfilled
+        @on_scheduled.each { |h| h.call(*@parents.map(&:returned_value)) }
+        @on_fulfilled.each { |h| h.call(*@parents.map(&:returned_value)) }
+        @on_scheduled = @on_rejected = @on_fulfilled = []
+        @scheduler = @executor = nil
+      when :rejected
+        @on_rejected.each { |h| h.call(*@parents.map(&:returned_value)) }
+        @on_fulfilled = @on_scheduled = @on_rejected = []
+        @scheduler = @executor = nil
+      when :pending
+        # A scheduler can get an exception. If so, treat it as rejection
+        # and the exception as the provided reason.
+        if @scheduler
+          begin
+            @scheduler.call(*@parents.map(&:returned_value))
+          rescue => e
+            @log.error("Error while running scheduler! #{e.full_message}")
+            rejected!(e)
+          end
+          @scheduler = nil
+        end
+        @on_scheduled.each { |h| h.call(*@parents.map(&:returned_value)) }
+        @on_scheduled = []
+      else
+        raise "Internal error! Trying to call handlers for #{state.inspect}!"
+      end
+    end
+
+    def parent_fulfilled!(parent)
+      @waiting_on.delete(parent)
+
+      # Last parent? If so, schedule ourselves.
+      if @waiting_on.empty? && !self.complete?
+        # This will result in :pending if there's no executor,
+        # or fulfilled/rejected if there is an executor.
+        set_state(:pending)
+      end
+    end
+
+    def parent_rejected!(parent)
+      @waiting_on = []
+
+      unless self.complete?
+        # If our parent was rejected and we were waiting on them,
+        # now we're rejected too.
+        set_state(:rejected)
+      end
+    end
+
+    def call_executor
+      raise("Internal error! Should not call_executor with no executor!") unless @executor
+
+      begin
+        result = @executor.call(*@parents.map(&:returned_value))
+        fulfilled!(result)
+      rescue => e
+        @log.error("Error running executor! #{e.full_message}")
+        rejected!(e)
+      end
+    ensure
+      @executor = nil
+    end
+
+    public
+
+    def on_fulfilled(&handler)
+      unless handler
+        raise "You must pass a block to on_fulfilled!"
+      end
+
+      case @state
+      when :fulfilled
+        handler.call(*@parents.map(&:returned_value))
+      when :pending, :unscheduled
+        @on_fulfilled << handler
+      when :rejected
+        # Do nothing
+      end
+
+      self
+    end
+
+    def on_rejected(&handler)
+      unless handler
+        raise "You must pass a block to on_rejected!"
+      end
+
+      case @state
+      when :rejected
+        handler.call(*@parents.map(&:returned_value))
+      when :pending, :unscheduled
+        @on_rejected << handler
+      when :fulfilled
+        # Do nothing
+      end
+
+      self
+    end
+
+    def on_scheduled(&handler)
+      unless handler
+        raise "You must pass a block to on_scheduled!"
+      end
+
+      # Add a pending handler or call it now
+      case @state
+      when :fulfilled, :pending
+        handler.call(*@parents.map(&:returned_value))
+      when :unscheduled
+        @on_scheduled << handler
+      when :rejected
+        # Do nothing
+      end
+
+      self
+    end
+  end
+end

data/lib/scarpe/shape.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "wv/shape_helper"
+
+class Scarpe
+  class Shape < Scarpe::Widget
+    include ShapeHelper
+    display_properties :left, :top
+
+    def initialize(left: nil, top: nil, path_commands: nil, &block)
+      @left = left
+      @top = top
+
+      super()
+      create_display_widget
+      instance_eval(&block) if block_given?
+    end
+  end
+end

data/lib/scarpe/spacing.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module Spacing
+    def self.included(includer)
+      includer.display_properties :margin, :padding
+    end
+  end
+end

data/lib/scarpe/span.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Span < Scarpe::Widget
+    display_properties :text, :stroke, :size, :font, :html_attributes
+
+    def initialize(text, stroke: nil, size: :span, font: nil, **html_attributes)
+      @text = text
+      @stroke = stroke
+      @size = size
+      @font = font
+      @html_attributes = html_attributes
+
+      super
+
+      create_display_widget
+    end
+
+    def replace(text)
+      @text = text
+
+      # This should signal the display widget to change
+      self.text = @text
+    end
+  end
+end