whirled_peas 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'whirled_peas'
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/whirled_peas.rb

@@ -0,0 +1,46 @@
+require 'logger'
+
+require 'whirled_peas/frame'
+require 'whirled_peas/ui'
+require 'whirled_peas/version'
+
+module WhirledPeas
+  class Error < StandardError; end
+
+  DEFAULT_HOST = 'localhost'
+  DEFAULT_PORT = 8765
+  DEFAULT_REFRESH_RATE = 30
+
+
+  def self.start(driver, template_factory, log_level: Logger::INFO, refresh_rate: DEFAULT_REFRESH_RATE, host: DEFAULT_HOST, port: DEFAULT_PORT)
+    logger = Logger.new(File.open('whirled_peas.log', 'a'))
+    logger.level = log_level
+    logger.formatter = proc do |severity, datetime, progname, msg|
+      "[#{severity}] #{datetime.strftime('%Y-%m-%dT%H:%M:%S.%L')} (#{progname}) - #{msg}\n"
+    end
+
+    consumer = Frame::Consumer.new(template_factory, refresh_rate, logger)
+    consumer_thread = Thread.new { consumer.start(host: host, port: port) }
+
+    Frame::Producer.start(logger: logger, host: host, port: port) do |producer|
+      begin
+        driver.start(producer)
+        producer.stop
+      rescue => e
+        logger.warn('MAIN') { "Driver exited with error, terminating producer..." }
+        logger.error('MAIN') { e }
+        logger.error('MAIN') { e.backtrace.join("\n") }
+        producer.terminate
+        raise
+      end
+    end
+
+    consumer_thread.join
+  end
+
+  def self.template(&block)
+    template = UI::Template.new
+    yield template, template.settings
+    template
+  end
+end

data/lib/whirled_peas/frame.rb

@@ -0,0 +1,14 @@
+require_relative 'frame/consumer'
+require_relative 'frame/producer'
+
+module WhirledPeas
+  module Frame
+    TERMINATE = '__term__'
+    EOF = '__EOF__'
+
+    DEFAULT_ADDRESS = 'localhost'
+    DEFAULT_PORT = 8765
+  end
+
+  private_constant :Frame
+end

data/lib/whirled_peas/frame/consumer.rb

@@ -0,0 +1,61 @@
+require 'socket'
+require 'json'
+
+require_relative 'loop'
+
+module WhirledPeas
+  module Frame
+    class Consumer
+      def initialize(template_factory, refresh_rate, logger=NullLogger.new)
+        @loop = Loop.new(template_factory, refresh_rate, logger)
+        @logger = logger
+        @running = false
+        @mutex = Mutex.new
+      end
+
+      def start(host:, port:)
+        mutex.synchronize { @running = true }
+        loop_thread = Thread.new { loop.start }
+        socket = TCPSocket.new(host, port)
+        logger.info('CONSUMER') { "Connected to #{host}:#{port}" }
+        while @running
+          line = socket.gets
+          if line.nil?
+            sleep(0.001)
+            next
+          end
+          args = JSON.parse(line)
+          name = args.delete('name')
+          if [Frame::EOF, Frame::TERMINATE].include?(name)
+            logger.info('CONSUMER') { "Received #{name} event, stopping..." }
+            loop.stop if name == Frame::TERMINATE
+            @running = false
+          else
+            duration = args.delete('duration')
+            loop.enqueue(name, duration, args)
+          end
+        end
+        logger.info('CONSUMER') { "Exited normally" }
+      rescue => e
+        logger.warn('CONSUMER') { "Exited with error" }
+        logger.error('CONSUMER') { e.message }
+        logger.error('CONSUMER') { e.backtrace.join("\n") }
+        loop.stop
+      ensure
+        logger.info('CONSUMER') { "Waiting for loop thread to exit" }
+        loop_thread.join
+        logger.info('CONSUMER') { "Closing socket" }
+        socket.close if socket
+      end
+
+      def stop
+        logger.info('CONSUMER') { "Stopping..." }
+        mutex.synchronize { @running = false }
+      end
+
+      private
+
+      attr_reader :loop, :logger, :mutex
+    end
+  end
+end

data/lib/whirled_peas/frame/loop.rb

@@ -0,0 +1,56 @@
+module WhirledPeas
+  module Frame
+    class Loop
+      def initialize(template_factory, refresh_rate, logger=NullLogger.new)
+        @template_factory = template_factory
+        @queue = Queue.new
+        @refresh_rate = refresh_rate
+        @logger = logger
+      end
+
+      def enqueue(name, duration, args)
+        queue.push([name, duration, args])
+      end
+
+      def start
+        logger.info('EVENT LOOP') { "Starting" }
+        @running = true
+        screen = UI::Screen.new
+        sleep(0.01) while queue.empty?  # Wait for the first event
+        remaining_frames = 1
+        template = nil
+        while @running && remaining_frames > 0
+          frame_at = Time.now
+          next_frame_at = frame_at + 1.0 / refresh_rate
+          remaining_frames -= 1
+          if remaining_frames > 0
+            screen.refresh if screen.needs_refresh?
+          elsif !queue.empty?
+            name, duration, args = queue.pop
+            remaining_frames = duration ? duration * refresh_rate : 1
+            template = template_factory.build(name, args)
+            screen.paint(template)
+          end
+          sleep(next_frame_at - Time.now)
+        end
+        logger.info('EVENT LOOP') { "Exiting normally" }
+      rescue => e
+        logger.warn('EVENT LOOP') { "Exiting with error" }
+        logger.error('EVENT LOOP') { e.message }
+        logger.error('EVENT LOOP') { e.backtrace.join("\n") }
+      ensure
+        screen.finalize if screen
+      end
+
+      def stop
+        logger.info('EVENT LOOP') { "Stopping..." }
+        @running = false
+      end
+
+      private
+
+      attr_reader :template_factory, :queue, :refresh_rate, :logger
+    end
+    private_constant :Loop
+  end
+end

data/lib/whirled_peas/frame/producer.rb

@@ -0,0 +1,57 @@
+require 'socket'
+require 'json'
+
+module WhirledPeas
+  module Frame
+    class Producer
+      def self.start(logger: NullLogger.new, host:, port:, &block)
+        server = TCPServer.new(host, port)
+        client = server.accept
+        logger.info('PRODUCER') { "Connected to #{host}:#{port}" }
+        producer = new(client, logger)
+        yield producer
+        logger.info('PRODUCER') { "Exited normally" }
+      rescue => e
+        logger.warn('PRODUCER') { "Exited with error" }
+        logger.error('PRODUCER') { e.message }
+        logger.error('PRODUCER') { e.backtrace.join("\n") }
+      ensure
+        client.close if client
+      end
+
+      def initialize(client, logger=NullLogger.new)
+        @client = client
+        @logger = logger
+        @queue = Queue.new
+      end
+
+      def send(name, duration: nil, args: {})
+        client.puts(JSON.generate('name' => name, 'duration' => duration, **args))
+        logger.debug('PRODUCER') { "Sending frame: #{name}" }
+      end
+
+      def enqueue(name, duration: nil, args: {})
+        queue.push([name, duration, args])
+      end
+
+      def flush
+        while !queue.empty?
+          name, duration, args = queue.pop
+          send(name, duration: duration, args: args)
+        end
+      end
+
+      def stop
+        send(Frame::EOF)
+      end
+
+      def terminate
+        send(Frame::TERMINATE)
+      end
+
+      private
+
+      attr_reader :client, :logger, :queue
+    end
+  end
+end

data/lib/whirled_peas/null_logger.rb

@@ -0,0 +1,20 @@
+module WhirledPeas
+  class NullLogger
+    def debug(*)
+    end
+
+    def error(*)
+    end
+
+    def fatal(*)
+    end
+
+    def info(*)
+    end
+
+    def warn(*)
+    end
+  end
+
+  private_constant :NullLogger
+end

data/lib/whirled_peas/ui.rb

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

data/lib/whirled_peas/ui/ansi.rb

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