whirled_peas 0.1.0 → 0.4.1

data/lib/whirled_peas.rb

@@ -1,44 +1,26 @@
 require 'logger'
 
+require 'whirled_peas/errors'
+
+require 'whirled_peas/config'
 require 'whirled_peas/frame'
+require 'whirled_peas/template'
 require 'whirled_peas/ui'
+require 'whirled_peas/utils'
 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
+  def self.config
+    @config ||= Config.new
+  end
 
-    consumer_thread.join
+  def self.configure(&block)
+    yield config
   end
 
   def self.template(&block)
+    require 'whirled_peas/template/element'
+
     template = UI::Template.new
     yield template, template.settings
     template

data/lib/whirled_peas/command_line.rb

@@ -0,0 +1,270 @@
+module WhirledPeas
+  class Command
+    DEFAULT_REFRESH_RATE = 30
+
+    DEFAULT_LOG_LEVEL = Logger::INFO
+    DEFAULT_FORMATTER = proc do |severity, datetime, progname, msg|
+      if msg.is_a?(Exception)
+        msg = %Q(#{msg.class}: #{msg.to_s}\n    #{msg.backtrace.join("\n    ")})
+      end
+      "[#{severity}] #{datetime.strftime('%Y-%m-%dT%H:%M:%S.%L')} (#{progname}) - #{msg}\n"
+    end
+
+    def self.command_name
+      self.name.split('::').last.sub(/Command$/, '').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+    end
+
+    def self.build_logger(output, level=DEFAULT_LOG_LEVEL, formatter=DEFAULT_FORMATTER)
+      logger = Logger.new(output)
+      logger.level = level
+      logger.formatter = formatter
+      logger
+    end
+
+    attr_reader :args
+
+    def initialize(args)
+      @args = args
+    end
+
+    def valid?
+      @error_text = nil
+      validate!
+      @error_text.nil?
+    end
+
+    def print_error
+      puts @error_text if @error_text
+      print_usage
+    end
+
+    def start
+    end
+
+    private
+
+    def print_usage
+      puts "Usage: #{$0} #{self.class.command_name}"
+    end
+
+    def validate!
+      # Set @error_text if the options are not valid
+    end
+  end
+
+  class TitleFontsCommand < Command
+    def start
+      require 'whirled_peas/utils/title_font'
+
+      Utils::TitleFont.fonts.keys.each do |key|
+        puts Utils::TitleFont.to_s(key.to_s, key)
+        puts key.inspect
+        puts
+      end
+    end
+  end
+
+  class ConfigCommand < Command
+    def start
+      require config
+    end
+
+    private
+
+    attr_reader :config
+
+    def validate!
+      if args.length == 0
+        @error_text = "#{self.class.command_name} requires a config file"
+      elsif !File.exist?(args[0])
+        @error_text = "File not found: #{args[0]}"
+      elsif args[0][-3..-1] != '.rb'
+        @error_text = 'Config file should be a .rb file'
+      else
+        @config = args[0][0] == '/' ? args[0] : File.join(Dir.pwd, args[0])
+      end
+    end
+
+    def print_usage
+      puts "Usage: #{$0} #{self.class.command_name} <config file>"
+    end
+  end
+
+  class StartCommand < ConfigCommand
+    LOGGER_ID = 'MAIN'
+
+    def start
+      super
+      require 'whirled_peas/frame/event_loop'
+      require 'whirled_peas/frame/producer'
+
+      logger = self.class.build_logger(File.open('whirled_peas.log', 'a'))
+
+      consumer = Frame::EventLoop.new(
+        WhirledPeas.config.template_factory,
+        WhirledPeas.config.loading_template_factory,
+        DEFAULT_REFRESH_RATE,
+        logger
+      )
+      Frame::Producer.produce(consumer, logger) do |producer|
+        begin
+          WhirledPeas.config.driver.start(producer)
+        rescue => e
+          logger.warn(LOGGER_ID) { 'Driver exited with error, terminating producer...' }
+          logger.error(LOGGER_ID) { e }
+          raise
+        end
+      end
+    end
+  end
+
+  class ListFramesCommand < ConfigCommand
+    def start
+      super
+      require 'whirled_peas/frame/print_consumer'
+      require 'whirled_peas/frame/producer'
+
+      logger = self.class.build_logger(STDOUT)
+      Frame::Producer.produce(Frame::PrintConsumer.new, logger) do |producer|
+        begin
+          WhirledPeas.config.driver.start(producer)
+        rescue => e
+          logger.warn(LOGGER_ID) { 'Driver exited with error, terminating producer...' }
+          logger.error(LOGGER_ID) { e }
+          raise
+        end
+      end
+    end
+  end
+
+  class PlayFrameCommand < ConfigCommand
+    def start
+      super
+
+      if args.last == '--debug'
+        puts WhirledPeas.config.template_factory.build(frame, frame_args).inspect
+        exit
+      end
+
+      require 'whirled_peas/frame/event_loop'
+      require 'whirled_peas/frame/producer'
+
+      logger = self.class.build_logger(File.open('whirled_peas.log', 'a'))
+
+      consumer = Frame::EventLoop.new(
+        WhirledPeas.config.template_factory,
+        WhirledPeas.config.loading_template_factory,
+        DEFAULT_REFRESH_RATE,
+        logger
+      )
+      Frame::Producer.produce(consumer, logger) do |producer|
+        producer.send_frame(args[1], duration: 5, args: frame_args)
+      end
+    end
+
+    private
+
+    attr_reader :frame, :frame_args
+
+    def validate!
+      super
+      if !@error_text.nil?
+        return
+      elsif args.length < 2
+        @error_text = "#{self.class.command_name} requires a frame name"
+      else
+        require 'json'
+        @frame = args[1]
+        @frame_args = {}
+        JSON.parse(args[2] || '{}').each do |key, value|
+          @frame_args[key.to_sym] = value
+        end
+      end
+    end
+
+    def print_usage
+      puts "Usage: #{$0} #{self.class.command_name} <config file> <frame> [args as a JSON string] [--debug]"
+    end
+  end
+
+  class LoadingCommand < ConfigCommand
+    def start
+      super
+      unless WhirledPeas.config.loading_template_factory
+        puts 'No loading screen configured'
+        exit
+      end
+
+      if args.last == '--debug'
+        puts WhirledPeas.config.loading_template_factory.build.inspect
+        exit
+      end
+
+      require 'whirled_peas/frame/event_loop'
+      require 'whirled_peas/frame/producer'
+
+      logger = self.class.build_logger(File.open('whirled_peas.log', 'a'))
+      consumer = Frame::EventLoop.new(
+        WhirledPeas.config.template_factory,
+        WhirledPeas.config.loading_template_factory,
+        DEFAULT_REFRESH_RATE,
+        logger
+      )
+      Frame::Producer.produce(consumer, logger) { sleep(5) }
+    end
+
+    private
+
+    def print_usage
+      puts "Usage: #{$0} #{self.class.command_name} [--debug]"
+    end
+  end
+
+  class CommandLine
+    COMMANDS = [
+      StartCommand,
+      ListFramesCommand,
+      PlayFrameCommand,
+      LoadingCommand,
+      TitleFontsCommand
+    ].map.with_object({}) { |c, h| h[c.command_name] = c }
+
+    def initialize(args)
+      @args = args
+    end
+
+    def start
+      if args.length < 1
+        print_usage
+        exit(1)
+      end
+
+      command = args.shift
+
+      unless COMMANDS.key?(command)
+        puts "Unrecognized command: #{command}"
+        print_usage
+        exit(1)
+      end
+
+      cmd = COMMANDS[command].new(args)
+
+      unless cmd.valid?
+        cmd.print_error
+        exit(1)
+      end
+
+      cmd.start
+    end
+
+    private
+
+    attr_reader :args
+
+    def print_usage
+      puts "Usage: #{$0} <command> [command options]"
+      puts
+      puts "Available commands: #{COMMANDS.keys.join(', ')}"
+    end
+  end
+end

data/lib/whirled_peas/config.rb

@@ -0,0 +1,21 @@
+module WhirledPeas
+  class Config
+    attr_writer :driver, :template_factory
+    attr_accessor :loading_template_factory
+
+    def driver
+      unless @driver
+        raise ConfigurationError, 'driver must be configured'
+      end
+      @driver
+    end
+
+    def template_factory
+      unless @template_factory
+        raise ConfigurationError, 'template_factory must be configured'
+      end
+      @template_factory
+    end
+  end
+  private_constant :Config
+end

data/lib/whirled_peas/errors.rb

@@ -0,0 +1,5 @@
+module WhirledPeas
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+end

data/lib/whirled_peas/frame.rb

@@ -1,13 +1,6 @@
-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

data/lib/whirled_peas/frame/event_loop.rb

@@ -0,0 +1,91 @@
+require_relative '../null_logger'
+require_relative '../ui/screen'
+
+module WhirledPeas
+  module Frame
+    class EventLoop
+      LOGGER_ID = 'EVENT LOOP'
+
+      def initialize(template_factory, loading_template_factory, refresh_rate, logger=NullLogger.new)
+        @template_factory = template_factory
+        @loading_template_factory = loading_template_factory
+        @queue = Queue.new
+        @frame_duration = 1.0 / refresh_rate
+        @logger = logger
+      end
+
+      def enqueue(name, duration, args)
+        # If duration is nil, set it to the duration of a single frame
+        queue.push([name, duration || frame_duration, args])
+      end
+
+      def running?
+        @running
+      end
+
+      def start(screen=UI::Screen.new)
+        wait_for_content(screen)
+        play_content(screen)
+      rescue
+        logger.warn(LOGGER_ID) { 'Exiting with error' }
+        raise
+      ensure
+        # We may have exited due to an EOF or a raised exception, set state so that
+        # instance reflects actual state.
+        @running = false
+        screen.finalize if screen
+      end
+
+      def stop
+        logger.info(LOGGER_ID) { 'Stopping...' }
+        enqueue(Frame::EOF, nil, {})
+        @running = false
+      end
+
+      private
+
+      attr_reader :template_factory, :loading_template_factory, :queue, :frame_duration, :logger
+
+      def wait_for_content(screen)
+        if loading_template_factory
+          play_loading_screen(screen)
+        else
+          sleep(frame_duration) while queue.empty?
+        end
+      end
+
+      def play_loading_screen(screen)
+        while queue.empty?
+          screen.paint(loading_template_factory.build)
+          sleep(frame_duration)
+        end
+      end
+
+      def play_content(screen)
+        @running = true
+        template = nil
+        frame_until = Time.new(0)  # Tell the loop to immediately pick up a new frame
+        while running?
+          frame_start = Time.now
+          next_frame_at = frame_start + frame_duration
+          if frame_until > frame_start
+            # While we're still displaying the previous frame, refresh the screen
+            screen.refresh
+          elsif !queue.empty?
+            name, duration, args = queue.pop
+            if name == Frame::EOF
+              @running = false
+            else
+              frame_until = frame_start + duration
+              template = template_factory.build(name, args)
+              screen.paint(template)
+            end
+          else
+            wait_for_content(screen)
+          end
+          sleep([0, next_frame_at - Time.now].max)
+        end
+      end
+    end
+  end
+end