whirled_peas 0.4.1 → 0.8.0

data/lib/whirled_peas/settings/position.rb

@@ -0,0 +1,15 @@
+module WhirledPeas
+  module Settings
+    class Position
+      attr_writer :left, :top
+
+      def left
+        @left || 0
+      end
+
+      def top
+        @top || 0
+      end
+    end
+  end
+end

data/lib/whirled_peas/settings/scrollbar.rb

@@ -0,0 +1,15 @@
+module WhirledPeas
+  module Settings
+    class Scrollbar
+      attr_writer :horiz, :vert
+
+      def horiz?
+        @horiz == true
+      end
+
+      def vert?
+        @vert == true
+      end
+    end
+  end
+end

data/lib/whirled_peas/settings/sizing.rb

@@ -0,0 +1,19 @@
+module WhirledPeas
+  module Settings
+    class Sizing
+      CONTENT = :content
+      BORDER = :border
+
+      DEFAULT = CONTENT
+
+      VALID = [CONTENT, BORDER]
+      private_constant :VALID
+
+      def self.validate!(sizing)
+        return if sizing.nil?
+        return sizing if VALID.include?(sizing)
+        raise ArgumentError, "Unsupported sizing model: #{sizing.inspect}"
+      end
+    end
+  end
+end

data/lib/whirled_peas/settings/spacing.rb

@@ -0,0 +1,58 @@
+module WhirledPeas
+  module Settings
+    class Spacing
+      attr_writer :left, :top, :right, :bottom
+
+      def left=(value)
+        @left = validate!(value)
+      end
+
+      def left
+        @left || 0
+      end
+
+      def top=(value)
+        @top = validate!(value)
+      end
+
+      def top
+        @top || 0
+      end
+
+      def right=(value)
+        @right = validate!(value)
+      end
+
+      def right
+        @right || 0
+      end
+
+      def bottom=(value)
+        @bottom = validate!(value)
+      end
+
+      def bottom
+        @bottom || 0
+      end
+
+      def horiz=(value)
+        self.left = self.right = value
+      end
+
+      def vert=(value)
+        self.top = self.bottom = value
+      end
+
+      private
+
+      def validate!(value)
+        if value && value < 0
+          raise ArgumentError, "Negative values for #{self.class.name.split('::').last.downcase} are not allowed"
+        else
+          value
+        end
+      end
+    end
+    private_constant :Spacing
+  end
+end

data/lib/whirled_peas/settings/text_color.rb

@@ -0,0 +1,21 @@
+require 'whirled_peas/utils/ansi'
+
+require_relative 'color'
+
+module WhirledPeas
+  module Settings
+    class TextColor < Color
+      BLACK = new(Utils::Ansi::BLACK)
+      RED = new(Utils::Ansi::RED)
+      GREEN = new(Utils::Ansi::GREEN)
+      YELLOW = new(Utils::Ansi::YELLOW)
+      BLUE = new(Utils::Ansi::BLUE)
+      MAGENTA = new(Utils::Ansi::MAGENTA)
+      CYAN = new(Utils::Ansi::CYAN)
+      WHITE = new(Utils::Ansi::WHITE)
+      GRAY = BLACK.bright
+
+      DEFAULT = nil  # Use system defined default
+    end
+  end
+end

data/lib/whirled_peas/settings/text_settings.rb

@@ -0,0 +1,15 @@
+require 'whirled_peas/utils/title_font'
+
+require_relative 'element_settings'
+
+module WhirledPeas
+  module Settings
+    class TextSettings < ElementSettings
+      attr_reader :title_font
+
+      def title_font=(font)
+        @title_font = Utils::TitleFont.validate!(font)
+      end
+    end
+  end
+end

data/lib/whirled_peas/settings/vert_alignment.rb

@@ -0,0 +1,24 @@
+module WhirledPeas
+  module Settings
+    module VertAlignment
+      TOP = :top
+      MIDDLE = :middle
+      BOTTOM = :bottom
+      BETWEEN = :between
+      AROUND = :around
+      EVENLY = :evenly
+
+      DEFAULT = TOP
+
+      VALID = [TOP, MIDDLE, BOTTOM, BETWEEN, AROUND, EVENLY]
+      private_constant :VALID
+
+      def self.validate!(valign)
+        return if valign.nil?
+        return valign if VALID.include?(valign)
+        raise ArgumentError, "Unsupported vertical alignment: #{valign.inspect}"
+      end
+    end
+    private_constant :VertAlignment
+  end
+end

data/lib/whirled_peas/utils/ansi.rb

@@ -1,5 +1,5 @@
 module WhirledPeas
-  module UI
+  module Utils
     # Helper module for working with ANSI escape codes. The most useful ANSI escape codes
     # relate to text formatting.
     #
@@ -7,6 +7,9 @@ module WhirledPeas
     module Ansi
       ESC = "\033"
 
+      END_FORMATTING = 0
+      private_constant :END_FORMATTING
+
       # Text formatting constants
       BOLD = 1
       UNDERLINE = 4
@@ -21,10 +24,23 @@ module WhirledPeas
       CYAN = 36
       WHITE = 37
 
-      END_FORMATTING = 0
-      private_constant :END_FORMATTING
+      # Bright colors are offset by this much from their standard versions
+      BRIGHT_OFFSET = 60
 
       class << self
+        def with_screen(output, width: nil, height: nil, &block)
+          require 'highline'
+          unless width && height
+            width, height = HighLine.new.terminal.terminal_size
+          end
+          yield width, height
+        ensure
+          output.print clear
+          output.print cursor_pos(top: height - 1)
+          output.print cursor_visible(true)
+          output.flush
+        end
+
         def cursor_pos(top: 0, left: 0)
           "#{ESC}[#{top + 1};#{left + 1}H"
         end
@@ -37,63 +53,10 @@ module WhirledPeas
           "#{ESC}[J"
         end
 
-        # Format the string with the ANSI escapes codes for the given integer codes
-        #
-        # @param str [String] the string to format
-        # @param codes [Array<Integer>] the integer part of the ANSI escape code (see
-        #   constants in this module for codes and meanings)
-        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
 
-        # If the string has unclosed formatting, add the end formatting characters to
-        # the end of the string
-        def close_formatting(str)
-          codes = str.scan(/#{ESC}\[(\d+)m/)
-          if codes.length > 0 && codes.last[0] != END_FORMATTING.to_s
-            "#{str}#{esc_seq(END_FORMATTING)}"
-          else
-            str
-          end
-        end
-
-        # Return a substring of the input string that preservse the formatting
-        #
-        # @param str [String] the (possibly formatted) string
-        # @param first_visible_character [Integer] the index of the first character to
-        #   include in the substring (ignoring all hidden formatting characters)
-        # @param num_visible_chars [Integer] the maximum number of visible characters to
-        #   include in the substring (ignoring all hidden formatting characters)
-        def substring(str, first_visible_character, num_visible_chars)
-          substr = ''
-          is_visible = true
-          visible_index = 0
-          substr_visible_len = 0
-          str.chars.each do |char|
-            in_substring = (visible_index >= first_visible_character)
-            is_visible = false if is_visible && char == ESC
-            visible_index += 1 if is_visible
-            if !is_visible || in_substring
-              substr += char
-              substr_visible_len += 1 if is_visible
-            end
-            is_visible = true if !is_visible && char == 'm'
-            break if substr_visible_len == num_visible_chars
-          end
-          close_formatting(substr)
-        end
-
-        private
-
         def esc_seq(code)
           "#{ESC}[#{code}m"
         end

data/lib/whirled_peas/utils/file_handler.rb

@@ -0,0 +1,57 @@
+require 'base64'
+require 'zlib'
+
+module WhirledPeas
+  module Utils
+    module FileHandler
+      module FileWriter
+        VERSION = '1'
+
+        def self.write(fp, renders)
+          fp.puts renders.count
+          renders.each do |strokes|
+            encoded = Base64.encode64(strokes)
+            fp.puts encoded.count("\n")
+            fp.puts encoded
+          end
+        end
+      end
+      private_constant :FileWriter
+
+      class FileReaderV1
+        def self.read(fp)
+          num_renders = Integer(fp.readline.chomp, 10)
+          num_renders.times.map do
+            num_strokes = Integer(fp.readline.chomp, 10)
+            Base64.decode64(num_strokes.times.map { fp.readline }.join)
+          end
+        end
+
+        private
+
+        attr_reader :file
+      end
+      private_constant :FileReaderV1
+
+      READERS = {
+        '1' => FileReaderV1
+      }
+      private_constant :READERS
+
+      def self.write(file, renders)
+        Zlib::GzipWriter.open(file, Zlib::BEST_COMPRESSION) do |gz|
+          gz.puts FileWriter::VERSION
+          FileWriter.write(gz, renders)
+        end
+      end
+
+      def self.read(file)
+        Zlib::GzipReader.open(file) do |gz|
+          version = gz.gets.chomp
+          raise ArgumentError, "Invalid file: #{file}" unless READERS.key?(version)
+          READERS[version].read(gz)
+        end
+      end
+    end
+  end
+end

data/lib/whirled_peas/utils/formatted_string.rb

@@ -0,0 +1,64 @@
+require_relative 'ansi'
+
+module WhirledPeas
+  module Utils
+    class FormattedString
+      def self.blank
+        new('')
+      end
+
+      def initialize(raw, formatting=nil)
+        @raw = raw
+        @formatting = [*formatting]
+      end
+
+      def length
+        raw.length
+      end
+
+      def [](index_or_range)
+        self.class.new(raw[index_or_range], foramtting)
+      end
+
+      def blank?
+        raw.empty?
+      end
+
+      def hash
+        [raw, formatting].hash
+      end
+
+      def ==(other)
+        case other
+        when self.class
+          hash == other.hash
+        when String
+          formatting.empty? && raw == other
+        else
+          false
+        end
+      end
+
+      def to_s
+        if raw.empty? || formatting.length == 0
+          raw
+        else
+          start_formatting = formatting.map { |code| Ansi.esc_seq(code) }.join
+          "#{start_formatting}#{raw}#{Ansi.clear}"
+        end
+      end
+
+      def inspect
+        if raw.empty? || formatting.length == 0
+          raw.inspect
+        else
+          "<#{formatting.join(', ')}>#{raw}<0>".inspect
+        end
+      end
+
+      private
+
+      attr_reader :raw, :formatting
+    end
+  end
+end

data/lib/whirled_peas/utils/title_font.rb

@@ -6,7 +6,7 @@ module WhirledPeas
 
       class << self
         def validate!(font_key)
-          return unless font_key
+          return if font_key.nil?
           return font_key if fonts.key?(font_key)
           allowed = fonts.keys.map(&:inspect).sort
           message = "Unrecognized font: '#{font_key.inspect}', expecting one of #{allowed.join(', ')}"

data/lib/whirled_peas/version.rb

@@ -1,3 +1,3 @@
 module WhirledPeas
-  VERSION = '0.4.1'
+  VERSION = '0.8.0'
 end

data/screen_test/elements/box.frame

@@ -0,0 +1 @@
+[?25lTOP LEFTBOTTOM LEFT TOP RIGHT    BOTTOM RIGHT[?25h

data/screen_test/elements/box.rb

@@ -0,0 +1,20 @@
+require 'whirled_peas'
+
+class TemplateFactory
+  def build(*)
+    WhirledPeas.template do |composer|
+      composer.add_box('Container') do |composer, settings|
+        composer.add_box do |composer, settings|
+          settings.flow = :t2b
+          composer.add_box('TopLeft') { "TOP LEFT" }
+          composer.add_box('BottomLeft') { "BOTTOM LEFT" }
+        end
+        composer.add_box do |composer, settings|
+          settings.flow = :t2b
+          composer.add_box('TopRight') { " TOP RIGHT   " }
+          composer.add_box('BottomRight') { " BOTTOM RIGHT" }
+        end
+      end
+    end
+  end
+end