whirled_peas 0.3.0 → 0.4.0

data/lib/whirled_peas/config.rb

@@ -0,0 +1,21 @@
+module WhirledPeas
+  class Config
+    attr_writer :driver, :template_factory
+    attr_accessor :loading_template_factory
+
+    def driver
+      unless @driver
+        raise ConfigurationError, 'driver must be configured'
+      end
+      @driver
+    end
+
+    def template_factory
+      unless @template_factory
+        raise ConfigurationError, 'template_factory must be configured'
+      end
+      @template_factory
+    end
+  end
+  private_constant :Config
+end

data/lib/whirled_peas/errors.rb

@@ -0,0 +1,5 @@
+module WhirledPeas
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+end

data/lib/whirled_peas/frame.rb

@@ -1,9 +1,5 @@
-require_relative 'frame/event_loop'
-require_relative 'frame/producer'
-
 module WhirledPeas
   module Frame
-    TERMINATE = '__term__'
     EOF = '__EOF__'
   end
 

data/lib/whirled_peas/frame/event_loop.rb

@@ -1,15 +1,22 @@
+require_relative '../null_logger'
+require_relative '../ui/screen'
+
 module WhirledPeas
   module Frame
     class EventLoop
-      def initialize(template_factory, refresh_rate, logger=NullLogger.new)
+      LOGGER_ID = 'EVENT LOOP'
+
+      def initialize(template_factory, loading_template_factory, refresh_rate, logger=NullLogger.new)
         @template_factory = template_factory
+        @loading_template_factory = loading_template_factory
         @queue = Queue.new
-        @refresh_rate = refresh_rate
+        @frame_duration = 1.0 / refresh_rate
         @logger = logger
       end
 
-      def enqueue(name:, duration:, args:)
-        queue.push([name, duration, args])
+      def enqueue(name, duration, args)
+        # If duration is nil, set it to the duration of a single frame
+        queue.push([name, duration || frame_duration, args])
       end
 
       def running?
@@ -17,43 +24,68 @@ module WhirledPeas
       end
 
       def start
-        logger.info('EVENT LOOP') { 'Starting' }
-        @running = true
         screen = UI::Screen.new
-        sleep(0.01) while queue.empty?  # Wait for the first event
-        remaining_frames = 1
-        template = nil
-        while @running && remaining_frames > 0
-          frame_at = Time.now
-          next_frame_at = frame_at + 1.0 / refresh_rate
-          remaining_frames -= 1
-          if remaining_frames > 0
-            screen.refresh if screen.needs_refresh?
-          elsif !queue.empty?
-            name, duration, args = queue.pop
-            remaining_frames = duration ? duration * refresh_rate : 1
-            template = template_factory.build(name, args)
-            screen.paint(template)
-          end
-          sleep([0, next_frame_at - Time.now].max)
-        end
-        logger.info('EVENT LOOP') { 'Exiting normally' }
+        wait_for_content(screen)
+        play_content(screen)
       rescue
-        logger.warn('EVENT LOOP') { 'Exiting with error' }
-        @running = false
+        logger.warn(LOGGER_ID) { 'Exiting with error' }
         raise
       ensure
+        # We may have exited due to an EOF or a raised exception, set state so that
+        # instance reflects actual state.
+        @running = false
         screen.finalize if screen
       end
 
       def stop
-        logger.info('EVENT LOOP') { 'Stopping...' }
+        logger.info(LOGGER_ID) { 'Stopping...' }
         @running = false
       end
 
       private
 
-      attr_reader :template_factory, :queue, :refresh_rate, :logger
+      attr_reader :template_factory, :loading_template_factory, :queue, :frame_duration, :logger
+
+      def wait_for_content(screen)
+        if loading_template_factory
+          play_loading_screen(screen)
+        else
+          sleep(frame_duration) while queue.empty?
+        end
+      end
+
+      def play_loading_screen(screen)
+        while queue.empty?
+          screen.paint(loading_template_factory.build)
+          sleep(frame_duration)
+        end
+      end
+
+      def play_content(screen)
+        @running = true
+        template = nil
+        frame_until = Time.new(0)  # Tell the loop to immediately pick up a new frame
+        while running?
+          frame_start = Time.now
+          next_frame_at = frame_start + frame_duration
+          if frame_until > frame_start
+            # While we're still displaying the previous frame, refresh the screen
+            screen.refresh
+          elsif !queue.empty?
+            name, duration, args = queue.pop
+            if name == Frame::EOF
+              @running = false
+            else
+              frame_until = frame_start + duration
+              template = template_factory.build(name, args)
+              screen.paint(template)
+            end
+          else
+            wait_for_content(screen)
+          end
+          sleep([0, next_frame_at - Time.now].max)
+        end
+      end
     end
   end
 end

data/lib/whirled_peas/frame/print_consumer.rb

@@ -0,0 +1,33 @@
+require_relative '../null_logger'
+
+module WhirledPeas
+  module Frame
+    class PrintConsumer
+      LOGGER_ID = 'EVENT LOOP'
+
+      def initialize(logger=NullLogger.new)
+        @logger = logger
+      end
+
+      def enqueue(name, duration, args)
+        if name == Frame::EOF
+          puts "EOF frame detected"
+        else
+          displayed_for = duration ? "#{duration} second(s)" : '1 frame'
+          args_str = args.empty? ? '' : " (#{args.inspect})"
+          puts "Frame '#{name}' displayed for #{displayed_for}#{args_str}"
+        end
+      end
+
+      def start
+      end
+
+      def stop
+      end
+
+      private
+
+      attr_reader :logger
+    end
+  end
+end

data/lib/whirled_peas/frame/producer.rb

@@ -1,50 +1,61 @@
 require 'socket'
 require 'json'
 
+require_relative '../null_logger'
+
 module WhirledPeas
   module Frame
     class Producer
       LOGGER_ID = 'PRODUCER'
 
-      def self.produce(event_loop:, logger: NullLogger.new)
-        producer = new(event_loop, logger)
-        logger.info(LOGGER_ID) { 'Starting' }
+      # Manages the EventLoop lifecycle and yields a Producer to send frames to the
+      # EventLoop
+      def self.produce(consumer, logger=NullLogger.new)
+        producer = new(consumer, logger)
+        consumer_thread = Thread.new do
+          Thread.current.report_on_exception = false
+          consumer.start
+        end
         yield producer
-        logger.info(LOGGER_ID) { 'Done with yield' }
         producer.send_frame(Frame::EOF)
-        logger.info(LOGGER_ID) { 'Exited normally' }
+        producer.flush
       rescue => e
-        producer.send_frame(Frame::TERMINATE)
+        consumer.stop if consumer
         logger.warn(LOGGER_ID) { 'Exited with error' }
         logger.error(LOGGER_ID) { e }
         raise
+      ensure
+        consumer_thread.join if consumer_thread
       end
 
-      def initialize(event_loop, logger=NullLogger.new)
-        @event_loop = event_loop
+      def initialize(consumer, logger=NullLogger.new)
+        @consumer = consumer
         @logger = logger
         @queue = Queue.new
       end
 
+      # Buffer a frame to be played for the given duration. `#flush` must be called
+      # for frames to get pushed to the EventLoop.
+      #
+      # @param name [String] name of frame, which is passed to #build of the
+      #   TemplateFactory
+      # @param duration [Float|Integer] duration in seconds the frame should be,
+      #   displayed (default is nil, which results in a duration of a single refresh
+      #   cycle)
+      # @param args [Hash] key/value pair of arguments, which is passed to #build of
+      #   the TemplateFactory
       def send_frame(name, duration: nil, args: {})
-        event_loop.enqueue(name: name, duration: duration, args: args)
-        logger.debug(LOGGER_ID) { "Sending frame: #{name}" }
-      end
-
-      def enqueue_frame(name, duration: nil, args: {})
         queue.push([name, duration, args])
       end
 
+      # Send any buffered frames to the EventLoop
       def flush
-        while !queue.empty?
-          name, duration, args = queue.pop
-          send_frame(name: name, duration: duration, args: args)
-        end
+        consumer.enqueue(*queue.pop) while !queue.empty?
       end
 
       private
 
-      attr_reader :event_loop, :logger
+      attr_reader :consumer, :logger, :queue
     end
   end
 end

data/lib/whirled_peas/template.rb

@@ -0,0 +1,5 @@
+module WhirledPeas
+  module Template
+  end
+  private_constant :Template
+end

data/lib/whirled_peas/{ui → template}/element.rb

@@ -1,3 +1,5 @@
+require_relative '../utils/title_font'
+
 require_relative 'settings'
 
 module WhirledPeas
@@ -16,19 +18,23 @@ module WhirledPeas
     private_constant :Element
 
     class TextElement < Element
-      attr_reader :value
+      attr_reader :lines
 
       def initialize(name, settings)
         super(name, TextSettings.merge(settings))
       end
 
-      def value=(val)
+      def lines=(val)
         unless STRINGALBE_CLASSES.include?(val.class)
           raise ArgmentError, "Unsupported type for TextElement: #{val.class}"
         end
-        @value = val.to_s
-        @preferred_width = settings.width || value.length
-        @preferred_height = 1
+        if settings.title_font
+          @lines = Utils::TitleFont.to_s(val.to_s, settings.title_font).split("\n")
+        else
+          @lines = [val.to_s]
+        end
+        @preferred_width = settings.width || @lines.first.length
+        @preferred_height = @lines.length
       end
 
       def inspect(indent='')
@@ -63,7 +69,7 @@ module WhirledPeas
 
       def add_text(name=self.class.next_name, &block)
         element = TextElement.new(name, settings)
-        element.value = yield nil, element.settings
+        element.lines = yield nil, element.settings
         children << element
       end
 

data/lib/whirled_peas/{ui → template}/settings.rb

@@ -1,6 +1,7 @@
 require 'json'
 
-require_relative 'color'
+require_relative '../utils/color'
+require_relative '../utils/title_font'
 
 module WhirledPeas
   module UI
@@ -457,6 +458,12 @@ module WhirledPeas
     class TextSettings < ElementSettings
       include WidthSettings
       include AlignSettings
+
+      attr_reader :title_font
+
+      def title_font=(font)
+        @title_font = Utils::TitleFont.validate!(font)
+      end
     end
 
     class ContainerSettings < ElementSettings

data/lib/whirled_peas/ui.rb

@@ -1,7 +1,5 @@
-require_relative 'ui/element'
-require_relative 'ui/screen'
-
 module WhirledPeas
   module UI
   end
+  private_constant :UI
 end

data/lib/whirled_peas/ui/canvas.rb

@@ -1,4 +1,4 @@
-require_relative 'ansi'
+require_relative '../utils/ansi'
 
 module WhirledPeas
   module UI

data/lib/whirled_peas/ui/painter.rb

@@ -1,6 +1,8 @@
-require_relative 'ansi'
+require_relative '../template/element'
+require_relative '../template/settings'
+require_relative '../utils/ansi'
+
 require_relative 'canvas'
-require_relative 'settings'
 
 module WhirledPeas
   module UI
@@ -15,28 +17,30 @@ module WhirledPeas
       end
 
       def paint(&block)
-        yield canvas.stroke(canvas.left, canvas.top, justified)
+        text.lines.each.with_index do |line, index|
+          yield canvas.stroke(canvas.left, canvas.top + index, justified(line))
+        end
       end
 
       private
 
       attr_reader :text, :canvas
 
-      def visible
-        if text.value.length <= text.preferred_width
-          text.value
+      def visible(line)
+        if line.length <= text.preferred_width
+          line
         elsif text.settings.align == TextAlign::LEFT
-          text.value[0..text.preferred_width - 1]
+          line[0..text.preferred_width - 1]
         elsif text.settings.align == TextAlign::CENTER
-          left_chop = (text.value.length - text.preferred_width) / 2
-          right_chop = text.value.length - text.preferred_width - left_chop
-          text.value[left_chop..-right_chop - 1]
+          left_chop = (line.length - text.preferred_width) / 2
+          right_chop = line.length - text.preferred_width - left_chop
+          line[left_chop..-right_chop - 1]
         else
-          text.value[-text.preferred_width..-1]
+          line[-text.preferred_width..-1]
         end
       end
 
-      def justified
+      def justified(line)
         format_settings = [*text.settings.color, *text.settings.bg_color]
         format_settings << Ansi::BOLD if text.settings.bold?
         format_settings << Ansi::UNDERLINE if text.settings.underline?
@@ -45,13 +49,13 @@ module WhirledPeas
         when TextAlign::LEFT
           0
         when TextAlign::CENTER
-          [0, (text.preferred_width - text.value.length) / 2].max
+          [0, (text.preferred_width - line.length) / 2].max
         when TextAlign::RIGHT
-          [0, text.preferred_width - text.value.length].max
+          [0, text.preferred_width - line.length].max
         end
-        rjust = [0, text.preferred_width - text.value.length - ljust].max
+        rjust = [0, text.preferred_width - line.length - ljust].max
         Ansi.format(JUSTIFICATION * ljust, [*text.settings.bg_color]) +
-          Ansi.format(visible, format_settings) +
+          Ansi.format(visible(line), format_settings) +
           Ansi.format(JUSTIFICATION * rjust, [*text.settings.bg_color])
       end
     end

data/lib/whirled_peas/ui/screen.rb

@@ -1,6 +1,7 @@
 require 'highline'
 
-require_relative 'ansi'
+require_relative '../utils/ansi'
+
 require_relative 'painter'
 
 module WhirledPeas
@@ -16,26 +17,13 @@ module WhirledPeas
 
       def paint(template)
         @template = template
-        refresh
-      end
-
-      def needs_refresh?
-        @refreshed_width != width || @refreshed_height != height
+        draw
       end
 
       def refresh
-        strokes = [Ansi.cursor_visible(false), Ansi.cursor_pos, Ansi.clear_down]
-        Painter.paint(@template, Canvas.new(0, 0, width, height)) do |stroke|
-          unless stroke.chars.nil?
-            strokes << Ansi.cursor_pos(left: stroke.left, top: stroke.top)
-            strokes << stroke.chars
-          end
-        end
-        return unless @print_output
-        strokes.each(&method(:print))
-        STDOUT.flush
-        @refreshed_width = width
-        @refreshed_height = height
+        # No need to refresh if the screen dimensions have not changed
+        return if @refreshed_width == width || @refreshed_height == height
+        draw
       end
 
       def finalize
@@ -55,6 +43,21 @@ module WhirledPeas
       private
 
       attr_reader :cursor, :terminal, :width, :height
+
+      def draw
+        strokes = [Ansi.cursor_visible(false), Ansi.cursor_pos, Ansi.clear_down]
+        Painter.paint(@template, Canvas.new(0, 0, width, height)) do |stroke|
+          unless stroke.chars.nil?
+            strokes << Ansi.cursor_pos(left: stroke.left, top: stroke.top)
+            strokes << stroke.chars
+          end
+        end
+        return unless @print_output
+        strokes.each(&method(:print))
+        STDOUT.flush
+        @refreshed_width = width
+        @refreshed_height = height
+      end
     end
   end
 end