whirled_peas 0.1.1 → 0.5.0

data/lib/whirled_peas/ui.rb

@@ -1,7 +0,0 @@
-require_relative 'ui/element'
-require_relative 'ui/screen'
-
-module WhirledPeas
-  module UI
-  end
-end

data/lib/whirled_peas/ui/ansi.rb

@@ -1,154 +0,0 @@
-module WhirledPeas
-  module UI
-    DEBUG_COLOR = ARGV.include?('--debug-color')
-
-    module Ansi
-      BOLD = 1
-      UNDERLINE = 4
-
-      BLACK = 30
-      RED = 31
-      GREEN = 32
-      YELLOW = 33
-      BLUE = 34
-      MAGENTA = 35
-      CYAN = 36
-      WHITE = 37
-
-      END_FORMATTING = 0
-
-      class << self
-        def format(str, codes)
-          if str.empty? || codes.length == 0
-            str
-          else
-            start_formatting = codes.map(&method(:esc_seq)).join
-            "#{start_formatting}#{str}#{esc_seq(END_FORMATTING)}"
-          end
-        end
-
-        def clear
-          esc_seq(END_FORMATTING)
-        end
-
-        def hidden_width(line)
-          return 0 if DEBUG_COLOR
-          width = 0
-          line.scan(/\033\[\d+m/).each { |f| width += f.length }
-          width
-        end
-
-        def close_formatting(line)
-          codes = line.scan(DEBUG_COLOR ? /<(\d+)>/ : /\033\[(\d+)m/)
-          if codes.length > 0 && codes.last[0] != END_FORMATTING.to_s
-            "#{line}#{esc_seq(END_FORMATTING)}"
-          else
-            line
-          end
-        end
-
-        def first(str, num_visible_chars)
-          return str if str.length <= num_visible_chars + hidden_width(str)
-          result = ''
-          in_format = false
-          visible_len = 0
-          str.chars.each do |char|
-            in_format = true if !in_format && char == "\033"
-            result += char
-            visible_len += 1 if !in_format
-            in_format = false if in_format && char == 'm'
-            break if visible_len == num_visible_chars
-          end
-          close_formatting(result)
-        end
-
-        private
-
-        def esc_seq(code)
-          DEBUG_COLOR ? "<#{code}>" : "\033[#{code}m"
-        end
-      end
-    end
-
-    class Color
-      BRIGHT_OFFSET = 60
-      private_constant :BRIGHT_OFFSET
-
-      def self.validate!(color)
-        return unless color
-        if color.is_a?(Symbol)
-          error_message = "Unsupported #{self.name.split('::').last}: #{color}"
-          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
-            end
-          rescue NameError
-            raise ArgumentError, error_message
-          end
-        else
-          color
-        end
-      end
-
-      def initialize(code, bright=false)
-        @code = code
-        @bright = bright
-      end
-
-      def bright?
-        @bright
-      end
-
-      def bright
-        bright? ? self : self.class.new(@code + BRIGHT_OFFSET, true)
-      end
-
-      def to_s
-        @code.to_s
-      end
-
-      def inspect
-        "#{self.class.name.split('::').last}(code=#{@code}, bright=#{@bright})"
-      end
-    end
-    private_constant :Color
-
-    class BgColor < Color
-      BG_OFFSET = 10
-      private_constant :BG_OFFSET
-
-      BLACK = new(Ansi::BLACK + BG_OFFSET)
-      RED = new(Ansi::RED + BG_OFFSET)
-      GREEN = new(Ansi::GREEN + BG_OFFSET)
-      YELLOW = new(Ansi::YELLOW + BG_OFFSET)
-      BLUE = new(Ansi::BLUE + BG_OFFSET)
-      MAGENTA = new(Ansi::MAGENTA + BG_OFFSET)
-      CYAN = new(Ansi::CYAN + BG_OFFSET)
-      WHITE = new(Ansi::WHITE + BG_OFFSET)
-      GRAY = BLACK.bright
-    end
-
-    class TextColor < Color
-      BLACK = new(Ansi::BLACK)
-      RED = new(Ansi::RED)
-      GREEN = new(Ansi::GREEN)
-      YELLOW = new(Ansi::YELLOW)
-      BLUE = new(Ansi::BLUE)
-      MAGENTA = new(Ansi::MAGENTA)
-      CYAN = new(Ansi::CYAN)
-      WHITE = new(Ansi::WHITE)
-      GRAY = BLACK.bright
-    end
-
-    module TextFormat
-      BOLD = Ansi::BOLD
-      UNDERLINE = Ansi::UNDERLINE
-    end
-  end
-end

data/lib/whirled_peas/ui/canvas.rb

@@ -1,35 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,283 +0,0 @@
-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