whirled_peas 0.7.1 → 0.8.0

data/lib/whirled_peas/frame/event_loop.rb

@@ -1,90 +0,0 @@
-require 'whirled_peas/null_logger'
-require 'whirled_peas/graphics/screen'
-
-require_relative 'consumer'
-
-module WhirledPeas
-  module Frame
-    class EventLoop < Consumer
-      DEFAULT_REFRESH_RATE = 30
-
-      LOGGER_ID = 'EVENT LOOP'
-
-      def initialize(
-        template_factory,
-        loading_template_factory=nil,
-        refresh_rate: DEFAULT_REFRESH_RATE,
-        logger: NullLogger.new,
-        screen: Graphics::Screen.new
-      )
-        @template_factory = template_factory
-        @loading_template_factory = loading_template_factory
-        @queue = Queue.new
-        @frame_duration = 1.0 / refresh_rate
-        @logger = logger
-        @screen = screen
-      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 start
-        super
-        wait_for_content
-        play_content
-      rescue
-        self.running = false
-        logger.warn(LOGGER_ID) { 'Exiting with error' }
-        raise
-      ensure
-        screen.finalize
-      end
-
-      private
-
-      attr_reader :template_factory, :loading_template_factory, :queue, :frame_duration, :logger, :screen
-
-      def wait_for_content
-        if loading_template_factory
-          play_loading_screen
-        else
-          sleep(frame_duration) while queue.empty?
-        end
-      end
-
-      def play_loading_screen
-        while queue.empty?
-          screen.paint(loading_template_factory.build)
-          sleep(frame_duration)
-        end
-      end
-
-      def play_content
-        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 == EOF
-              self.running = false
-            else
-              frame_until = frame_start + duration
-              template = template_factory.build(name, args)
-              screen.paint(template)
-            end
-          else
-            wait_for_content
-          end
-          sleep([0, next_frame_at - Time.now].max)
-        end
-      end
-    end
-  end
-end

data/lib/whirled_peas/frame/producer.rb

@@ -1,67 +0,0 @@
-require 'socket'
-require 'json'
-
-require 'whirled_peas/null_logger'
-
-module WhirledPeas
-  module Frame
-    # A Producer is the object given to the driver as the interface that allows
-    # the driver to emit frame events. The recommended way of creating a Producer
-    # is by invoking `Producer.produce` as it handles the lifecycle methods of
-    # the consumer.
-    class Producer
-      LOGGER_ID = 'PRODUCER'
-
-      # Manages the consumer lifecycle and yields a Producer to send frames to the
-      # consumer
-      #
-      # @param consumer [Consumer] instance that consumes frame events through
-      #   `#enqueue`
-      def self.produce(consumer, logger=NullLogger.new)
-        producer = new(consumer, logger)
-        consumer_thread = Thread.new do
-          Thread.current.report_on_exception = false
-          consumer.start
-        end
-        yield producer
-        producer.flush
-      rescue => e
-        logger.warn(LOGGER_ID) { 'Exited with error' }
-        logger.error(LOGGER_ID) { e }
-        raise
-      ensure
-        consumer.stop
-        consumer_thread.join if consumer_thread
-      end
-
-      def initialize(consumer, logger=NullLogger.new)
-        @consumer = consumer
-        @logger = logger
-        @queue = Queue.new
-      end
-
-      # Buffer a frame to be played for the given duration. `#flush` must be called
-      # for frames to get pushed to the EventLoop.
-      #
-      # @param name [String] name of frame, which is passed to #build of the
-      #   TemplateFactory
-      # @param duration [Float|Integer] duration in seconds the frame should be,
-      #   displayed (default is nil, which results in a duration of a single refresh
-      #   cycle)
-      # @param args [Hash] key/value pair of arguments, which is passed to #build of
-      #   the TemplateFactory
-      def send_frame(name, duration: nil, args: {})
-        queue.push([name, duration, args])
-      end
-
-      # Send any buffered frames to the EventLoop
-      def flush
-        consumer.enqueue(*queue.pop) while !queue.empty?
-      end
-
-      private
-
-      attr_reader :consumer, :logger, :queue
-    end
-  end
-end

data/lib/whirled_peas/graphics/screen.rb

@@ -1,70 +0,0 @@
-require 'highline'
-
-require 'whirled_peas/utils/ansi'
-
-require_relative 'renderer'
-
-module WhirledPeas
-  module Graphics
-    class Screen
-      def self.current_dimensions
-        width, height = HighLine.new.terminal.terminal_size
-        [width || 0, height || 0]
-      end
-
-      def initialize(width: nil, height: nil, output: STDOUT)
-        @output = output
-        @terminal = HighLine.new.terminal
-        @strokes = []
-        if width && height
-          @width = width
-          @height = height
-        else
-          refresh_size!
-          Signal.trap('SIGWINCH', proc { self.refresh_size! })
-        end
-      end
-
-      def paint(template)
-        @template = template
-        draw
-      end
-
-      def refresh
-        # No need to refresh if the screen dimensions have not changed
-        return if @refreshed_width == width || @refreshed_height == height
-        draw
-      end
-
-      def finalize
-        output.print Utils::Ansi.clear
-        output.print Utils::Ansi.cursor_pos(top: height - 1)
-        output.print Utils::Ansi.cursor_visible(true)
-        output.flush
-      end
-
-      protected
-
-      def refresh_size!
-        @width, @height = self.class.current_dimensions
-      end
-
-      private
-
-      attr_reader :output, :cursor, :terminal, :width, :height
-
-      def draw
-        strokes = [Utils::Ansi.cursor_visible(false), Utils::Ansi.cursor_pos, Utils::Ansi.clear_down]
-        Renderer.new(@template, width, height).paint do |left, top, fstring|
-          next unless fstring.length > 0
-          strokes << Utils::Ansi.cursor_pos(left: left, top: top)
-          strokes << fstring
-        end
-        strokes.each { |stroke| output.print(stroke) }
-        output.flush
-        @refreshed_width = width
-        @refreshed_height = height
-      end
-    end
-  end
-end