raindeer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8783b509655bf58e51f0e7afc0aa320832d8aee1b298d50771d4121c418b28d1
-  data.tar.gz: 1eaf600341059527fc7dc013df6cc24a3bc1ba7d606a34b5544b73630e10b0ea
+  metadata.gz: 8d79ce92ce79c7e46122adb4e9ba39968d9bf220cca424deba580f3a74ac26c6
+  data.tar.gz: 6970876678afd4bf8395135d52a9c1ff20858170282e3c97c540f1458338d4ea
 SHA512:
-  metadata.gz: 6328d1ed634f9e501e8abd946deccfe13e39ee68b863273bc5c6aa8b4822e449b9462bf3027a5147382802f0af2367995af807ac2144a18e66247f0c2603ceb0
-  data.tar.gz: 2268752ea3dbb8e0eb8190f007fa8263ac37e0eff6f4d1e737fbf04fc9760788e15af59e426d46e4bdd2105075a3795396f95a5d837136f6138a61c4263dc8db
+  metadata.gz: 947dd01220faa492c9abf83e78aae9ec07d5e6c5794724aa24dda43be39e8fe82822734c068612f1176246c64b3e5f34e205d5b2fbb7d5517be598d3e927b1f2
+  data.tar.gz: bb4fff4358eae10a7b3ee1085ad9bd35bd7ac795c639dcb48b8e7c7deea3055e592a1f196931fc98ad64161631b5107bd1ca75fe29086d415891e7cfc23d84d3

data/lib/boot.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
-require 'low_dependency'
 require 'low_event'
-require 'low_loop'
 require 'low_node'
 require 'low_type'
-require 'lowload'
+require 'providers'
 
-require_relative 'matrix/matrix'
 require_relative 'support/config_loader'
 
 env = {
@@ -20,16 +17,20 @@ env = {
 
 config = Rain::ConfigLoader.load('./config/config.yaml', env)
 
-LowDependency.provide('rain.router') do
+Providers.define('rain.router') do
+  require_relative 'router/router'
   Rain::Router.new
 end
 
-LowDependency.provide('rain.matrix') do
-  Rain::Matrix.new(event_pool: Low::Providers['low.event.pool'])
+Providers.define('rain.matrix') do
+  require_relative 'matrix/matrix'
+  Rain::Matrix.new(event_pool: Providers['low.event.pool'])
 end
 
-LowDependency.provide('low.loop') do
-  LowLoop.new(config:, router: Low::Providers['rain.router'], renderer: Low::Providers['rain.matrix'])
+Providers.define('low.loop') do
+  require 'low_loop'
+  LowLoop.new(config:, router: Providers['rain.router'], renderer: Providers['rain.matrix'])
 end
 
-LowLoad.dirload(File.expand_path('../system', __FILE__))
+require 'lowload'
+LowLoad.dirload(File.expand_path('system', __dir__))

data/lib/matrix/cursor.rb

@@ -10,19 +10,38 @@ module Rain
       @last_update = now
     end
 
+    # Unit tests use "duration" to skip forward in time, while feature tests and the real world use old fashioned linear time.
     def increment(delays:, inputs:, duration: nil)
-      next_index = @index + 1
-      duration = now - @last_update if duration.nil?
+      next_index = next_index(loop_count: inputs.count)
+
+      return unless delays[next_index] && (duration || now - @last_update) >= delays[next_index]
+
+      @index = next_index
+      @last_update = now
+
+      yield index
+    end
 
-      if delays[next_index] && duration >= delays[next_index]
+    def iterate(inputs:, loop_count:)
+      inputs.each do |input|
         @index += 1
-        @index = 0 if index >= inputs.count
-        @last_update = now
+        @index = 0 if index >= loop_count
 
-        yield index
+        yield index, input
       end
     end
 
+    def increase_index(loop_count:)
+      @index += 1
+      @index = 0 if @index >= loop_count
+    end
+
+    def next_index(loop_count:)
+      next_index = @index + 1
+      next_index = 0 if next_index >= loop_count
+      next_index
+    end
+
     private
 
     def now

data/lib/matrix/matrix.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'paint'
 require 'low_event'
 require 'observers'
+require 'paint'
 
 require_relative '../support/config_loader'
 require_relative 'stream'
@@ -11,77 +11,101 @@ module Rain
   class Matrix
     include Observers
 
-    observe Low::Events::EventPool
-
-    def initialize(event_pool:, config: Rain::ConfigLoader.load('./config/matrix.yaml'))
+    def initialize(event_pool:, config: ConfigLoader.load('./config/matrix.yaml'))
       @event_pool = event_pool
       @config = config
 
       @screen_size = nil
 
       @last_stream_index = -1
-      @streams = {}
+      @streams = {} # TODO: Could be a "stream pool" like event pool (a pool hash).
       @columns = []
     end
 
+    def redraw(screen_size:)
+      @setup ||= setup
+
+      @streams.each_value do |stream|
+        stream.redraw(cell_count: screen_size[:row_count])
+      end
+    end
+
     def render(screen_size:, show_output: true)
       if screen_size != @screen_size
         @screen_size = screen_size
-        redraw_streams
+        redraw(screen_size:)
       end
 
       render_streams(show_output:)
     end
 
-    def update(stream_id:, event_tree:)
-      upsert_stream(stream_id:, event_tree:)
+    # TODO: Introduce "on :new_event_tree do |event|" block construct in LowEvent for making event handlers more obvious.
+    # TODO: Observers should allow arbitrary params when triggering and observing.
+    def new_event_tree(event: Low::Events::EventTree)
+      stream = upsert_stream(event_tree: event)
+      stream.redraw(cell_count: @screen_size[:row_count])
     end
 
     private
 
-    def redraw_streams
-      @event_pool.event_trees.each do |stream_id, event_tree|
-        stream = upsert_stream(stream_id:, event_tree:)
-        stream.redraw(cell_count: @screen_size[:row_count])
-
-        @columns[stream.index] = upsert_stream(stream_id:, event_tree:)
+    def setup
+      @event_pool.event_trees.each_value do |event_tree|
+        upsert_stream(event_tree:)
       end
+
+      observe @event_pool
+
+      true
     end
 
-    def render_streams(show_output:)
-      @streams.each_value { |stream| stream.render }
+    def upsert_stream(event_tree:)
+      stream = @streams[event_tree.request_id] ||= Stream.new(index: generate_index, config: @config, event_tree:)
+      @columns[stream.index] = stream
+      stream
+    end
+
+    def render_streams(show_output: true) # rubocop:disable Metrics/AbcSize
+      @streams.each_value(&:render)
+
+      return unless show_output
+
+      output = ''.dup
 
       (0...@screen_size[:row_count]).each do |row_index|
         cell_outputs = []
         cell_colors = []
 
-        # Rendering streams can happen before redrawing streams and @columns haven't been populated yet (empty event pool).
-        (0...@screen_size[:column_count]).each do |column_index|
+        # Rendering streams can happen before redrawing streams, so @columns may not be populated yet.
+        (0...column_count).each do |column_index|
           cell_colors << (@columns[column_index].nil? ? nil : @columns[column_index].colors[row_index])
           cell_outputs << (@columns[column_index].nil? ? nil : @columns[column_index].outputs[row_index])
         end
 
-        output = cell_outputs.zip(cell_colors).map do |cell, color|
-          cell ? Paint[cell, color] : Paint[' ', nil]
+        output << "\n" + cell_outputs.zip(cell_colors).map do |cell, color| # rubocop:disable Style/StringConcatenation
+          cell ? Paint[cell, color] : Paint[' ']
         end.join(' ')
-
-        puts output if show_output
       end
-    end
 
-    def upsert_stream(stream_id:, event_tree:)
-      @streams[stream_id] ||= Stream.new(index:, config: @config, event_tree:)
+      system 'clear'
+      print output.delete_prefix("\n").delete_suffix("\n")
     end
 
-    def index
+    def generate_index
       case @config.start_col
       when :random
-        rand(0...@screen_size[:column_count])
+        rand(0...column_count)
       when :latest
         @last_stream_index += 1
-        return @last_stream_index = 0 if @last_stream_index >= @screen_size[:column_count]
+        return @last_stream_index = 0 if @last_stream_index >= column_count
+
         @last_stream_index
       end
     end
+
+    def column_count
+      return @screen_size[:column_count] if @screen_size[:column_count] < 10
+
+      (@screen_size[:column_count] / 2).to_i.clamp(1, nil)
+    end
   end
 end

data/lib/matrix/stream.rb

@@ -1,35 +1,58 @@
 # frozen_string_literal: true
 
+require 'low_event'
+require 'observers'
+
 require_relative 'cursor'
 
 module Rain
   class Stream
-    attr_reader :index, :colors, :outputs
+    include Observers
+    attr_reader :index, :inputs, :outputs, :delays, :colors, :head_cursor, :tail_cursor
 
-    ARROW = ['│', '▼']
+    ARROW = ['│', '▼'].freeze
 
     def initialize(index:, config:, event_tree:)
       @index = index
       @config = config
-
       @event_tree = event_tree
-      @event_cursor = 0
-      @redraw_cursor = 0
 
       @inputs = []
       @delays = []
       @colors = []
       @outputs = []
 
+      @event_cursor = 0
       @head_cursor = Cursor.new
       @tail_cursor = Cursor.new
+      @tail_cursor.index = 0
+
+      @show_cursor = Cursor.new
+      @hide_cursor = Cursor.new
+
+      observe event_tree
+    end
+
+    # TODO: Use "on :branch do |event|" syntax.
+    def branch(event: Low::Events::BranchEvent) # rubocop:disable Lint/UnusedMethodArgument
+      redraw(cell_count: @inputs.count)
     end
 
-    # Layout cells to fit the current cell count. Called on matrix initialization, screen size changes and on new events.
+    # Draw event names onto the current amount of cells in a stream, using cursors. Called when there's a new event.
+    #
+    #  INPUT DELAY OUTPUT
+    # ┌─────┬─────┬─────┐
+    # │  R  │  75 │     │ ◀── 2. Tail Cursor begins at index zero or a random starting index.
+    # │  e  │  75 │     │        A Head Cursor that wraps around will push the Tail Cursor down to be just beneath it.
+    # │  q  │  75 │     │        The Show Cursor will start at the Tail Cursor index.
+    # │  u  │  75 │     │
+    # │     │  75 │     │ ◀── 1. Head Cursor begins at index zero or a random starting index.
+    # │     │  75 │     │        It populates input for every character in an event name.
+    # │     │  75 │     │        Then sets a "75" delay for the Show Cursor.
+    # └─────┴─────┴─────┘
     def redraw(cell_count:)
-      @inputs.fill(nil, 0...cell_count)[0...cell_count]
-      @delays.fill(@config.min_delay, 0...cell_count)[0...cell_count]
-      @colors.fill(@config.cell_color, 0...cell_count)[0...cell_count]
+      randomize_start_index if first_cell_redraw? && @config.start_row == :random
+      resize_cells(cell_count:) if cell_count != @inputs.count
 
       (@event_cursor...@event_tree.sequence.count).each do |event_index|
         current_event = @event_tree.sequence[event_index]
@@ -38,24 +61,27 @@ module Rain
         redraw_event(current_event:, past_event:)
         @event_cursor += 1
       end
-
-      @inputs
     end
 
     # Render a cell's input as output after a delay, using cursors. Called on every frame.
-    # ┌─┐
-    # │R│ <-- Each cell is represented as an input, delay and output.
-    # │e│
-    # │q│ <-- The head cursor outputs the cell's input after a delay and colors the leading cell white.
-    # │ │
-    # │ │ <-- The tail cursor does the same thing but the input (and therefore output) will be empty.
-    # └─┘     The tail cursor can be before or after the head cursor depending on whether events wrap around.
     #
-    # Unit tests use "duration" to skip forwards in time, while matrix spec and the real world use old fashioned linear time.
-    def render(duration: nil)
-      @head_cursor.increment(delays:, inputs:, duration:) do |index|
-        prev_index = (index - 1).clamp(0, nil)
-        next_index = index >= @inputs.count ? 0 : index + 1
+    #  INPUT DELAY OUTPUT
+    # ┌─────┬─────┬─────┐
+    # │     │   0 │     │ ◀── 2. Hide Cursor moves the input to the output after a delay.
+    # │     │ 250 │  e  │        The nil input replaces the previous output of "R".
+    # │     │ 250 │  q  │
+    # │     │ 250 │  u  │ ◀── 1. Show Cursor moves the input to the output after a delay.
+    # │  e  │  75 │     │        Leaving behind nil input.
+    # │  s  │  75 │     │        Then sets a "250" delay for the Hide Cursor.
+    # │  t  │  75 │     │
+    # └─────┴─────┴─────┘
+    #
+    # TODO: Refactor "@colors" into an Effect that happens dynamically on render rather than stored as a column of data.
+    #       This will reduce the "Metrics/AbcSize" complexity.
+    def render(duration: nil) # rubocop:disable Metrics/AbcSize
+      @show_cursor.increment(delays:, inputs:, duration:) do |index|
+        prev_index = index.zero? ? @inputs.count - 1 : index - 1
+        next_index = index + 1 >= @inputs.count ? 0 : index + 1
 
         if @inputs[index]
           @outputs[index] = @inputs[index]
@@ -71,17 +97,14 @@ module Rain
 
     private
 
-    attr_reader :inputs, :delays
-
     def fade(duration: nil)
-      fade_start = rand(5_000..10_000)
-
-      if (now - @head_cursor.first_update) >= fade_start || (duration && duration >= fade_start)
-        @tail_cursor.increment(delays:, inputs:, duration:) do |index|
-          if @inputs[index].nil? && @outputs[index]
-            @outputs[index] = @inputs[index]
-            @delays[index] = 0
-          end
+      fade_start_delay = rand(5_000..10_000)
+      return unless (now - @show_cursor.first_update) >= fade_start_delay || duration
+
+      @hide_cursor.increment(delays:, inputs:, duration:) do |index|
+        if @inputs[index].nil? && @outputs[index]
+          @outputs[index] = @inputs[index]
+          @delays[index] = 0
         end
       end
     end
@@ -95,37 +118,42 @@ module Rain
     # │R│  FIRST EVENT
     # │e│  Each cell will render input as output after a minimum delay (since there's no prior event).
     # │q│
-    # │u│ 
+    # │u│
     # │e│
     # │s│
     # │t│
-    # └─┘ <-- Time has passed between events.
+    # └─┘ ◀── Time has passed between events.
     # ┌─┐
     # │││  SECOND EVENT
     # │▼│  The next event has data to work with, it can represent the time it took to get from the previous event to the next.
-    # │R│  Each cell will render after the largest duration of the following values:
+    # │R│  Each cell will delay render for the larger duration of either:
     # │o│   1. The minimum delay
-    # │u│   2. The time elapsed between events divided by the number of inputs
+    # │u│   2. The time elapsed between events divided by the number of cells
     # │t│
-    # │e│ <-- A cursor moves to the next cell after a delay and colors the leading cell white.
+    # │e│ ◀── A cursor moves to the next cell after a delay and colors the leading cell white.
     # └─┘
     def redraw_event(current_event:, past_event:)
-      if @event_cursor == 0
-        inputs = event_name(current_event:)
-        delay = @config.min_delay
-        randomize_start_row
-      else
-        inputs = [*ARROW, *event_name(current_event:)]
-        difference = current_event.created_at - past_event.created_at
-        delay = difference == 0 ? @config.min_delay : (difference / inputs.count).to_i.clamp(@config.min_delay, nil)
+      variable_delay = variable_delay(current_event:, past_event:)
+
+      characters = event_name(current_event:)
+      characters = [*ARROW, *characters] if @event_cursor > 0
+
+      @head_cursor.iterate(inputs: characters, loop_count: @inputs.count) do |index, input|
+        @inputs[index] = input
+        @delays[index] = first_cell_redraw? ? 0 : variable_delay # Don't add delay to the first cell, looks stuck.
+
+        @tail_cursor.increase_index(loop_count: @inputs.count) if @head_cursor.index == @tail_cursor.index
       end
 
-      inputs.each do |character|
-        @inputs[@redraw_cursor] = character
-        @delays[@redraw_cursor] = @redraw_cursor == 0 ? 0 : delay # Don't add delay to the first cell, looks stuck.
+      @hide_cursor.index = @head_cursor.index # Everything after me is old so it can fade away.
+    end
 
-        @redraw_cursor += 1
-        @redraw_cursor = 0 if @redraw_cursor >= @inputs.count
+    def variable_delay(current_event:, past_event:)
+      if @event_cursor.zero?
+        @config.min_delay
+      else
+        difference = current_event.created_at - past_event.created_at
+        difference.zero? ? @config.min_delay : (difference / inputs.count).to_i.clamp(@config.min_delay, nil)
       end
     end
 
@@ -133,12 +161,26 @@ module Rain
       current_event.class.name.split('::').last.delete_suffix('Event').chars
     end
 
-    def randomize_start_row
-      return unless @config.start_row == :random
+    def first_cell_redraw?
+      @head_cursor.index == -1
+    end
+
+    def resize_cells(cell_count:)
+      old_index = (@inputs.count - 1).clamp(0, nil)
+
+      @inputs = @inputs.fill(nil, old_index...cell_count)[0...cell_count]
+      @outputs = @outputs.fill(nil, old_index...cell_count)[0...cell_count]
+      @delays = @delays.fill(@config.min_delay, old_index...cell_count)[0...cell_count]
+      @colors = @colors.fill(@config.cell_color, old_index...cell_count)[0...cell_count]
+    end
+
+    def randomize_start_index
+      random_index = rand(0..2)
+
+      @head_cursor.index = random_index
+      @tail_cursor.index = random_index
 
-      random_index = rand(0..2) 
-      @redraw_cursor = random_index
-      @head_cursor.index = random_index - 1 # Head cursor always 1 index behind to make "increment" method's logic simple.
+      @show_cursor.index = random_index
     end
   end
 end

data/lib/raindeer.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'low_dependency'
 require 'low_event'
 require 'low_node'
 require 'low_type'
 require 'observers'
+require 'providers'
 
 require_relative 'router/router'
 
 module Raindeer
   class << self
     def router(&block)
-      Low::Providers['rain.router'].instance_eval(&block)
+      Providers['rain.router'].instance_eval(&block)
     end
   end
 end

data/lib/router/router.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'low_dependency'
 require 'low_event'
+require 'providers'
 
 require_relative 'route'
 require_relative 'route_event'

data/lib/system/routes_node.rbx

@@ -4,7 +4,7 @@ class RoutesNode < LowNode
   observe '/system/routes'
 
   def initialize(event:)
-    @routes = Low::Providers['rain.router'].routes
+    @routes = Providers['rain.router'].routes
   end
 
   def render(event:)

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raindeer
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raindeer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - maedi
@@ -38,21 +38,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: low_dependency
+  name: low_event
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: low_event
+  name: lowload
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -69,16 +69,16 @@ dependencies:
   name: low_loop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: low_node
   requirement: !ruby/object:Gem::Requirement
@@ -122,7 +122,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: lowload
+  name: antlers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -136,7 +136,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: antlers
+  name: expressions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,7 +150,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: expressions
+  name: observers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -164,7 +164,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: observers
+  name: providers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="