whirled_peas 0.5.0 → 0.9.0

data/lib/whirled_peas/graphics/graph_painter.rb

@@ -0,0 +1,95 @@
+require 'whirled_peas/utils/ansi'
+
+require_relative 'content_painter'
+
+module WhirledPeas
+  module Graphics
+    class GraphPainter < ContentPainter
+      def paint(canvas, left, top, &block)
+        axis_formatting = [*settings.axis_color, *settings.bg_color]
+        plot_formatting = [*settings.color, *settings.bg_color]
+        axes_lines.each.with_index do |axis_line, row_index|
+          canvas.stroke(left, top + row_index, axis_line, axis_formatting, &block)
+          next if row_index >= plot_lines.length
+          canvas.stroke(left + 1, top + row_index, plot_lines[row_index], plot_formatting, &block)
+        end
+      end
+
+      private
+
+      def content_lines
+        axes_lines
+      end
+
+      def plot_lines
+        return @plot_lines if @plot_lines
+        min_y = 1.0 / 0
+        max_y = -1.0 / 0
+        if settings.width
+          interpolated = inner_width.times.map do |i|
+            x = (i * (content.length - 1).to_f / inner_width).floor
+            max_y = content[x] if content[x] > max_y
+            min_y = content[x] if content[x] < min_y
+            content[x]
+          end
+        else
+          interpolated = content
+          content.each do |y|
+            max_y = y if y > max_y
+            min_y = y if y < min_y
+          end
+        end
+        scaled = interpolated.map do |y|
+          (2 * inner_height * (y - min_y).to_f / (max_y - min_y)).floor
+        end
+        @plot_lines = Array.new(inner_height) { '' }
+        scaled.each.with_index do |y, x_index|
+          @plot_lines.each.with_index do |row, row_index|
+            y_index = inner_height - row_index - 1
+            asc, next_y = if scaled.length == 1
+              [true, y]
+            elsif x_index == scaled.length - 1
+              y >= scaled[x_index - 1]
+              [true, y]
+            else
+              scaled[x_index + 1] >= y
+              [true, scaled[x_index + 1]]
+            end
+            if asc
+              top_half = (y...next_y).include?(2 * y_index + 1)
+              bottom_half = (y...next_y).include?(2 * y_index)
+            else
+              top_half = (next_y...y).include?(2 * y_index + 1)
+              bottom_half = (next_y...y).include?(2 * y_index)
+            end
+            row << if top_half && bottom_half
+              '█'
+            elsif top_half
+              '▀'
+            elsif bottom_half
+              '▄'
+            else
+              ' '
+            end
+          end
+        end
+        @plot_lines
+      end
+
+      def inner_height
+        settings.height - 1
+      end
+
+      def inner_width
+        settings.width.nil? ? content.length : settings.width - 1
+      end
+
+      def axes_lines
+        return @axes_lines if @axes_lines
+        @axes_lines = inner_height.times.map { '┃' }
+        @axes_lines << '┗' + '━' * inner_width
+        @axes_lines
+      end
+    end
+  end
+end

data/lib/whirled_peas/graphics/grid_painter.rb

@@ -4,33 +4,30 @@ require_relative 'container_painter'
 module WhirledPeas
   module Graphics
     class GridPainter < ContainerPainter
-      def paint(canvas, &block)
+      def paint(canvas, left, top, &block)
         super
         return unless canvas.writable?
         each_child.with_index do |child, index|
-          col_index = index % dimensions.num_cols
-          row_index = index / dimensions.num_cols
-          content_left = coords(canvas).content_left(col_index)
-          if settings.align_center?
-            content_left += (dimensions.content_width - child.dimensions.outer_width) / 2
-          elsif settings.align_right?
-            content_left += dimensions.content_width - child.dimensions.outer_width
-          end
+          col_index, row_index = grid_cell(index)
+          left_offset, _ = horiz_justify_offset(child.dimensions.outer_width)
+          top_offset, _ = vert_justify_offset(child.dimensions.outer_height)
           child_canvas = canvas.child(
-            content_left,
-            coords(canvas).content_top(row_index),
+            coords(left, top).content_left(col_index) + left_offset,
+            coords(left, top).content_top(row_index) + top_offset,
             [dimensions.content_width, child.dimensions.outer_width].min,
             [dimensions.content_height, child.dimensions.outer_height].min
           )
-          child.paint(child_canvas, &block)
+          child.paint(
+            child_canvas,
+            coords(left, top).content_left(col_index) + left_offset,
+            coords(left, top).content_top(row_index) + top_offset,
+            &block
+          )
         end
       end
 
       def dimensions
         @dimensions ||= begin
-          if settings.num_cols.nil? || settings.num_cols == 0
-            raise SettingsError, "`num_cols` must be set for GridSettings(#{name})"
-          end
           num_cols = settings.num_cols
           num_rows = (num_children.to_f / num_cols).ceil
           content_width = 0
@@ -50,6 +47,19 @@ module WhirledPeas
           )
         end
       end
+
+      private
+
+      def grid_cell(index)
+        if settings.horizontal_flow?
+          col_index, row_index = [index % dimensions.num_cols, index / dimensions.num_cols]
+          col_index = dimensions.num_cols - col_index - 1 if settings.reverse_flow?
+        else
+          col_index, row_index = [index / dimensions.num_rows, index % dimensions.num_rows]
+          row_index = dimensions.num_rows - row_index - 1 if settings.reverse_flow?
+        end
+        [col_index, row_index]
+      end
     end
     private_constant :BoxPainter
   end

data/lib/whirled_peas/graphics/mock_screen.rb

@@ -3,7 +3,7 @@ require_relative 'renderer'
 module WhirledPeas
   module Graphics
     class MockScreen
-      def initialize(width, height)
+      def initialize(width:, height:)
         @width = width
         @height = height
       end

data/lib/whirled_peas/graphics/painter.rb

@@ -1,23 +1,32 @@
 module WhirledPeas
   module Graphics
+    # Abstract base Painter class. Given a canvas and start coordinates (left, top), a painter
+    # is responsible for generating the "strokes" that display the element.
     class Painter
       attr_reader :name, :settings
 
-      def initialize(element, settings, name)
-        @element = element
+      def initialize(name, settings)
         @settings = settings
         @name = name
       end
 
-      def paint(canvas, &block)
+      # Paint the element onto the canvas by yielding strokes to the block. A stroke is composed
+      # of a left, top, and chars. E.g.
+      #
+      #   yield 10, 3, 'Hello World!'
+      #
+      # paints the string "Hello World!" in the 10th column from the left, 3rd row down.
+      def paint(canvas, left, top, &block)
       end
 
+      # Return a dimension object that provider the `outer_width` and `outer_height` of the
+      # element being painted.
       def dimensions
       end
 
-      private
-
-      attr_reader :element
+      def inspect
+        "#{self.class.name.split('::').last}(name=#{name.inspect})"
+      end
     end
     private_constant :Painter
   end

data/lib/whirled_peas/graphics/renderer.rb

@@ -1,49 +1,32 @@
-require 'whirled_peas/template/box_element'
-require 'whirled_peas/template/container'
-require 'whirled_peas/template/grid_element'
-require 'whirled_peas/template/text_element'
-
-require_relative 'box_painter'
 require_relative 'canvas'
-require_relative 'grid_painter'
-require_relative 'text_painter'
 
 module WhirledPeas
   module Graphics
     class Renderer
-      PAINTERS = {
-        Template::BoxElement => BoxPainter,
-        Template::GridElement => GridPainter,
-        Template::TextElement => TextPainter
-      }
       def initialize(template, width, height)
         @template = template
         @width = width
         @height = height
       end
 
-      def paint(&block)
-        painter.paint(Canvas.new(0, 0, width, height, 0, 0), &block)
-      end
-
-      def painter
-        build(template)
+      def paint
+        # Modify the template's settings so that it fills the entire screen
+        template.settings.width = width
+        template.settings.height = height
+        template.settings.sizing = :border
+        template.settings.set_margin(left: 0, top: 0, right: 0, bottom: 0)
+        strokes = [Utils::Ansi.cursor_visible(false), Utils::Ansi.cursor_pos, Utils::Ansi.clear_down]
+        template.paint(Canvas.new(0, 0, width, height), 0, 0) do |left, top, fstring|
+          next unless fstring.length > 0
+          strokes << Utils::Ansi.cursor_pos(left: left, top: top)
+          strokes << fstring
+        end
+        strokes.join
       end
 
       private
 
       attr_reader :template, :width, :height
-
-      def build(element)
-        unless PAINTERS.key?(element.class)
-          raise ArgumentError, "Unable to render #{element.class}"
-        end
-        painter = PAINTERS[element.class].new(element, element.settings, element.name)
-        if element.is_a?(Template::Container)
-          element.each_child { |child| painter.add_child(build(child)) }
-        end
-        painter
-      end
     end
   end
 end

data/lib/whirled_peas/graphics/text_painter.rb

@@ -1,35 +1,33 @@
 require 'whirled_peas/utils/formatted_string'
 require 'whirled_peas/utils/title_font'
 
-require_relative 'painter'
-require_relative 'text_dimensions'
+require_relative 'content_dimensions'
+require_relative 'content_painter'
 
 module WhirledPeas
   module Graphics
-    class TextPainter < Painter
-      def paint(canvas, &block)
+    class TextPainter < ContentPainter
+      def paint(canvas, left, top, &block)
         return unless canvas.writable?
         formatting = [*settings.color, *settings.bg_color]
         formatting << Utils::Ansi::BOLD if settings.bold?
         if settings.underline? && settings.title_font.nil?
           formatting << Utils::Ansi::UNDERLINE
         end
-        content.each.with_index do |line, index|
-          canvas.stroke(canvas.start_left, canvas.start_top + index, line, formatting, &block)
+        content_lines.each.with_index do |line, index|
+          canvas.stroke(left, top + index, line, formatting, &block)
         end
       end
 
-      def dimensions
-        TextDimensions.new(content)
-      end
+      private
 
-      def content
-        if settings.title_font
+      def content_lines
+        @content_lines = if settings.title_font
           Utils::TitleFont.to_s(
-            element.content, settings.title_font
+            content, settings.title_font
           ).split("\n")
         else
-          element.content.split("\n")
+          content.split("\n")
         end
       end
     end

data/lib/whirled_peas/settings/alignment.rb

@@ -0,0 +1,24 @@
+module WhirledPeas
+  module Settings
+    module Alignment
+      LEFT = :left
+      CENTER = :center
+      RIGHT = :right
+      BETWEEN = :between
+      AROUND = :around
+      EVENLY = :evenly
+
+      DEFAULT = LEFT
+
+      VALID = [LEFT, CENTER, RIGHT, BETWEEN, AROUND, EVENLY]
+      private_constant :VALID
+
+      def self.validate!(align)
+        return if align.nil?
+        return align if VALID.include?(align)
+        raise ArgumentError, "Unsupported alignment: #{align.inspect}"
+      end
+    end
+    private_constant :Alignment
+  end
+end

data/lib/whirled_peas/settings/bg_color.rb

@@ -17,6 +17,8 @@ module WhirledPeas
       CYAN = new(Utils::Ansi::CYAN + BG_OFFSET)
       WHITE = new(Utils::Ansi::WHITE + BG_OFFSET)
       GRAY = BLACK.bright
+
+      DEFAULT = nil  # Use system defined default
     end
   end
 end

data/lib/whirled_peas/settings/border.rb

@@ -34,20 +34,20 @@ module WhirledPeas
           '╚', '═', '╩', '╝'
         )
 
+        DEFAULT = BOLD
+
         def self.validate!(style)
-          return unless style
+          return if style.nil?
+          return style if style.is_a?(Border::Style)
           if style.is_a?(Symbol)
-            error_message = "Unsupported border style: #{style}"
-            begin
-              style = self.const_get(style.upcase)
-              raise ArgumentError, error_message unless style.is_a?(Style)
-              style
-            rescue NameError
-              raise ArgumentError, error_message
-            end
-          else
-            style
+            style_class = self.const_get(style.upcase)
+            return style_class if style_class.is_a?(Border::Style)
           end
+          error_message = "Unsupported border style: #{style.inspect}"
+          raise ArgumentError, error_message
+        rescue NameError
+          error_message = "Unsupported border style: #{style.inspect}"
+          raise ArgumentError, error_message
         end
       end
 
@@ -82,20 +82,20 @@ module WhirledPeas
       end
 
       def style
-        @style || Styles::BOLD
+        @style || Styles::DEFAULT
       end
 
       def style=(val)
         @style = Styles.validate!(val)
       end
 
-      def color
-        @color || TextColor::WHITE
-      end
-
       def color=(val)
         @color = TextColor.validate!(val)
       end
+
+      def color
+        @color || TextColor::DEFAULT
+      end
     end
   end
 end

data/lib/whirled_peas/settings/color.rb

@@ -13,25 +13,24 @@ module WhirledPeas
       # @return [Color|Symbol] the value passed in if valid, otherwise an ArgumentError
       #   is raised.
       def self.validate!(color)
-        return unless color
+        return if color.nil?
+        return color if color.is_a?(self)
         if color.is_a?(Symbol)
-          error_message = "Unsupported #{self.name.split('::').last}: #{color.inspect}"
           match = color.to_s.match(/^(bright_)?(\w+)$/)
-          begin
-            color = self.const_get(match[2].upcase)
-            raise ArgumentError, error_message unless color.is_a?(Color)
-            if match[1]
-              raise ArgumentError, error_message if color.bright?
-              color.bright
-            else
-              color
+          color_class = self.const_get(match[2].upcase)
+          if color_class.is_a?(self)
+            if !match[1]
+              return color_class
+            elsif !color_class.bright?
+              return color_class.bright
             end
-          rescue NameError
-            raise ArgumentError, error_message
           end
-        else
-          color
         end
+        error_message = "Unsupported #{self.name.split('::').last}: #{color.inspect}"
+        raise ArgumentError, error_message
+      rescue NameError
+        error_message = "Unsupported #{self.name.split('::').last}: #{color.inspect}"
+        raise ArgumentError, error_message
       end
 
       def initialize(code, bright=false)