whirled_peas 0.1.0

data/lib/whirled_peas/ui/canvas.rb

@@ -0,0 +1,35 @@
+require_relative 'stroke'
+
+module WhirledPeas
+  module UI
+    class Canvas
+      attr_reader :left, :top, :width, :height
+
+      def initialize(left, top, width, height)
+        @left = left
+        @top = top
+        @width = width
+        @height = height
+      end
+
+      def stroke(left, top, chars)
+        if left >= self.left + self.width || left + chars.length <= self.left
+          Stroke::EMPTY
+        elsif top < self.top || top >= self.top + self.height
+          Stroke::EMPTY
+        else
+          if left < self.left
+            chars = chars[self.left - left..-1]
+            left = self.left
+          end
+          num_chars = [self.left + self.width, left + chars.length].min - left
+          Stroke.new(left, top, Ansi.first(chars, num_chars))
+        end
+      end
+
+      def inspect
+        "Canvas(left=#{left}, top=#{top}, width=#{width}, height=#{height})"
+      end
+    end
+  end
+end

data/lib/whirled_peas/ui/element.rb

@@ -0,0 +1,199 @@
+require_relative 'settings'
+
+module WhirledPeas
+  module UI
+    class Element
+      attr_accessor :preferred_width, :preferred_height
+      attr_reader :settings
+
+      def initialize(settings)
+        @settings = settings
+      end
+    end
+    private_constant :Element
+
+    class TextElement < Element
+      attr_reader :value
+
+      def initialize(settings)
+        super(TextSettings.merge(settings))
+      end
+
+      def value=(val)
+        @value = val
+        @preferred_width = settings.width || value.length
+        @preferred_height = 1
+      end
+
+      def inspect(indent='')
+        dims = unless preferred_width.nil?
+          "#{indent + '  '}Dimensions: #{preferred_width}x#{preferred_height}"
+        end
+        [
+          "#{indent}#{self.class.name}",
+          dims,
+          "#{indent + '  '}Settings",
+          settings.inspect(indent + '    ')
+        ].compact.join("\n")
+      end
+    end
+
+    class ComposableElement < Element
+      def initialize(settings)
+        super
+      end
+
+      def children
+        @children ||= []
+      end
+
+      def add_text(&block)
+        element = TextElement.new(settings)
+        element.value = yield nil, element.settings
+        children << element
+      end
+
+      def add_box(&block)
+        element = BoxElement.new(settings)
+        value = yield element, element.settings
+        children << element
+        if element.children.empty? && value.is_a?(String)
+          element.add_text { value }
+        end
+      end
+
+      def add_grid(&block)
+        element = GridElement.new(settings)
+        values = yield element, element.settings
+        children << element
+        if element.children.empty? && values.is_a?(Array)
+          values.each { |v| element.add_text { v } }
+        end
+      end
+
+      def inspect(indent='')
+        kids = children.map { |c| c.inspect(indent + '    ') }.join("\n")
+        dims = unless preferred_width.nil?
+          "#{indent + '  '}Dimensions: #{preferred_width}x#{preferred_height}"
+        end
+        [
+          "#{indent}#{self.class.name}",
+          dims,
+          "#{indent + '  '}Settings",
+          settings.inspect(indent + '    '),
+          "#{indent + '  '}Children",
+          kids
+        ].compact.join("\n")
+      end
+    end
+
+    class Template < ComposableElement
+      def initialize(settings=TemplateSettings.new)
+        super(settings)
+      end
+    end
+
+    class BoxElement < ComposableElement
+      attr_writer :content_width, :content_height
+
+      def initialize(settings)
+        super(BoxSettings.merge(settings))
+      end
+
+      def self.from_template(template, width, height)
+        box = new(template.settings)
+        template.children.each { |c| box.children << c }
+        box.content_width = box.preferred_width = width
+        box.content_height = box.preferred_height = height
+        box
+      end
+
+      def content_width
+        @content_width ||= begin
+          child_widths = children.map(&:preferred_width)
+          width = settings.horizontal_flow? ? child_widths.sum : (child_widths.max || 0)
+          [width, *settings.width].max
+        end
+      end
+
+      def preferred_width
+        @preferred_width ||= settings.margin.left +
+          (settings.border.left? ? 1 : 0) +
+          settings.padding.left +
+          content_width +
+          settings.padding.right +
+          (settings.border.right? ? 1 : 0) +
+          settings.margin.right
+      end
+
+      def content_height
+        @content_height ||= begin
+          child_heights = children.map(&:preferred_height)
+          settings.vertical_flow? ? child_heights.sum : (child_heights.max || 0)
+        end
+      end
+
+      def preferred_height
+        @preferred_height ||= settings.margin.top +
+          (settings.border.top? ? 1 : 0) +
+          settings.padding.top +
+          content_height +
+          settings.padding.bottom +
+          (settings.border.bottom? ? 1 : 0) +
+          settings.margin.bottom
+      end
+    end
+
+    class GridElement < ComposableElement
+      def initialize(settings)
+        super(GridSettings.merge(settings))
+      end
+
+      def col_width
+        return @col_width if @col_width
+        @col_width = 0
+        children.each do |child|
+          @col_width = child.preferred_width if child.preferred_width > @col_width
+        end
+        @col_width
+      end
+
+      def row_height
+        return @row_height if @row_height
+        @row_height = 0
+        children.each do |child|
+          @row_height = child.preferred_height if child.preferred_height > @row_height
+        end
+        @row_height
+      end
+
+
+      def preferred_width
+        settings.margin.left +
+          (settings.border.left? ? 1 : 0) +
+          settings.num_cols * (
+            settings.padding.left +
+            col_width +
+            settings.padding.right
+          ) +
+          (settings.num_cols - 1) * (settings.border.inner_vert? ? 1 : 0) +
+          (settings.border.right? ? 1 : 0) +
+          settings.margin.right
+      end
+
+      def preferred_height
+        num_rows = (children.length / settings.num_cols).ceil
+        settings.margin.top +
+          (settings.border.top? ? 1 : 0) +
+          num_rows * (
+            settings.padding.top +
+            row_height +
+            settings.padding.bottom
+          ) +
+          (num_rows - 1) * (settings.border.inner_horiz? ? 1 : 0) +
+          (settings.border.bottom? ? 1 : 0) +
+          settings.margin.bottom
+      end
+    end
+  end
+end

data/lib/whirled_peas/ui/painter.rb

@@ -0,0 +1,283 @@
+require_relative 'ansi'
+require_relative 'canvas'
+require_relative 'settings'
+
+module WhirledPeas
+  module UI
+    DEBUG_SPACING = ARGV.include?('--debug-spacing')
+
+    class TextPainter
+      JUSTIFICATION = DEBUG_SPACING ? 'j' : ' '
+
+      def initialize(text, canvas)
+        @text = text
+        @canvas = canvas
+      end
+
+      def paint(&block)
+        yield canvas.stroke(canvas.left, canvas.top, justified)
+      end
+
+      private
+
+      attr_reader :text, :canvas
+
+      def visible
+        if text.value.length <= text.preferred_width
+          text.value
+        elsif text.settings.align == TextAlign::LEFT
+          text.value[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]
+        else
+          text.value[-text.preferred_width..-1]
+        end
+      end
+
+      def justified
+        format_settings = [*text.settings.color, *text.settings.bg_color]
+        format_settings << TextFormat::BOLD if text.settings.bold?
+        format_settings << TextFormat::UNDERLINE if text.settings.underline?
+
+        ljust = case text.settings.align
+        when TextAlign::LEFT
+          0
+        when TextAlign::CENTER
+          [0, (text.preferred_width - text.value.length) / 2].max
+        when TextAlign::RIGHT
+          [0, text.preferred_width - text.value.length].max
+        end
+        rjust = [0, text.preferred_width - text.value.length - ljust].max
+        Ansi.format(JUSTIFICATION * ljust, [*text.settings.bg_color]) +
+          Ansi.format(visible, format_settings) +
+          Ansi.format(JUSTIFICATION * rjust, [*text.settings.bg_color])
+      end
+    end
+    private_constant :TextPainter
+
+    class ContainerPainter
+      PADDING = DEBUG_SPACING ? 'p' : ' '
+
+      def initialize(container, canvas)
+        @container = container
+        @settings = container.settings
+        @canvas = canvas
+      end
+
+      def paint(&block)
+        return if container.num_rows == 0 || container.num_cols == 0
+        top = canvas.top + settings.margin.top
+        if settings.auto_margin?
+          left = canvas.left + (canvas.width - container.preferred_width) / 2
+        else
+          left = canvas.left + settings.margin.left
+        end
+        if settings.border.top?
+          yield canvas.stroke(left, top, top_border)
+          top += 1
+        end
+        container.num_rows.times do |row_num|
+          if row_num > 0 && settings.border.inner_horiz?
+            yield canvas.stroke(left, top, middle_border)
+            top += 1
+          end
+          (settings.padding.top + container.row_height + settings.padding.bottom).times do
+            yield canvas.stroke(left, top, content_line)
+            top += 1
+          end
+        end
+        if settings.border.bottom?
+          yield canvas.stroke(left, top, bottom_border)
+          top += 1
+        end
+      end
+
+      private
+
+      attr_reader :container, :settings, :canvas
+
+      def line_stroke(left_border, horiz_border, junc_border, right_border)
+        stroke = ''
+        stroke += left_border if settings.border.left?
+        container.num_cols.times do |col_num|
+          stroke += junc_border if col_num > 0 && settings.border.inner_horiz?
+          stroke += horiz_border * (container.col_width + settings.padding.left + settings.padding.right)
+        end
+        stroke += right_border if settings.border.right?
+        Ansi.format(stroke, [*settings.border.color, *settings.bg_color])
+      end
+
+      def top_border
+        line_stroke(
+          settings.border.style.top_left,
+          settings.border.style.top_horiz,
+          settings.border.style.top_junc,
+          settings.border.style.top_right
+        )
+      end
+
+      def content_line
+        line_stroke(
+          settings.border.style.left_vert,
+          PADDING,
+          settings.border.style.middle_vert,
+          settings.border.style.right_vert
+        )
+      end
+
+      def middle_border
+        line_stroke(
+          settings.border.style.left_junc,
+          settings.border.style.middle_horiz,
+          settings.border.style.cross_junc,
+          settings.border.style.right_junc
+        )
+      end
+
+      def bottom_border
+        line_stroke(
+          settings.border.style.bottom_left,
+          settings.border.style.bottom_horiz,
+          settings.border.style.bottom_junc,
+          settings.border.style.bottom_right
+        )
+      end
+    end
+
+    class BoxContainer
+      attr_reader :settings, :num_cols, :num_rows, :col_width, :row_height, :preferred_width
+
+      def initialize(box)
+        @settings = ContainerSettings.merge(box.settings)
+        @num_cols = 1
+        @num_rows = 1
+        @col_width = box.content_width
+        @row_height = box.content_height
+        @preferred_width = box.preferred_width
+      end
+    end
+
+    class BoxPainter
+      def initialize(box, canvas)
+        @box = box
+        @canvas = canvas
+      end
+
+      def paint(&block)
+        container = BoxContainer.new(box)
+        ContainerPainter.new(container, canvas).paint(&block)
+        top = canvas.top + box.settings.margin.top + (box.settings.border.top? ? 1 : 0) + box.settings.padding.top
+        if box.settings.auto_margin?
+          margin = (canvas.width - box.preferred_width) / 2
+        else
+          margin = box.settings.margin.left
+        end
+        left = canvas.left + margin + (box.settings.border.left? ? 1 : 0) + box.settings.padding.left
+        greedy_width = box.settings.vertical_flow? || box.children.length == 1
+        children = box.children
+        children = children.reverse if box.settings.reverse_flow?
+        children.each do |child|
+          if greedy_width
+            width = box.content_width
+            height = child.preferred_height
+          else
+            width = child.preferred_width
+            height = box.content_height
+          end
+          child_canvas = Canvas.new(left, top, width, height)
+          Painter.paint(child, child_canvas, &block)
+          if box.settings.horizontal_flow?
+            left += child.preferred_width
+          else
+            top += child.preferred_height
+          end
+        end
+      end
+
+      private
+
+      attr_reader :box, :canvas
+    end
+
+    class GridContainer
+      attr_reader :settings, :num_cols, :num_rows, :col_width, :row_height, :preferred_width
+
+      def initialize(grid, num_cols, num_rows)
+        @settings = ContainerSettings.merge(grid.settings)
+        @num_cols = num_cols
+        @num_rows = num_rows
+        @col_width = grid.col_width
+        @row_height = grid.row_height
+        @preferred_width = grid.preferred_width
+      end
+    end
+
+    class GridPainter
+      def initialize(grid, canvas)
+        @grid = grid
+        @canvas = canvas
+        available_width = grid.preferred_width - (grid.settings.margin.left || 0) - (grid.settings.margin.right || 0)
+        @num_cols = grid.settings.num_cols || (available_width - (grid.settings.border.left? ? 1 : 0) - (grid.settings.border.right? ? 1 : 0) + (grid.border.inner_vert ? 1 : 0)) / (col_width + grid.settings.padding.left + grid.settings.right + (grid.border.inner_vert ? 1 : 0))
+      end
+
+      def paint(&block)
+        return if grid.children.empty?
+
+        container = GridContainer.new(grid, num_cols, (grid.children.length.to_f / num_cols).ceil)
+        ContainerPainter.new(container, canvas).paint(&block)
+
+        children = if grid.settings.transpose?
+          grid.children.length.times.map do |i|
+            grid.children[(i * num_cols) % grid.children.length +  i / (grid.children.length / num_cols)]
+          end.compact
+        else
+          grid.children
+        end
+
+        top = canvas.top + grid.settings.margin.top + (grid.settings.border.top? ? 1 : 0) + grid.settings.padding.top
+        if grid.settings.auto_margin?
+          margin = (canvas.width - grid.preferred_width) / 2
+        else
+          margin = grid.settings.margin.left
+        end
+        left = canvas.left + margin + (grid.settings.border.left? ? 1 : 0) + grid.settings.padding.left
+        grid_height = grid.settings.padding.top + grid.row_height + grid.settings.padding.bottom + (grid.settings.border.inner_horiz? ? 1 : 0)
+        grid_width = grid.settings.padding.left + grid.col_width + grid.settings.padding.right + (grid.settings.border.inner_vert? ? 1 : 0)
+        children.each_slice(num_cols).each.with_index do |row, row_num|
+          row_top = top + row_num * grid_height
+          row.each.with_index do |element, col_num|
+            col_left = left + col_num * grid_width
+            child_canvas = Canvas.new(
+              col_left,
+              row_top,
+              element.preferred_width,
+              element.preferred_height
+            )
+            Painter.paint(element, child_canvas, &block)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :grid, :canvas, :num_cols
+    end
+
+    module Painter
+      PAINTERS = {
+        TextElement => TextPainter,
+        BoxElement => BoxPainter,
+        GridElement => GridPainter,
+      }
+
+      def self.paint(element, canvas, &block)
+        if element.is_a?(Template)
+          element = BoxElement.from_template(element, canvas.width, canvas.height)
+        end
+        PAINTERS[element.class].new(element, canvas).paint(&block)
+      end
+    end
+  end
+end