scarpe 0.2.1 → 0.3.0

data/scarpe-components/lib/scarpe/components/minitest_import_runnable.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "json"
+require "json/add/exception"
+
+module Scarpe; module Components; end; end
+module Scarpe::Components::ImportRunnables
+  # Minitest Runnables are unusual - we expect to declare a class (like a Test) with
+  # a lot of methods to run. The ImportRunnable is a single Runnable. But whenever
+  # you tell it to import a JSON file, it will add all of the described tests to
+  # its runnable methods.
+  #
+  # Normally that means that your subclass tests will run up front and produce
+  # JSON files, then Minitest will autorun at the end and report all their
+  # results.
+  #
+  # It wouldn't really make sense to create these runnables during the testing
+  # phase, because Minitest has already decided what to run at that point.
+  class ImportRunnable #< Minitest::Runnable
+    # Import JSON from an exported Minitest run. Note that running this multiple
+    # times with overlapping class names may be really bad.
+    def self.import_json_data(data)
+      @imported_classes ||= {}
+      @imported_tests ||= {}
+
+      JSON.parse(data).each do |item|
+        klass = item["klass"]
+        meth = item["name"]
+        @imported_tests[klass] ||= {}
+        @imported_tests[klass][meth] = item
+      end
+
+      @imported_tests.each do |klass_name, test_method_hash|
+        klass = @imported_classes[klass_name]
+        unless klass
+          new_klass = Class.new(Minitest::Runnable)
+          @imported_classes[klass_name] = new_klass
+          ImportRunnable.const_set(klass_name, new_klass)
+          klass = new_klass
+
+          klass.define_singleton_method(:run_one_method) do |klass, method_name, reporter|
+            reporter.prerecord klass, method_name
+            imp = test_method_hash[method_name]
+
+            res = Minitest::Result.new imp["name"]
+            res.klass = imp["klass"]
+            res.assertions = imp["assertions"]
+            res.time = imp["time"]
+            res.failures = ImportRunnable.deserialize_failures imp["failures"]
+            res.metadata = imp["metadata"] if imp["metadata"]
+
+            # Record the synthetic result built from imported data
+            reporter.record res
+          end
+        end
+
+        # Update "runnables" method to reflect all current known runnable tests
+        klass_methods = test_method_hash.keys
+        klass.define_singleton_method(:runnable_methods) do
+          klass_methods
+        end
+      end
+    end
+
+    def self.json_to_err(err_json)
+      klass = begin
+        Object.const_get(err_json["json_class"])
+      rescue
+        nil
+      end
+      if klass && klass <= Minitest::Assertion
+        klass.json_create(err_json)
+      else
+        err = Exception.json_create(err_json)
+        Minitest::UnexpectedError.new(err)
+      end
+    end
+
+    def self.deserialize_failures(failures)
+      failures.map do |fail|
+        # Instantiate the Minitest::Assertion or Minitest::UnexpectedError
+        if fail[0] == "exception"
+          exc_json = JSON.parse(fail[1])
+          json_to_err exc_json
+        elsif fail[0] == "unexpected"
+          unexpected_json = JSON.parse(fail[1])
+          inner_json = JSON.parse(fail[2])
+          outer_err = json_to_err unexpected_json
+          inner_err = json_to_err inner_json
+          outer_err.error = inner_err
+        else
+          raise "Unknown exception data when trying to deserialize! #{fail.inspect}"
+        end
+      end
+    end
+  end
+end

data/scarpe-components/lib/scarpe/components/minitest_result.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "json"
+#require "json/add/exception"
+
+module Scarpe; module Components; end; end
+
+# A MinitestResult imports a JSON file from a minitest_export_reporter.
+# But instead of creating a Minitest::Test to report the result, the
+# MinitestResult is just a queryable Ruby object.
+#
+# MinitestResult assumes there will be only one class and one method
+# in the JSON, which is true for Scarpe but not necessarily in general.
+class Scarpe::Components::MinitestResult
+  attr_reader :assertions
+  attr_reader :method_name
+  attr_reader :class_name
+
+  def initialize(filename)
+    data = JSON.parse File.read(filename)
+
+    unless data.size == 1
+      # We would want a different interface to support this in general. For now we don't
+      # need it to work in general.
+      raise "Scarpe::Components::MinitestResult only supports one class and method in results!"
+    end
+
+    item = data.first
+
+    @assertions = item["assertions"]
+    @method_name = item["name"]
+    @class_name = item["klass"]
+    @time = item["time"]
+    @metadata = item.key?("metadata") ? item["metadata"]: {}
+
+    @skip = false
+    @exceptions = []
+    @failures = []
+    item["failures"].each do |f|
+      # JSON.parse ignores json_class and won't create an arbitrary object. That's good
+      # because Minitest::UnexpectedError seems to load in a bad way, so we don't want
+      # it to auto-instantiate.
+      d = JSON.parse f[1]
+      msg = d["m"]
+      case d["json_class"]
+      when "Minitest::UnexpectedError"
+        @exceptions << msg
+      when "Minitest::Skip"
+        @skip = msg
+      when "Minitest::Assertion"
+        @failures << msg
+      else
+        raise Scarpe::InternalError, "Didn't expect type #{t.inspect} as exception type when importing Minitest tests!"
+      end
+    end
+  end
+
+  def error?
+    !@exceptions.empty?
+  end
+
+  def fail?
+    !@failures.empty?
+  end
+
+  def skip?
+    @skip ? true : false
+  end
+
+  def passed?
+    @exceptions.empty? && @failures.empty? && !@skip
+  end
+
+  def error_message
+    @exceptions[0]
+  end
+
+  def fail_message
+    @failures[0]
+  end
+
+  def skip_message
+    @skip
+  end
+end

data/scarpe-components/lib/scarpe/components/modular_logger.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "logging"
+require "json"
+
+require "shoes/log"
+
+# Requires the logging gem
+
+module Scarpe; end
+module Scarpe::Components; end
+module Scarpe
+  class Components::ModularLogImpl
+    include Shoes::Log # for constants
+
+    def logger_for_component(component)
+      Logging.logger[component]
+    end
+
+    private
+
+    def name_to_severity(data)
+      case data
+      when "debug"
+        :debug
+      when "info"
+        :info
+      when "warn"
+        :warn
+      when "err", "error"
+        :error
+      when "fatal"
+        :fatal
+      else
+        raise Shoes::Errors::InvalidAttributeValueError, "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 Shoes::Errors::InvalidAttributeValueError, "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 Shoes::Errors::InvalidAttributeValueError, "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
+
+#Shoes::Log.instance = Scarpe::Components::ModularLogImpl.new
+#Shoes::Log.configure_logger(Shoes::Log::DEFAULT_LOG_CONFIG)

data/scarpe-components/lib/scarpe/components/print_logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "shoes/log"
+require "json"
+
+module Scarpe; end
+module Scarpe::Components; end
+class Scarpe::Components::PrintLogImpl
+  include Shoes::Log # for constants
+
+  class PrintLogger
+    class << self
+      attr_accessor :silence
+    end
+
+    def initialize(component_name)
+      @comp_name = component_name
+    end
+
+    def error(msg)
+      puts "#{@comp_name} error: #{msg}" unless PrintLogger.silence
+    end
+
+    def warn(msg)
+      puts "#{@comp_name} warn: #{msg}" unless PrintLogger.silence
+    end
+
+    def debug(msg)
+      puts "#{@comp_name} debug: #{msg}" unless PrintLogger.silence
+    end
+
+    def info(msg)
+      puts "#{@comp_name} info: #{msg}" unless PrintLogger.silence
+    end
+  end
+
+  def logger_for_component(component)
+    PrintLogger.new(component.to_s)
+  end
+
+  def configure_logger(log_config)
+    # For now, ignore
+  end
+end
+
+#Shoes::Log.instance = Scarpe::PrintLogImpl.new
+#Shoes::Log.configure_logger(Shoes::Log::DEFAULT_LOG_CONFIG)

data/{lib/scarpe → scarpe-components/lib/scarpe/components}/promises.rb

@@ -1,42 +1,56 @@
 # 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
+module Scarpe; end
+module Scarpe::Components; end
+module Scarpe
+  # Scarpe::Promise is a promises library, but one with no form of built-in
+  # concurrency. Instead, promise callbacks are executed synchronously.
+  # Even execution is usually synchronous, but can also be handled manually
+  # for forms of execution not controlled in Ruby (like Webview.)
+  #
+  # 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 Promise
-    include Scarpe::Log
+    include Shoes::Log
 
+    # The unscheduled promise state means it's waiting on a parent promise that
+    # hasn't completed yet. The pending state means it's waiting to execute.
+    # Fulfilled means it has completed successfully and returned a value,
+    # while rejected means it has failed, normally producing a reason.
     PROMISE_STATES = [:unscheduled, :pending, :fulfilled, :rejected]
 
+    # The state of the promise, which should be one of PROMISE_STATES
     attr_reader :state
+
+    # The parent promises of this promise, sometimes an empty array
     attr_reader :parents
+
+    # If the promise is fulfilled, this is the value returned
     attr_reader :returned_value
-    attr_reader :reason
 
-    # These methods are meant to be a prettier interface to promises,
-    # suitable for day-to-day usage.
+    # If the promise is rejected, this is the reason, sometimes an exception
+    attr_reader :reason
 
     # Create a promise and then instantly fulfill it.
     def self.fulfilled(return_val = nil, parents: [], &block)
@@ -52,19 +66,19 @@ class Scarpe
       p
     end
 
-    # Instance methods
-
+    # Fulfill the promise, setting the returned_value to value
     def fulfilled!(value = nil)
       set_state(:fulfilled, value)
     end
 
+    # Reject the promise, setting the reason to reason
     def rejected!(reason = nil)
       set_state(:rejected, reason)
     end
 
+    # Create a new promise with this promise as a parent. It runs the
+    # specified code in block when scheduled.
     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
 
@@ -73,7 +87,15 @@ class Scarpe
     # the prettiest. However, they ensure that guarantees are made
     # and so on, so they're great as plumbing under the syntactic
     # sugar above.
-
+    #
+    # Note that the state passed in may not be the actual initial
+    # state. If a parent is rejected, the state will become
+    # rejected. If no parents are waiting or failed then a state
+    # of nil or :unscheduled will become :pending.
+    #
+    # @param state [Symbol] One of PROMISE_STATES for the initial state
+    # @param parents [Array] A list of promises that must be fulfilled before this one is scheduled
+    # @yield A block that executes when this promise is scheduled - when its parents, if any, are all fulfilled
     def initialize(state: nil, parents: [], &scheduler)
       log_init("Promise")
 
@@ -131,15 +153,43 @@ class Scarpe
       end
     end
 
+    # Return true if the Promise is either fulfilled or rejected.
+    #
+    # @return [Boolean] true if the promise is fulfilled or rejected
     def complete?
       @state == :fulfilled || @state == :rejected
     end
 
+    # Return true if the promise is already fulfilled.
+    #
+    # @return [Boolean] true if the promise is fulfilled
+    def fulfilled?
+      @state == :fulfilled
+    end
+
+    # Return true if the promise is already rejected.
+    #
+    # @return [Boolean] true if the promise is rejected
+    def rejected?
+      @state == :rejected
+    end
+
+    # An inspect method to give slightly smaller output, for ease of reading in irb
+    def inspect
+      "#<Scarpe::Promise:#{object_id} " +
+        "@state=#{@state.inspect} @parents=#{@parents.inspect} " +
+        "@waiting_on=#{@waiting_on.inspect} @on_fulfilled=#{@on_fulfilled.size} " +
+        "@on_rejected=#{@on_rejected.size} @on_scheduled=#{@on_scheduled.size} " +
+        "@scheduler=#{@scheduler ? "Y" : "N"} @executor=#{@executor ? "Y" : "N"} " +
+        "@returned_value=#{@returned_value.inspect} @reason=#{@reason.inspect}" +
+        ">"
+    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
+    # But in many cases 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
@@ -148,7 +198,7 @@ class Scarpe
       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!"
+        raise Scarpe::NoOperationError, "Registering an executor on an already fulfilled promise means it will never run!"
       when :rejected
         return
       when :unscheduled
@@ -157,7 +207,7 @@ class Scarpe
         @executor = block
         call_executor
       else
-        raise "Internal error, illegal state!"
+        raise Scarpe::InternalError, "Internal error, illegal state!"
       end
 
       self
@@ -172,16 +222,16 @@ class Scarpe
 
       # 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}"
+        raise Scarpe::InternalError, "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}! " +
+        raise Scarpe::InternalError, "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!"
+        raise Scarpe::InternalError, "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.
@@ -204,11 +254,11 @@ class Scarpe
 
       # 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}!"
+        raise Scarpe::InternalError, "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!"
+        raise Shoes::Errors::InvalidAttributeValueError, "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.
@@ -291,7 +341,7 @@ class Scarpe
         @on_scheduled.each { |h| h.call(*@parents.map(&:returned_value)) }
         @on_scheduled = []
       else
-        raise "Internal error! Trying to call handlers for #{state.inspect}!"
+        raise Scarpe::InternalError, "Internal error! Trying to call handlers for #{state.inspect}!"
       end
     end
 
@@ -317,7 +367,7 @@ class Scarpe
     end
 
     def call_executor
-      raise("Internal error! Should not call_executor with no executor!") unless @executor
+      raise(Scarpe::InternalError, "Internal error! Should not call_executor with no executor!") unless @executor
 
       begin
         result = @executor.call(*@parents.map(&:returned_value))
@@ -332,9 +382,14 @@ class Scarpe
 
     public
 
+    # Register a handler to be called when the promise is fulfilled.
+    # If called on a fulfilled promise, the handler will be called immediately.
+    #
+    # @yield Handler to be called on fulfilled
+    # @return [Scarpe::Promise] self
     def on_fulfilled(&handler)
       unless handler
-        raise "You must pass a block to on_fulfilled!"
+        raise Shoes::Errors::InvalidAttributeValueError, "You must pass a block to on_fulfilled!"
       end
 
       case @state
@@ -349,9 +404,14 @@ class Scarpe
       self
     end
 
+    # Register a handler to be called when the promise is rejected.
+    # If called on a rejected promise, the handler will be called immediately.
+    #
+    # @yield Handler to be called on rejected
+    # @return [Scarpe::Promise] self
     def on_rejected(&handler)
       unless handler
-        raise "You must pass a block to on_rejected!"
+        raise Shoes::Errors::InvalidAttributeValueError, "You must pass a block to on_rejected!"
       end
 
       case @state
@@ -366,9 +426,15 @@ class Scarpe
       self
     end
 
+    # Register a handler to be called when the promise is scheduled.
+    # If called on a promise that was scheduled earlier, the handler
+    # will be called immediately.
+    #
+    # @yield Handler to be called on scheduled
+    # @return [Scarpe::Promise] self
     def on_scheduled(&handler)
       unless handler
-        raise "You must pass a block to on_scheduled!"
+        raise Shoes::Errors::InvalidAttributeValueError, "You must pass a block to on_scheduled!"
       end
 
       # Add a pending handler or call it now
@@ -384,4 +450,5 @@ class Scarpe
       self
     end
   end
+  Components::Promise = Promise
 end