whirled_peas 0.4.0 → 0.7.1

data/lib/whirled_peas/frame/producer.rb

@@ -1,15 +1,22 @@
 require 'socket'
 require 'json'
 
-require_relative '../null_logger'
+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'
 
-      # Manages the EventLoop lifecycle and yields a Producer to send frames to the
-      # EventLoop
+      # 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
@@ -17,14 +24,13 @@ module WhirledPeas
           consumer.start
         end
         yield producer
-        producer.send_frame(Frame::EOF)
         producer.flush
       rescue => e
-        consumer.stop if consumer
         logger.warn(LOGGER_ID) { 'Exited with error' }
         logger.error(LOGGER_ID) { e }
         raise
       ensure
+        consumer.stop
         consumer_thread.join if consumer_thread
       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

data/lib/whirled_peas/graphics/composer.rb

@@ -0,0 +1,80 @@
+require 'whirled_peas/settings/box_settings'
+require 'whirled_peas/settings/grid_settings'
+require 'whirled_peas/settings/text_settings'
+
+require_relative 'box_painter'
+require_relative 'grid_painter'
+require_relative 'text_painter'
+
+module WhirledPeas
+  module Graphics
+    class Composer
+      # List of classes that convert nicely to a string
+      STRINGALBE_CLASSES = [FalseClass, Float, Integer, NilClass, String, Symbol, TrueClass]
+      private_constant :STRINGALBE_CLASSES
+
+      def self.stringable?(value)
+        STRINGALBE_CLASSES.include?(value.class)
+      end
+
+      def self.next_name
+        @counter ||= 0
+        @counter += 1
+        "Element-#{@counter}"
+      end
+
+      def self.build
+        settings = Settings::BoxSettings.new
+        template = BoxPainter.new('TEMPLATE', settings)
+        composer = Composer.new(template)
+        value = yield composer, settings
+        if !template.children? && stringable?(value)
+          composer.add_text { value.to_s }
+        end
+        template
+      end
+
+      attr_reader :painter
+
+      def initialize(painter)
+        @painter = painter
+      end
+
+      def add_text(name=self.class.next_name, &block)
+        child_settings = Settings::TextSettings.inherit(painter.settings)
+        child = TextPainter.new(name, child_settings)
+        # TextPainters are not composable, so yield nil
+        content = yield nil, child_settings
+        unless self.class.stringable?(content)
+          raise ArgumentError, "Unsupported type for text: #{content.class}"
+        end
+        child.content = content.to_s
+        painter.add_child(child)
+      end
+
+      def add_box(name=self.class.next_name, &block)
+        child_settings = Settings::BoxSettings.inherit(painter.settings)
+        child = BoxPainter.new(name, child_settings)
+        composer = self.class.new(child)
+        value = yield composer, child.settings
+        painter.add_child(child)
+        if !child.children? && self.class.stringable?(value)
+          composer.add_text("#{name}-Text") { value.to_s }
+        end
+      end
+
+      def add_grid(name=self.class.next_name, &block)
+        child_settings = Settings::GridSettings.inherit(painter.settings)
+        child = GridPainter.new(name, child_settings)
+        composer = self.class.new(child)
+        values = yield composer, child.settings
+        painter.add_child(child)
+        if !child.children? && values.is_a?(Array)
+          values.each.with_index do |value, index|
+            composer.add_text("#{name}-Text-#{index}") { value.to_s }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/whirled_peas/graphics/container_coords.rb

@@ -0,0 +1,72 @@
+module WhirledPeas
+  module Graphics
+    class ContainerCoords
+      def initialize(dimensions, settings, start_left, start_top)
+        @dimensions = dimensions
+        @settings = settings
+        @start_left = start_left
+        @start_top = start_top
+      end
+
+      def left
+        start_left + settings.position.left
+      end
+
+      def top
+        start_top + settings.position.top
+      end
+
+      def border_left
+        left + settings.margin.left
+      end
+
+      def border_top
+        top + settings.margin.top
+      end
+
+      def padding_left
+        border_left + (settings.border.left? ? 1 : 0)
+      end
+
+      def padding_top
+        border_top + (settings.border.top? ? 1 : 0)
+      end
+
+      def content_left(col_index=0)
+        padding_left + settings.padding.left + col_index * grid_width
+      end
+
+      def content_top(row_index=0)
+        padding_top + settings.padding.top + row_index * grid_height
+      end
+
+      def inner_grid_width
+        settings.padding.left +
+          dimensions.content_width +
+          settings.padding.right
+      end
+
+      def grid_width
+        (settings.border.inner_vert? ? 1 : 0) +
+          inner_grid_width +
+          (settings.scrollbar.vert? ? 1 : 0)
+      end
+
+      def inner_grid_height
+        settings.padding.top +
+          dimensions.content_height +
+          settings.padding.bottom
+      end
+
+      def grid_height
+        (settings.border.inner_horiz? ? 1 : 0) +
+          inner_grid_height +
+          (settings.scrollbar.horiz? ? 1 : 0)
+      end
+
+      private
+
+      attr_reader :settings, :dimensions, :start_left, :start_top
+    end
+  end
+end

data/lib/whirled_peas/graphics/container_dimensions.rb

@@ -0,0 +1,93 @@
+module WhirledPeas
+  module Graphics
+    class ContainerDimensions
+      attr_reader :children_width, :children_height, :num_cols, :num_rows
+
+      def initialize(settings, content_width, content_height, num_cols=1, num_rows=1)
+        @orig_content_width = content_width
+        @orig_content_height = content_height
+        @children_width = content_width
+        @children_height = content_height
+        @num_cols = num_cols
+        @num_rows = num_rows
+        @settings = settings
+      end
+
+      def content_width
+        return orig_content_width unless settings.width
+        if settings.border_sizing?
+          settings.width - outer_border_width - scrollbar_width - padding_width
+        else
+          settings.width
+        end
+      end
+
+      def content_height
+        return orig_content_height unless settings.height
+        if settings.border_sizing?
+          settings.height - outer_border_height - scrollbar_height - padding_height
+        else
+          settings.height
+        end
+      end
+
+      def outer_width
+        @outer_width ||= margin_width +
+          outer_border_width +
+          num_cols * (padding_width + content_width + scrollbar_width) +
+          (num_cols - 1) * inner_border_width
+      end
+
+      def outer_height
+        @outer_height ||= margin_height +
+          outer_border_height +
+          num_rows * (padding_height + content_height + scrollbar_height) +
+          (num_rows - 1) * inner_border_height
+      end
+
+      def margin_width
+        settings.margin.left + settings.margin.right
+      end
+
+      def margin_height
+        settings.margin.top + settings.margin.bottom
+      end
+
+      def outer_border_width
+        (settings.border.left? ? 1 : 0) + (settings.border.right? ? 1 : 0)
+      end
+
+      def outer_border_height
+        (settings.border.top? ? 1 : 0) + (settings.border.bottom? ? 1 : 0)
+      end
+
+      def inner_border_width
+        settings.border.inner_vert? ? 1 : 0
+      end
+
+      def inner_border_height
+        settings.border.inner_horiz? ? 1 : 0
+      end
+
+      def padding_width
+        settings.padding.left + settings.padding.right
+      end
+
+      def padding_height
+        settings.padding.top + settings.padding.bottom
+      end
+
+      def scrollbar_width
+        settings.scrollbar.vert? ? 1 : 0
+      end
+
+      def scrollbar_height
+        settings.scrollbar.horiz? ? 1 : 0
+      end
+
+      private
+
+      attr_reader :settings, :orig_content_width, :orig_content_height
+    end
+  end
+end