scarpe 0.2.0 → 0.2.2

data/scarpe-components/test/test_promises.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+require "scarpe/components/promises"
+
+class TestPromises < Minitest::Test
+  Promise = Scarpe::Promise
+
+  def setup
+    # Save so we can restore it post-test
+    @normal_log_config = Shoes::Log.current_log_config
+
+    # For these tests, don't log anything
+    Shoes::Log.configure_logger("default" => "fatal")
+  end
+
+  def teardown
+    # Restore previous log config
+    Shoes::Log.configure_logger(@normal_log_config)
+  end
+
+  def empty_promise_with_checker(state: nil, parents: [])
+    # Initially, no handlers have been called
+    called = {
+      fulfilled: false,
+      rejected: false,
+      scheduled: false,
+    }
+    p = Promise.new(state: state, parents: parents)
+    p.on_fulfilled { called[:fulfilled] = true }
+    p.on_rejected { called[:rejected] = true }
+    p.on_scheduled { called[:scheduled] = true }
+
+    [p, called]
+  end
+
+  def promise_that_immediately_returns(val, parents: [])
+    Promise.fulfilled(val, parents: parents)
+  end
+
+  def test_simple_promise_fulfillment
+    p, called = empty_promise_with_checker
+
+    p.fulfilled!
+
+    assert_equal true, called[:fulfilled], "Promise fulfilled handler wasn't called successfully on simple fulfillment!"
+    assert_equal false, called[:rejected], "Promise rejection handler was called on simple fulfillment!"
+    assert_equal true, called[:scheduled], "Promise scheduled handler wasn't called on simple fulfillment!"
+  end
+
+  def test_simple_promise_fulfillment_accessor
+    p = Promise.new
+
+    p.fulfilled!
+
+    assert_equal true, p.fulfilled?, "Promise fulfilled? accessor failed!"
+    assert_equal false, p.rejected?, "Promise rejected? accessor failed!"
+  end
+
+  def test_simple_promise_rejection_accessor
+    p = Promise.new
+
+    p.rejected!
+
+    assert_equal false, p.fulfilled?, "Promise fulfilled? accessor failed!"
+    assert_equal true, p.rejected?, "Promise rejected? accessor failed!"
+  end
+
+  def test_simple_promise_rejection
+    p, called = empty_promise_with_checker
+
+    p.rejected!
+
+    assert_equal false, called[:fulfilled], "Promise wasn't called successfully on simple rejection!"
+    assert_equal true, called[:rejected], "Promise rejection handler wasn't called on simple rejection!"
+
+    # Here's a fun thing - the on_scheduled handler *will* be called, but only if there's no incomplete
+    # parent, because effectively the promise will be scheduled during construction.
+    assert_equal true, called[:scheduled], "Promise scheduled handler wasn't called on simple rejection!"
+  end
+
+  def test_dependent_promise_fulfillment
+    parent_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent_promise])
+
+    # If a promise has an incomplete parent, it will start as unscheduled
+    assert_equal :unscheduled, promise.state
+    assert_equal false, called[:scheduled]
+
+    parent_promise.fulfilled!
+
+    # After the parent is complete, it will be scheduled
+    assert_equal :pending, promise.state
+    assert_equal true, called[:scheduled]
+  end
+
+  def test_dependent_promise_rejection
+    parent_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent_promise])
+
+    # If a promise has an incomplete parent, it will start as unscheduled
+    assert_equal :unscheduled, promise.state
+    assert_equal false, called[:scheduled]
+
+    parent_promise.rejected!
+
+    # After the parent is rejected, it will be rejected
+    assert_equal :rejected, promise.state
+    assert_equal false, called[:scheduled]
+    assert_equal true, called[:rejected]
+  end
+
+  def test_promise_with_initial_rejected_parent
+    parent1_promise = Promise.new
+    parent2_promise = Promise.rejected
+    promise, called = empty_promise_with_checker(parents: [parent1_promise, parent2_promise])
+
+    assert_equal :rejected, promise.state
+
+    assert_equal false, called[:scheduled]
+    assert_equal false, called[:fulfilled]
+    assert_equal true, called[:rejected]
+  end
+
+  def test_multiparent_fulfillment
+    parent1_promise = Promise.new
+    parent2_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent1_promise, parent2_promise])
+
+    parent1_promise.fulfilled!
+
+    assert_equal :unscheduled, promise.state
+    assert_equal false, called[:scheduled]
+
+    parent2_promise.fulfilled!
+
+    # After the parents are complete, it will be scheduled
+    assert_equal :pending, promise.state
+    assert_equal true, called[:scheduled]
+  end
+
+  def test_multiparent_rejection
+    parent1_promise = Promise.new
+    parent2_promise = Promise.new
+    promise, called = empty_promise_with_checker(parents: [parent1_promise, parent2_promise])
+
+    parent1_promise.rejected!
+
+    assert_equal :rejected, promise.state
+    assert_equal false, called[:scheduled]
+    assert_equal true, called[:rejected]
+  end
+
+  def test_instant_fulfillment
+    p = promise_that_immediately_returns(7)
+    assert_equal :fulfilled, p.state
+    assert_equal 7, p.returned_value, "The promise should be fulfilled with a value of 7!"
+  end
+
+  def test_multiparent_instant_fulfillment_with_args
+    parents = [
+      promise_that_immediately_returns(7),
+      promise_that_immediately_returns(5),
+      promise_that_immediately_returns(8),
+    ]
+    assert_equal true, parents.all? { |p| p.complete? && p.returned_value.is_a?(Integer) }
+    sum_up_promise = Promise.new(parents: parents)
+    sum_up_promise.to_execute { |*args| args.sum }
+
+    assert_equal :fulfilled, sum_up_promise.state
+    assert_equal 20, sum_up_promise.returned_value
+  end
+
+  def test_multiparent_delayed_fulfillment_with_args
+    parents = [
+      Promise.new,
+      promise_that_immediately_returns(10),
+      Promise.new,
+      Promise.new,
+    ]
+    sum_up_promise = Promise.new(parents: parents)
+    sum_up_promise.to_execute { |*args| args.sum }
+
+    parents[0].fulfilled!(3)
+    parents[2].fulfilled!(8)
+
+    assert_equal false, sum_up_promise.complete?
+
+    parents[3].fulfilled!(9)
+
+    assert_equal :fulfilled, sum_up_promise.state
+    assert_equal 30, sum_up_promise.returned_value
+  end
+
+  def test_simple_executor_success
+    p = Promise.new
+    p.to_execute { 7 }
+
+    assert_equal :fulfilled, p.state
+    assert_equal 7, p.returned_value
+  end
+
+  def test_simple_executor_failure
+    expected_err = RuntimeError.new "Yup, that's an error"
+    p = Promise.new
+    p.to_execute { raise expected_err }
+
+    assert_equal :rejected, p.state
+    assert_equal expected_err, p.reason
+  end
+
+  def test_delayed_executor_success
+    parent = Promise.new
+    p = Promise.new(parents: [parent])
+    p.to_execute { 7 }
+
+    assert_equal :unscheduled, p.state
+
+    parent.fulfilled!
+
+    assert_equal :fulfilled, p.state
+    assert_equal 7, p.returned_value
+  end
+
+  def test_scheduler_raise_error
+    expected_err = StandardError.new "Yup, that's an error"
+    p = Promise.new { raise expected_err }
+
+    assert_equal :rejected, p.state
+    assert_equal expected_err, p.reason, "Promise should record the raised error as the reason for rejection!"
+  end
+
+  def test_explicit_rejected_error
+    expected_err = StandardError.new "Yup, that's an error"
+    p = Promise.new
+
+    p.rejected!(expected_err)
+
+    assert_equal expected_err, p.reason, "Promise should record the raised error as the reason for rejection!"
+  end
+
+  def test_then_with_success
+    called = {
+      p1_scheduled: false,
+      p2_scheduled: false,
+      p3_scheduled: false,
+    }
+    p1 = Promise.new { called[:p1_scheduled] = true }
+    p1.then { called[:p2_scheduled] = true }.then { called[:p3_scheduled] = true }
+
+    assert_equal true, called[:p1_scheduled]
+    assert_equal false, called[:p2_scheduled]
+
+    p1.fulfilled!
+
+    assert_equal true, called[:p2_scheduled]
+    assert_equal false, called[:p3_scheduled]
+  end
+end

data/scarpe-components/test/test_segmented_app_files.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+require "scarpe/components/segmented_file_loader"
+
+SEG_TEST_DATA = {}
+
+class TestSegmentedAppFiles < Minitest::Test
+  def setup
+    @orig_file_loaders = Shoes.file_loaders
+    Shoes.reset_file_loaders # create new loaders array with no overlap with @orig_file_loaders
+    SEG_TEST_DATA.clear
+
+    @loader = Scarpe::Components::SegmentedFileLoader.new
+    Shoes.add_file_loader @loader
+  end
+
+  def teardown
+    Shoes.set_file_loaders(@orig_file_loaders)
+  end
+
+  def test_add_segment_type
+    @loader.add_segment_type("new_seg_type", proc { true })
+  end
+
+  def test_default_single_segment_with_front_matter
+    app = <<~SEG_TEST_FILE
+      ---
+      front_matter: yes
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_single_segment_no_front_matter_with_initial_name
+    app = <<~SEG_TEST_FILE
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_single_segment_no_front_matter_no_initial_name
+    app = <<~SEG_TEST_FILE
+      SEG_TEST_DATA[:app_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_double_segment_with_front_matter
+    app = <<~SEG_TEST_FILE
+      ---
+      front_matter: yes
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SCARPE_APP_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_empty_front_matter
+    app = <<~SEG_TEST_FILE
+      ---
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SCARPE_APP_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_double_segment_no_front_matter_with_initial_name
+    app = <<~SEG_TEST_FILE
+      ----- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SCARPE_APP_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_unnamed_double_segments
+    app = <<~SEG_TEST_FILE
+      -----
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SCARPE_APP_TEST']) # run test code
+      -----
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_default_double_segment_no_front_matter_no_initial_name
+    app = <<~SEG_TEST_FILE
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SCARPE_APP_TEST']) # run test code
+      ----- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_extra_dashes_in_dividers
+    app = <<~SEG_TEST_FILE
+      ---
+        front_matter: yes
+      ---------------- app code
+      SEG_TEST_DATA[:app_ran] = true
+      eval File.read(ENV['SCARPE_APP_TEST']) # run test code
+      ------- test code
+      SEG_TEST_DATA[:test_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ app_ran: true, test_ran: true }, SEG_TEST_DATA)
+  end
+
+  def test_custom_segment_types
+    # "shoes" type already exists and evaluates the code, don't need to add it
+    @loader.add_segment_type("capybara", proc { |path| load path })
+    @loader.add_segment_type("extra_data", proc { |path| load path })
+
+    app = <<~SEG_TEST_FILE
+      ---
+      :segments:
+      - shoes
+      - capybara
+      - extra_data
+      -----
+      SEG_TEST_DATA[:shoes_ran] = true
+      -----
+      SEG_TEST_DATA[:capy_ran] = true
+      -----
+      SEG_TEST_DATA[:extra_data_ran] = true
+    SEG_TEST_FILE
+    with_tempfile(["segfile_test_app", ".scas"], app) do |app_file|
+      Shoes.run_app(app_file)
+    end
+
+    assert_equal({ shoes_ran: true, capy_ran: true, extra_data_ran: true }, SEG_TEST_DATA)
+  end
+end

data/{lib/scarpe → spikes}/glibui/widget.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 class Scarpe
-  class GlimmerLibUIWidget < DisplayService::Linkable
+  class GlimmerLibUIWidget < Shoes::Linkable
     class << self
       def display_class_for(scarpe_class_name)
         scarpe_class = Scarpe.const_get(scarpe_class_name)
-        unless scarpe_class.ancestors.include?(Scarpe::DisplayService::Linkable)
+        unless scarpe_class.ancestors.include?(Shoes::Linkable)
           raise "Scarpe GlimmerLibUI can only get display classes for Scarpe linkable widgets, not #{scarpe_class.inspect}!"
         end
 

data/{lib/scarpe → spikes}/glibui.rb

@@ -26,4 +26,4 @@ require_relative "glibui/alert"
 require_relative "glibui/text_widget"
 require_relative "glibui/link"
 
-Scarpe::DisplayService.set_display_service_class(Scarpe::GlimmerLibUIDisplayService)
+Shoes::DisplayService.set_display_service_class(Scarpe::GlimmerLibUIDisplayService)

data/templates/basic_class_template.erb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 class Scarpe
-  class <%= argument %> < Scarpe::Widget
+  class <%= argument %> < Shoes::Widget
 
     # Display Properties
     # These properties determine the visual characteristics of the widget

data/templates/class_template_with_event_bind.erb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Scarpe
-  class <%= argument %> < Scarpe::Widget
+  class <%= argument %> < Shoes::Widget
      display_properties <%= display_properties %> # Write your display proporties here
 
     def initialize(text, width: nil, height: nil, top: nil, left: nil, &block)

data/templates/class_template_with_shapes.erb

@@ -3,7 +3,7 @@
 class Scarpe
   class InvalidAttributeValueError < StandardError; end
 
-  class <%= argument %> < Scarpe::Widget
+  class <%= argument %> < Shoes::Widget
      display_properties <%= display_properties %>  # Write your display proporties here
 
     def initialize(left, top)

data/templates/webview_template.erb

@@ -8,9 +8,6 @@ class Scarpe
 
     end
 
-      super
-    end
-
     def element
       HTML.render do |h|
         h.textarea(id: html_id, style: style)