whirled_peas 0.11.0 → 0.11.1

data/doc/template_factory.md

@@ -0,0 +1,53 @@
+## Template Factory
+
+To render the frame events sent by the application, the application requires a template factory. This factory will be called for each frame event, with the frame name and the arguments supplied by the application. A template factory can be an instance of ruby class and thus can maintain state. Whirled Peas provides a few basic building blocks to make simple, yet elegant terminal-based UIs.
+
+To build a template in a template factory, use `WhirledPeas.template(theme)`, which takes an optional [theme](themes.md) and yields a composer (used to add [elements](elements.md) to the template) and [settings](settings.md) (used to configure the element).
+
+### Full example
+
+```ruby
+class TemplateFactory
+  def build(frame, args)
+    set_state(frame, args)
+    WhirledPeas.template do |composer, settings|
+      settings.flow = :l2r
+      settings.align = :center
+
+      composer.add_box('Title', &method(:title))
+      composer.add_box('Sum', &method(:sum))
+      composer.add_grid('NumberGrid', &method(:number_grid))
+    end
+  end
+
+  private
+
+  def set_state(frame, args)
+    @frame = frame
+    @numbers = args.key?(:numbers) ? args[:numbers] || []
+    @sum = args[:sum] if args.key?(:sum)
+    @low = args[:low] if args.key?(:low)
+    @high = args[:high] if args.key?(:high)
+  end
+
+  def title(_composer, settings)
+    settings.underline = true
+    "Pair Finder"
+  end
+
+  def sum(_composer, settings)
+    settings.color = @frame == 'found-pair' ? :green : :red
+    @sum ? "Sum: #{@sum}" : 'N/A'
+  end
+
+  def number_grid(composer, settings)
+    settings.full_border
+    @numbers.each.with_index do |num, index|
+      composer.add_text do |_, settings|
+        settings.bg_color = (@low == index || @high == index) ? :cyan : :white
+        num
+      end
+    end
+  end
+end
+```

data/doc/themes.md

@@ -0,0 +1,15 @@
+## Themes
+
+The template builder (`WhirledPeas.template`) takes an optional `theme` argument. You can provide the name of a predefined theme (run `whirled_peas themes` to see a list with samples) or define you own with the following
+
+```ruby
+WhirledPeas.register_theme(:my_theme) do |theme|
+  theme.bg_color = :bright_white
+  theme.color = :blue
+  theme.border_color = :bright_green
+  theme.axis_color = :bright_red
+  theme.title_font = :default
+end
+```
+
+Theme settings will be used as default settings throughout the template, however theme settings can be overridden on any element.

data/lib/data/themes.yaml

@@ -1,13 +1,17 @@
 bright:
+  axis_color: :red
   bg_color: :bright_white
-  color: :blue
   border_color: :bright_blue
-  axis_color: :red
+  border_style: :soft
+  color: :blue
   title_font: :default
 
 dark:
+  axis_color: :bright_white
   bg_color: :black
-  color: :white
   border_color: :gray
-  axis_color: :bright_white
+  border_style: :double
+  color: :white
+  highlight_bg_color: :bright_red
+  highlight_color: :black
   title_font: :swan

data/lib/whirled_peas/component/list_with_active.rb

@@ -1,7 +1,7 @@
 module WhirledPeas
   module Component
     class ListWithActive
-      attr_accessor :active_index, :active_color, :active_bg_color, :separator
+      attr_accessor :active_index, :separator
 
       attr_reader :items
 
@@ -75,8 +75,8 @@ module WhirledPeas
             composer.add_text { separator } if !separator.nil? && index > 0
             composer.add_text do |_, settings|
               if index == active_index
-                settings.bg_color = active_bg_color
-                settings.color = active_color
+                settings.bg_color = :highlight
+                settings.color = :highlight
               end
               item
             end

data/lib/whirled_peas/graphics/container_coords.rb

@@ -33,7 +33,7 @@ module WhirledPeas
       end
 
       def content_left(col_index=0)
-        padding_left + settings.padding.left + col_index * grid_width
+        padding_left + settings.padding.left + col_index * dimensions.grid_width
       end
 
       def offset_content_left(col_index=0)
@@ -48,7 +48,7 @@ module WhirledPeas
       end
 
       def content_top(row_index=0)
-        padding_top + settings.padding.top + row_index * grid_height
+        padding_top + settings.padding.top + row_index * dimensions.grid_height
       end
 
       def offset_content_top(row_index=0)
@@ -62,30 +62,6 @@ module WhirledPeas
         end
       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

data/lib/whirled_peas/graphics/container_dimensions.rb

@@ -31,6 +31,30 @@ module WhirledPeas
         end
       end
 
+      def inner_grid_width
+        settings.padding.left +
+          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 +
+          content_height +
+          settings.padding.bottom
+      end
+
+      def grid_height
+        (settings.border.inner_horiz? ? 1 : 0) +
+          inner_grid_height +
+          (settings.scrollbar.horiz? ? 1 : 0)
+      end
+
       def outer_width
         @outer_width ||= margin_width +
           outer_border_width +

data/lib/whirled_peas/graphics/container_painter.rb

@@ -35,11 +35,17 @@ module WhirledPeas
 
         # Paint the top border if the settings call for it
         if settings.border.top?
-          canvas.stroke(stroke_left, stroke_top, top_border_stroke(canvas_coords), formatting, &block)
+          canvas.stroke(stroke_left, stroke_top, top_border_stroke, formatting, &block)
           stroke_top += 1
         end
         # Precalculate the middle border container grids with more than 1 row
-        middle_border = dimensions.num_rows > 1 ? middle_border_stroke(canvas_coords) : ''
+        middle_border = dimensions.num_rows > 1 ? middle_border_stroke : ''
+
+        vert_scrollbar = settings.scrollbar.vert? ? ScrollbarHelper.vert(
+          dimensions.children_height + dimensions.padding_height,
+          dimensions.inner_grid_height,
+          canvas_coords.content_top - canvas_coords.offset_content_top,
+        ) : []
 
         # Paint each grid row by row
         dimensions.num_rows.times do |row_num|
@@ -53,8 +59,9 @@ module WhirledPeas
 
           # Paint the interior of each row (horizontal borders, veritical scroll bar and
           # background color for the padding and content area)
-          canvas_coords.inner_grid_height.times do |row_within_cell|
-            canvas.stroke(stroke_left, stroke_top, content_line_stroke(canvas_coords, row_within_cell), formatting, &block)
+          dimensions.inner_grid_height.times do |row_within_cell|
+            content_line = content_line_stroke(row_within_cell, vert_scrollbar)
+            canvas.stroke(stroke_left, stroke_top, content_line, formatting, &block)
             stroke_top += 1
           end
 
@@ -67,7 +74,7 @@ module WhirledPeas
 
         # Paint the bottom border if the settings call for it
         if settings.border.bottom?
-          canvas.stroke(stroke_left, stroke_top, bottom_border_stroke(canvas_coords), formatting, &block)
+          canvas.stroke(stroke_left, stroke_top, bottom_border_stroke, formatting, &block)
           stroke_top += 1
         end
       end
@@ -177,55 +184,49 @@ module WhirledPeas
       end
 
       # Return the stroke for the top border
-      def top_border_stroke(canvas_coords)
+      def top_border_stroke
         line_stroke(
           settings.border.style.top_left,
           settings.border.style.top_junc,
           settings.border.style.top_right
         ) do
-          settings.border.style.top_horiz * (canvas_coords.inner_grid_width + (settings.scrollbar.vert? ? 1 : 0))
+          settings.border.style.top_horiz * (dimensions.inner_grid_width + (settings.scrollbar.vert? ? 1 : 0))
         end
       end
 
       # Return the stroke for an inner horizontal border
-      def middle_border_stroke(canvas_coords)
+      def middle_border_stroke
         line_stroke(
           settings.border.style.left_junc,
           settings.border.style.cross_junc,
           settings.border.style.right_junc
         ) do
-          settings.border.style.middle_horiz * (canvas_coords.inner_grid_width + (settings.scrollbar.vert? ? 1 : 0))
+          settings.border.style.middle_horiz * (dimensions.inner_grid_width + (settings.scrollbar.vert? ? 1 : 0))
         end
       end
 
       # Return the stroke for the bottom border
-      def bottom_border_stroke(canvas_coords)
+      def bottom_border_stroke
         line_stroke(
           settings.border.style.bottom_left,
           settings.border.style.bottom_junc,
           settings.border.style.bottom_right
         ) do
-          settings.border.style.bottom_horiz * (canvas_coords.inner_grid_width + (settings.scrollbar.vert? ? 1 : 0))
+          settings.border.style.bottom_horiz * (dimensions.inner_grid_width + (settings.scrollbar.vert? ? 1 : 0))
         end
       end
 
       # Return the stroke for a grid row between any borders
-      def content_line_stroke(canvas_coords, row_within_cell)
+      def content_line_stroke(row_within_cell, vert_scrollbar)
         line_stroke(
           settings.border.style.left_vert,
           settings.border.style.middle_vert,
           settings.border.style.right_vert,
         ) do
           if settings.scrollbar.vert?
-            scrollbar_char = ScrollbarHelper.vert_char(
-              dimensions.children_height + dimensions.padding_height,
-              canvas_coords.inner_grid_height,
-              canvas_coords.top - canvas_coords.offset_content_top,
-              row_within_cell
-            )
-            PADDING * canvas_coords.inner_grid_width + scrollbar_char
+            PADDING * dimensions.inner_grid_width + vert_scrollbar[row_within_cell]
           else
-            PADDING * canvas_coords.inner_grid_width
+            PADDING * dimensions.inner_grid_width
           end
         end
       end
@@ -237,14 +238,11 @@ module WhirledPeas
           settings.border.style.middle_vert,
           settings.border.style.right_vert,
         ) do
-          canvas_coords.inner_grid_width.times.map do |col_within_cell|
-            ScrollbarHelper.horiz_char(
-              dimensions.children_width + dimensions.padding_width,
-              canvas_coords.inner_grid_width,
-              canvas_coords.left - canvas_coords.offset_content_left,
-              col_within_cell
-            )
-          end.join
+          ScrollbarHelper.horiz(
+            dimensions.children_width + dimensions.padding_width,
+            dimensions.inner_grid_width,
+            canvas_coords.content_left - canvas_coords.offset_content_left
+          ).join
         end
       end
     end

data/lib/whirled_peas/graphics/debugger.rb

@@ -15,6 +15,7 @@ module WhirledPeas
           "#{indent}* #{painter.class}(#{painter.name})",
         ]
         info << "#{indent + '  '}- Dimensions(#{dimensions})"
+        info << "#{indent + '  '}- Theme=#{painter.settings.theme.inspect}" if indent == ''
         info << "#{indent + '  '}- Settings"
         info << Settings::Debugger.new(painter.settings).debug(indent + '    ')
         if painter.is_a?(TextPainter)

data/lib/whirled_peas/graphics/graph_painter.rb

@@ -5,6 +5,10 @@ require_relative 'content_painter'
 module WhirledPeas
   module Graphics
     class GraphPainter < ContentPainter
+      # The number of units along the Y-axis a single character can be divided into
+      Y_AXIS_SCALE = 2
+      private_constant :Y_AXIS_SCALE
+
       def paint(canvas, left, top, &block)
         axis_formatting = [*settings.axis_color, *settings.bg_color]
         plot_formatting = [*settings.color, *settings.bg_color]
@@ -26,8 +30,8 @@ module WhirledPeas
         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
+          interpolated = (inner_width + 1).times.map do |i|
+            x = (i * (content.length - 1).to_f / (inner_width + 1)).floor
             max_y = content[x] if content[x] > max_y
             min_y = content[x] if content[x] < min_y
             content[x]
@@ -39,31 +43,34 @@ module WhirledPeas
             min_y = y if y < min_y
           end
         end
+        if min_y == max_y
+          min_y -= 1
+          max_y += 1
+        end
         scaled = interpolated.map do |y|
-          (2 * inner_height * (y - min_y).to_f / (max_y - min_y)).floor
+          inner_height * (y - min_y).to_f / (max_y - min_y)
         end
+
         @plot_lines = Array.new(inner_height) { '' }
-        scaled.each.with_index do |y, x_index|
+        scaled[0..-2].each.with_index do |y, x_index|
+          last = x_index == scaled.length - 2
+
+          prev_y = x_index == 0 ? y : scaled[x_index - 1]
+          next_y = scaled[x_index + 1]
+
+          min_y = [(prev_y + y) / 2, y, last ? next_y : (y + next_y) / 2].min
+          min_y = (Y_AXIS_SCALE * min_y).round.to_f / Y_AXIS_SCALE
+
+          max_y = [(prev_y + y) / 2, y, last ? next_y : (y + next_y) / 2].max
+          max_y = (Y_AXIS_SCALE * max_y).round.to_f / Y_AXIS_SCALE
+
           @plot_lines.each.with_index do |row, row_index|
-            bottom_half_index = 2 * (inner_height - row_index - 1)
-            top_half_index = bottom_half_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 == top_half_index || (y...next_y).include?(top_half_index)
-              bottom_half = y == bottom_half_index || (y...next_y).include?(bottom_half_index)
-            else
-              top_half = y == top_half_index || (next_y...y).include?(top_half_index)
-              bottom_half = y == bottom_half_index || (next_y...y).include?(bottom_half_index)
-            end
+            bottom_value = inner_height - row_index - 1
+            top_value = bottom_value + 1.0 / Y_AXIS_SCALE
+
+            top_half =  min_y == top_value || (min_y <= top_value && top_value < max_y)
+            bottom_half = min_y == bottom_value || (min_y <= bottom_value && bottom_value < max_y)
+
             row << if top_half && bottom_half
               '█'
             elsif top_half
@@ -83,7 +90,7 @@ module WhirledPeas
       end
 
       def inner_width
-        settings.width.nil? ? content.length : settings.width - 1
+        (settings.width.nil? ? content.length : settings.width) - 1
       end
 
       def axes_lines

data/lib/whirled_peas/graphics/scrollbar_helper.rb

@@ -15,18 +15,18 @@ module WhirledPeas
       private_constant :SCROLL_HANDLE_SCALE
 
       class << self
-        # Determine the character to paint the horizontal scroll bar with for the given column
+        # Return the characters to paint the horizontal scroll bar with for the given column
         #
-        # @see #scroll_char for more details
-        def horiz_char(col_count, viewable_col_count, first_visible_col, curr_col)
-          scroll_char(col_count, viewable_col_count, first_visible_col, curr_col, HORIZONTAL)
+        # @see #scroll_chars for more details
+        def horiz(col_count, viewable_col_count, first_visible_col)
+          scroll_chars(col_count, viewable_col_count, first_visible_col, HORIZONTAL)
         end
 
-        # Determine the character to paint the vertical scroll bar with for the given row
+        # Return the characters to paint the vertical scroll bar with for the given row
         #
-        # @see #scroll_char for more details
-        def vert_char(row_count, viewable_row_count, first_visible_row, curr_row)
-          scroll_char(row_count, viewable_row_count, first_visible_row, curr_row, VERTICAL)
+        # @see #scroll_chars for more details
+        def vert(row_count, viewable_row_count, first_visible_row)
+          scroll_chars(row_count, viewable_row_count, first_visible_row, VERTICAL)
         end
 
         private
@@ -37,15 +37,16 @@ module WhirledPeas
         # @param viewable_count [Integer] number of rows/columns visible in the viewport
         # @param first_visible [Integer] zero-based index of the first row/column that is visible
         #   in the viewport
-        # @param curr [Integer] zero-based index of the row/column (relative to the first visible
-        #   row/column) that the painted character is being requested for
-        # @param chars [Array<String>] an array with three 1-character strings, the frist is the
-        #   "second half" scrollbar character, the second is the "full" scrollbar character, and
-        #   the third is the "first half" scrollbar character.
-        def scroll_char(total_count, viewable_count, first_visible, curr, chars)
-          return chars[0] if total_count == 0
-          return chars[0] if viewable_count == 0
-          return chars[0] if viewable_count >= total_count
+        # @param chars [Array<String>] an array with four 1-character strings, the frist is the
+        #   gutter (i.e. no scrolbar handle visible), then the "second half" scrollbar character,
+        #   then second is the "first half" scrollbar character, and finally the "full"
+        def scroll_chars(total_count, viewable_count, first_visible, chars)
+          # Start by initializing the scroll back to to all gutters
+          scrollbar = Array.new(viewable_count) { chars[0] }
+
+          return scrollbar if total_count == 0
+          return scrollbar if viewable_count == 0
+          return scrollbar if viewable_count >= total_count
 
           # The scroll handle has the exact same relative size and position in the scroll gutter
           # that the viewable content has in the total content area. For example, a content area
@@ -92,31 +93,32 @@ module WhirledPeas
           # Always use the same length for the scrollbar so it does not give an inchworm effect
           # as it scrolls along. This will calculate the "ideal" length of the scroll bar if we
           # could infinitely divide a character.
-          scrollbar_length = (viewable_count ** 2).to_f / total_count
+          length = (viewable_count ** 2).to_f / total_count
 
           # Round the length to the nearst "scaled" value
-          scrollbar_length = (SCROLL_HANDLE_SCALE * scrollbar_length).round.to_f / SCROLL_HANDLE_SCALE
+          length = (SCROLL_HANDLE_SCALE * length).round.to_f / SCROLL_HANDLE_SCALE
 
           # Ensure we have a scrollbar!
-          scrollbar_length = 1.0 / SCROLL_HANDLE_SCALE if scrollbar_length == 0
+          length = 1.0 / SCROLL_HANDLE_SCALE if length == 0
 
           # Find the "ideal" position of where the scrollbar should start.
-          scrollbar_start = first_visible * viewable_count.to_f / total_count
+          start = first_visible * viewable_count.to_f / total_count
 
           # Round the start to the nearest "scaled" value
-          scrollbar_start = (SCROLL_HANDLE_SCALE * scrollbar_start).round.to_f / SCROLL_HANDLE_SCALE
+          start = (SCROLL_HANDLE_SCALE * start).round.to_f / SCROLL_HANDLE_SCALE
 
           # Make sure we didn't scroll off the page!
-          scrollbar_start -= scrollbar_length if scrollbar_start == viewable_count
+          start -= length if start == viewable_count
 
-          # Create "scaled" indexes for the subdivided current character
-          curr_0 = curr
-          curr_1 = curr + 1.0 / SCROLL_HANDLE_SCALE
+          (start.floor..[(start + length).floor, viewable_count - 1].min).each do |curr_0|
+            curr_1 = curr_0 + 1.0 / SCROLL_HANDLE_SCALE
 
-          first_half = scrollbar_start <= curr_0 && curr_0 < scrollbar_start + scrollbar_length ? 2 : 0
-          second_half = scrollbar_start <= curr_1 && curr_1 < scrollbar_start + scrollbar_length ? 1 : 0
+            first_half = start <= curr_0 && curr_0 < start + length ? 2 : 0
+            second_half = start <= curr_1 && curr_1 < start + length ? 1 : 0
 
-          chars[second_half | first_half]
+            scrollbar[curr_0] = chars[second_half | first_half]
+          end
+          scrollbar
         end
       end
     end