whirled_peas 0.3.0 → 0.7.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,7 @@
+module WhirledPeas
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  class SettingsError < Error; end
+end

data/lib/whirled_peas/frame.rb

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

data/lib/whirled_peas/frame/consumer.rb

@@ -0,0 +1,30 @@
+module WhirledPeas
+  module Frame
+    # Abstract class for consuming frame events.
+    class Consumer
+      EOF = '__EOF__'
+
+      def enqueue(name, duration, args)
+        raise NotImplemented, "#{self.class} must implement #enqueue"
+      end
+
+      def running?
+        @running == true
+      end
+
+      def start
+        self.running = true
+      end
+
+      def stop
+        enqueue(EOF, nil, {})
+      end
+
+      private
+
+      attr_writer :running
+    end
+
+    private_constant :Consumer
+  end
+end

data/lib/whirled_peas/frame/debug_consumer.rb

@@ -0,0 +1,30 @@
+require 'whirled_peas/null_logger'
+
+require_relative 'consumer'
+
+module WhirledPeas
+  module Frame
+    class DebugConsumer < Consumer
+      LOGGER_ID = 'PRINTER'
+
+      def initialize(output=STDOUT, logger=NullLogger.new)
+        @output = output
+        @logger = logger
+      end
+
+      def enqueue(name, duration, args)
+        if name == EOF
+          output.puts "EOF frame detected"
+        else
+          displayed_for = duration ? "#{duration} second(s)" : '1 frame'
+          args_str = args.empty? ? '' : " '#{JSON.generate(args)}'"
+          output.puts "Frame '#{name}' displayed for #{displayed_for}#{args_str}"
+        end
+      end
+
+      private
+
+      attr_reader :output, :logger
+    end
+  end
+end

data/lib/whirled_peas/frame/event_loop.rb

@@ -1,59 +1,90 @@
+require 'whirled_peas/null_logger'
+require 'whirled_peas/graphics/screen'
+
+require_relative 'consumer'
+
 module WhirledPeas
   module Frame
-    class EventLoop
-      def initialize(template_factory, refresh_rate, logger=NullLogger.new)
+    class EventLoop < Consumer
+      DEFAULT_REFRESH_RATE = 30
+
+      LOGGER_ID = 'EVENT LOOP'
+
+      def initialize(
+        template_factory,
+        loading_template_factory=nil,
+        refresh_rate: DEFAULT_REFRESH_RATE,
+        logger: NullLogger.new,
+        screen: Graphics::Screen.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
+        @screen = screen
       end
 
-      def enqueue(name:, duration:, args:)
-        queue.push([name, duration, args])
-      end
-
-      def running?
-        @running
+      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 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' }
+        super
+        wait_for_content
+        play_content
       rescue
-        logger.warn('EVENT LOOP') { 'Exiting with error' }
-        @running = false
+        self.running = false
+        logger.warn(LOGGER_ID) { 'Exiting with error' }
         raise
       ensure
-        screen.finalize if screen
+        screen.finalize
       end
 
-      def stop
-        logger.info('EVENT LOOP') { 'Stopping...' }
-        @running = false
+      private
+
+      attr_reader :template_factory, :loading_template_factory, :queue, :frame_duration, :logger, :screen
+
+      def wait_for_content
+        if loading_template_factory
+          play_loading_screen
+        else
+          sleep(frame_duration) while queue.empty?
+        end
       end
 
-      private
+      def play_loading_screen
+        while queue.empty?
+          screen.paint(loading_template_factory.build)
+          sleep(frame_duration)
+        end
+      end
 
-      attr_reader :template_factory, :queue, :refresh_rate, :logger
+      def play_content
+        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 == EOF
+              self.running = false
+            else
+              frame_until = frame_start + duration
+              template = template_factory.build(name, args)
+              screen.paint(template)
+            end
+          else
+            wait_for_content
+          end
+          sleep([0, next_frame_at - Time.now].max)
+        end
+      end
     end
   end
 end

data/lib/whirled_peas/frame/producer.rb

@@ -1,50 +1,67 @@
 require 'socket'
 require 'json'
 
+require 'whirled_peas/null_logger'
+
 module WhirledPeas
   module Frame
+    # A Producer is the object given to the driver as the interface that allows
+    # the driver to emit frame events. The recommended way of creating a Producer
+    # is by invoking `Producer.produce` as it handles the lifecycle methods of
+    # the consumer.
     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 consumer lifecycle and yields a Producer to send frames to the
+      # consumer
+      #
+      # @param consumer [Consumer] instance that consumes frame events through
+      #   `#enqueue`
+      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)
         logger.warn(LOGGER_ID) { 'Exited with error' }
         logger.error(LOGGER_ID) { e }
         raise
+      ensure
+        consumer.stop
+        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/graphics.rb

@@ -0,0 +1,19 @@
+module WhirledPeas
+  module Graphics
+    class << self
+      attr_accessor :debug
+
+      def debugger(string_or_proc)
+        return unless @debug
+        @debugger ||= Logger.new(STDOUT, level: Logger::DEBUG)
+        if string_or_proc.is_a?(Proc)
+          string = string_or_proc.call
+        else
+          string = string_or_proc
+        end
+        @debugger.debug(string)
+      end
+    end
+  end
+  private_constant :Graphics
+end

data/lib/whirled_peas/graphics/box_painter.rb

@@ -0,0 +1,101 @@
+require_relative 'container_painter'
+require_relative 'container_dimensions'
+
+module WhirledPeas
+  module Graphics
+    class BoxPainter < ContainerPainter
+      def paint(canvas, left, top, &block)
+        super
+        canvas_coords = coords(left, top)
+        content_canvas = canvas.child(
+          canvas_coords.content_left,
+          canvas_coords.content_top,
+          dimensions.content_width,
+          dimensions.content_height
+        )
+        return unless content_canvas.writable?
+        if settings.horizontal_flow?
+          paint_horizontally(content_canvas, canvas_coords, &block)
+        else
+          paint_vertically(content_canvas, canvas_coords, &block)
+        end
+      end
+
+      def dimensions
+        @dimensions ||= begin
+          content_width = 0
+          content_height = 0
+          if settings.horizontal_flow?
+            each_child do |child|
+              content_width += child.dimensions.outer_width
+              if child.dimensions.outer_height > content_height
+                content_height = child.dimensions.outer_height
+              end
+            end
+          else
+            each_child do |child|
+              if child.dimensions.outer_width > content_width
+                content_width = child.dimensions.outer_width
+              end
+              content_height += child.dimensions.outer_height
+            end
+          end
+          ContainerDimensions.new(settings, content_width, content_height)
+        end
+      end
+
+      def each_child(&block)
+        if settings.reverse_flow?
+          children.reverse.each(&block)
+        else
+          super
+        end
+      end
+
+      private
+
+      def paint_horizontally(canvas, canvas_coords, &block)
+        stroke_left = canvas_coords.content_left
+        stroke_top = canvas_coords.content_top
+        children_width = 0
+        each_child { |c| children_width += c.dimensions.outer_width }
+        left_offset, spacing_offset = horiz_justify_offset(children_width)
+        stroke_left += left_offset
+        each_child do |child|
+          top_offset, _ = vert_justify_offset(child.dimensions.outer_height)
+          child_width = child.dimensions.outer_width
+          child_canvas = canvas.child(
+            stroke_left,
+            stroke_top + top_offset,
+            child_width,
+            child.dimensions.outer_height
+          )
+          child.paint(child_canvas, stroke_left, stroke_top + top_offset, &block)
+          stroke_left += child_width + spacing_offset
+        end
+      end
+
+      def paint_vertically(canvas, canvas_coords, &block)
+        stroke_left = canvas_coords.content_left
+        stroke_top = canvas_coords.content_top
+        children_height = 0
+        each_child { |c| children_height += c.dimensions.outer_height }
+        top_offset, spacing_offset = vert_justify_offset(children_height)
+        stroke_top += top_offset
+        each_child do |child|
+          left_offset, _ = horiz_justify_offset(child.dimensions.outer_width)
+          child_height = child.dimensions.outer_height
+          child_canvas = canvas.child(
+            stroke_left + left_offset,
+            stroke_top ,
+            child.dimensions.outer_width,
+            child_height
+          )
+          child.paint(child_canvas, stroke_left + left_offset, stroke_top, &block)
+          stroke_top += child_height + spacing_offset
+        end
+      end
+    end
+    private_constant :BoxPainter
+  end
+end

data/lib/whirled_peas/graphics/canvas.rb

@@ -0,0 +1,118 @@
+require 'whirled_peas/utils/formatted_string'
+
+module WhirledPeas
+  module Graphics
+    # Canvas represent the area of the screen a painter can paint on.
+    class Canvas
+      attr_reader :left, :top, :width, :height
+
+      def self.unwritable
+        new(-1, -1, 0, 0)
+      end
+
+      def initialize(left, top, width, height)
+        @left = left
+        @top = top
+        @width = width
+        @height = height
+      end
+
+      def writable?
+        width > 0 || height > 0
+      end
+
+      def child(child_left, child_top, child_width, child_height)
+        Graphics.debugger(
+          proc do
+            "Create child: #{self.inspect}.child(left=#{child_left}, top=#{child_top}, width=#{child_width}, height=#{child_height})"
+          end
+        )
+        if child_left >= left + width
+          self.class.unwritable
+        elsif child_left + child_width <= left
+          self.class.unwritable
+        elsif child_top >= top + height
+          self.class.unwritable
+        elsif child_top + child_height <= top
+          self.class.unwritable
+        else
+          if child_left < left
+            child_width -= left - child_left
+            child_left = left
+          end
+          child_width = [width - (child_left - left), child_width].min
+          if child_top < top
+            child_height -= top - child_top
+            child_top = top
+          end
+          child_height = [height - (child_top - top), child_height].min
+          child_canvas = self.class.new(
+            child_left,
+            child_top,
+            child_width,
+            child_height,
+          )
+          Graphics.debugger(proc { "  -> #{child_canvas.inspect}" })
+          child_canvas
+        end
+      end
+
+      # Yields a single line of formatted characters positioned on the canvas,
+      # verifying only characters within the canvas are included.
+      def stroke(stroke_left, stroke_top, raw, formatting=[], &block)
+        Graphics.debugger(
+          proc do
+            "Stroke: #{self.inspect}.stroke(left=#{stroke_left}, top=#{stroke_top}, length=#{raw.length})"
+          end
+        )
+        if stroke_left >= left + width
+          # The stroke starts to the right of the canvas
+          fstring = Utils::FormattedString.blank
+        elsif stroke_left + raw.length <= left
+          # The stroke ends to the left of the canvas
+          fstring = Utils::FormattedString.blank
+        elsif stroke_top < top
+          # The stroke is above the canvas
+          fstring = Utils::FormattedString.blank
+        elsif stroke_top >= top + height
+          # The stroke is below the canvas
+          fstring = Utils::FormattedString.blank
+        else
+          # In this section, we know that at least part of the stroke should be visible
+          # on the canvas. Chop off parts of the raw string that aren't within the
+          # canvas boundary and ensure the stroke start position is also within the
+          # canvas boundary
+
+          # If the stroke starts to the left of the canvas, set the start index to the
+          # first value that will be on the canvas, then update stroke_left to be on
+          # the canvas
+          start_index = stroke_left < left ? left - stroke_left : 0
+          stroke_left = left if stroke_left <= left
+
+          # Determine how many characters from the stroke will fit on the canvas
+          visible_length = [raw.length, width - (stroke_left - left)].min
+          end_index = start_index + visible_length - 1
+          fstring = Utils::FormattedString.new(raw[start_index..end_index], formatting)
+        end
+        Graphics.debugger(
+          proc do
+            "  -> Stroke(left=#{stroke_left}, top=#{stroke_top}, length=#{fstring.length})"
+          end
+        )
+        yield stroke_left, stroke_top, fstring
+      end
+
+      def hash
+        [left, top, width, height].hash
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && hash == other.hash
+      end
+
+      def inspect
+        "Canvas(left=#{left}, top=#{top}, width=#{width}, height=#{height})"
+      end
+    end
+  end
+end