whirled_peas 0.5.0 → 0.9.0

data/lib/whirled_peas/frame.rb

@@ -1,6 +0,0 @@
-module WhirledPeas
-  module Frame
-  end
-
-  private_constant :Frame
-end

data/lib/whirled_peas/frame/consumer.rb

@@ -1,30 +0,0 @@
-module WhirledPeas
-  module Frame
-    # Abstract class for consuming frame events.
-    class Consumer
-      EOF = '__EOF__'
-
-      def enqueue(name, duration, args)
-        raise NotImplemented, "#{self.class} must implement #enqueue"
-      end
-
-      def running?
-        @running == true
-      end
-
-      def start
-        self.running = true
-      end
-
-      def stop
-        enqueue(EOF, nil, {})
-      end
-
-      private
-
-      attr_writer :running
-    end
-
-    private_constant :Consumer
-  end
-end

data/lib/whirled_peas/frame/debug_consumer.rb

@@ -1,30 +0,0 @@
-require 'whirled_peas/null_logger'
-
-require_relative 'consumer'
-
-module WhirledPeas
-  module Frame
-    class DebugConsumer < Consumer
-      LOGGER_ID = 'PRINTER'
-
-      def initialize(output=STDOUT, logger=NullLogger.new)
-        @output = output
-        @logger = logger
-      end
-
-      def enqueue(name, duration, args)
-        if name == EOF
-          output.puts "EOF frame detected"
-        else
-          displayed_for = duration ? "#{duration} second(s)" : '1 frame'
-          args_str = args.empty? ? '' : " '#{JSON.generate(args)}'"
-          output.puts "Frame '#{name}' displayed for #{displayed_for}#{args_str}"
-        end
-      end
-
-      private
-
-      attr_reader :output, :logger
-    end
-  end
-end

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,65 +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(output=STDOUT)
-        @output = output
-        @terminal = HighLine.new.terminal
-        @strokes = []
-        refresh_size!
-        Signal.trap('SIGWINCH', proc { self.refresh_size! })
-      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

data/lib/whirled_peas/graphics/text_dimensions.rb

@@ -1,15 +0,0 @@
-module WhirledPeas
-  module Graphics
-    class TextDimensions
-      attr_reader :outer_width, :outer_height
-
-      def initialize(content)
-        @outer_width = 0
-        content.each do |line|
-          @outer_width = line.length if line.length > @outer_width
-        end
-        @outer_height = content.length
-      end
-    end
-  end
-end

data/lib/whirled_peas/settings/text_align.rb

@@ -1,19 +0,0 @@
-module WhirledPeas
-  module Settings
-    module TextAlign
-      LEFT = :left
-      CENTER = :center
-      RIGHT = :right
-
-      def self.validate!(align)
-        return unless align
-        if [TextAlign::LEFT, TextAlign::CENTER, TextAlign::RIGHT].include?(align)
-          align
-        else
-          raise ArgumentError, "Unsupported text alignment: #{align}"
-        end
-      end
-    end
-    private_constant :TextAlign
-  end
-end

data/lib/whirled_peas/template.rb

@@ -1,5 +0,0 @@
-module WhirledPeas
-  module Template
-  end
-  private_constant :Template
-end

data/lib/whirled_peas/template/box_element.rb

@@ -1,8 +0,0 @@
-require_relative 'container'
-
-module WhirledPeas
-  module Template
-    class BoxElement < Container
-    end
-  end
-end

data/lib/whirled_peas/template/composer.rb

@@ -1,68 +0,0 @@
-require 'whirled_peas/settings/box_settings'
-require 'whirled_peas/settings/grid_settings'
-require 'whirled_peas/settings/text_settings'
-
-require_relative 'box_element'
-require_relative 'grid_element'
-require_relative 'text_element'
-
-module WhirledPeas
-  module Template
-    class Composer
-      def self.next_name
-        @counter ||= 0
-        @counter += 1
-        "Element-#{@counter}"
-      end
-
-      def self.build
-        settings = Settings::BoxSettings.new
-        template = BoxElement.new('TEMPLATE', settings)
-        composer = Template::Composer.new(template)
-        value = yield composer, settings
-        if !template.children? && TextElement.stringable?(value)
-          composer.add_text { value.to_s }
-        end
-        template
-      end
-
-      attr_reader :element
-
-      def initialize(element)
-        @element = element
-      end
-
-      def add_text(name=self.class.next_name, &block)
-        child_settings = Settings::TextSettings.inherit(element.settings)
-        child = TextElement.new(name, child_settings)
-        # TextElements are not composable, so yield nil
-        child.content = yield nil, child_settings
-        element.add_child(child)
-      end
-
-      def add_box(name=self.class.next_name, &block)
-        child_settings = Settings::BoxSettings.inherit(element.settings)
-        child = BoxElement.new(name, child_settings)
-        composer = self.class.new(child)
-        value = yield composer, child.settings
-        element.add_child(child)
-        if !child.children? && TextElement.stringable?(value)
-          composer.add_text("#{name}-Text") { value.to_s }
-        end
-      end
-
-      def add_grid(name=self.class.next_name, &block)
-        child_settings = Settings::GridSettings.inherit(element.settings)
-        child = GridElement.new(name, child_settings)
-        composer = self.class.new(child)
-        values = yield composer, child.settings
-        element.add_child(child)
-        if !child.children? && values.is_a?(Array)
-          values.each.with_index do |value, index|
-            composer.add_text("#{name}-Text-#{index}") { value.to_s }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/whirled_peas/template/container.rb

@@ -1,28 +0,0 @@
-require_relative 'element'
-
-module WhirledPeas
-  module Template
-    class Container < Element
-      def initialize(name, settings)
-        super
-        @children = []
-      end
-
-      def add_child(child)
-        @children << child
-      end
-
-      def children?
-        @children.length > 0
-      end
-
-      def num_children
-        @children.length
-      end
-
-      def each_child(&block)
-        @children.each(&block)
-      end
-    end
-  end
-end