outputhandler 0.1.3beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa2c1260ae74bb1f296417d69cd039fa429029d8a1d5058002045bb68133e4d6
+  data.tar.gz: 75fe96764a08dd4b11be692cbf161953c0975fc775b18dcaba0f3895e55ebeb7
+SHA512:
+  metadata.gz: 31978d557201555266b1ee15c48d01664c3c04db51bd521fc61a7a69c51e917bfd82aa2e30a772a0047f44bf7d2882b8b01578db472829a27ce7ed325983561f
+  data.tar.gz: 9b8708f025c23602dcb99f8a5caf7027cc62801b04cbe5a7f42bb277f95914ac0edea0a78884a9ed066915d4dee618d2169a4f9a31b1b282e075452723ddef94

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/HISTORY

@@ -0,0 +1,7 @@
+== 0.1.1 / 2019-04-07
+
+* Initial version - Benjamin L. Tischendorf
+
+== 0.1.2 / 2019-04-08
+
+* Added YARD documentation and 'rake cucumber' (also default)

data/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, Donkeybridge
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,49 @@
+# OutputHandler
+
+A wrapper class for ruby, that allows output to be paused. Output can be send to console, to a logfile or both.
+
+## Description
+
+An OutputHandler instance provides #print and #puts, behaving like commonly used IO::print and IO::puts, 
+except that these do not accept _\*args_ but only one chunk to be output. 
+And it behaves this way as long as #pause is not triggered. With output being paused, chunks sent to the 
+instance will wait until either #unpause or #flush are triggered.
+
+At any time, using #print! or #puts! will output directly. 
+
+When using #pause(_limit_), the output is paused for _limit_ seconds (e.g. when printing a help message in a
+fluent stream). 
+
+\#print(!) and \#puts(!) allow a second argument of type Boolean, that adds a carriage return to the beginning of the chunk (e.g. for displaying a progressbar). Please note, that alike IO::print, you probably want to add whitespace to overwrite the entire previous output. 
+
+OutputHandler.new is the same as OutputHandler.new(console: true, logfile: nil).
+
+To discard currently queued output, use #flush(_true_).
+
+
+## Installation
+
+    gem install outputhandler
+
+## Usage example:
+
+    user:~/$ irb
+    "Loading irbrc"
+    2.5.1 :001 > require 'outputhandler'
+    2.5.1 :002 > o = OutputHandler.new
+    2.5.1 :003 > o.print "01: Lore ipsum dolor sit amet"
+    01: Lore ipsum dolor sit amet2.5.1 :004 > o.pause
+    2.5.1 :005 > o.puts  "02: consectetuer adipiscing elit"
+    2.5.1 :006 > o.puts! "03: Aliquam hendrerit mi posuere lectus"
+    03: Aliquam hendrerit mi posuere lectus
+    2.5.1 :007 > o.flush
+    02: consectetuer adipiscing elit
+    2.5.1 :008 > o.puts  "04: Vestibulum enim wisi"
+    2.5.1 :009 > o.puts! "05: viverra nec, fringilla in"
+    05: viverra nec, fringilla in
+    2.5.1 :010 > o.unpause
+    04: Vestibulum enim wisi
+    2.5.1 :011 > o.puts  "06: laoreet vitae, risus."
+    06: laoreet vitae, risus.
+
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new
+
+desc "Run tests"
+task :default => :cucumber

data/features/01-outputhandler_new.feature

@@ -0,0 +1,37 @@
+Feature: Initialization
+
+  Scenario: Create a new OutputHandler from scratch without any options
+    Given a new OutputHandler is created without options
+    Then it should return an object of class OutputHandler
+    Then it should have an instance variable "@outputQueue"
+    And  "@outputQueue" should be a "Queue"
+    And  it should have an instance variable "@console"
+    And  "@console" should be a Boolean
+    And  it should have an instance variable "@file"
+    And  "@file" should be a Boolean
+    And  it should have an instance variable "@logfile"
+    And  "@logfile" should be nil
+    And it should be not paused?
+    And it should not respond to #foo
+    And #out! should send output with newline to console
+    And #out should send output with newline to console
+    And #out! should send output to console without newline when added parameter false
+    And #out should send output to console without newline when added parameter false
+
+
+
+  Scenario Outline: Checking whether it is responding to methods
+    Given a new OutputHandler is created
+    Then  it should respond to "<method>"
+    Examples:
+      | method     |
+      | paused?    |
+      | pause      |
+      | unpause    | 
+      | out        | 
+      | out!       | 
+      | flush      | 
+      | puts       |
+      | puts!      |
+      | print      |
+      | print!     |

data/features/02-outputhandler_pause.feature

@@ -0,0 +1,33 @@
+Feature: Pausing and unpausing the Outputhandler
+
+  Scenario: Creating and pausing the outputhandler should send output via #out! but not via #out
+    Given a new instance is created
+    And it is paused 
+    Then #out! should send output
+    But #out should not send output
+
+  Scenario: Creating and pausing the outputHandler should not send output via #out, but after unpausing it should
+
+    Given a new instance is created
+    And it is paused
+    Then #out should not send immediate output
+    And #out should send immediate output when unpausing
+
+  Scenario: Creating and pausing the outputHandler for 2 second should not print anything, but after 2 seconds it should
+
+    Given a new instance is created
+    And   it is paused for 2 seconds
+    Then  #out should not send immediate output
+    But   should arrive after 2 seconds
+
+  Scenario: Creating and pausing the outputhandler, output should not be sent immediately, but upon #flush
+    Given a new instance is created
+    And   it is paused
+    And   output is send to #out
+    And   output is send to #out
+    Then  it should send immediate upon #flush
+    Given output is send to #out
+    Then  it should not send immediate upon silent #flush
+    And   #out should not send immediate output when unpausing
+
+

data/features/03-outputhandler_opts.feature

@@ -0,0 +1,15 @@
+Feature: A new OutputHandler can react to options hash
+
+  Scenario: Only Hash as Parameter is accepted
+    Given a OutputHandler will be created
+    Then with a String as parameter is should raise a TypeError
+    Then with a Hash as parameter it should not raise
+
+  Scenario: Parameter "console: false" disables default console output
+    Given an OutputHandler is created with parameter "console" set to "false"
+    Then  #out should not send output
+
+  Scenario: Parameter "logile: filename" enables output to filename
+    Given an OutputHandler is created with parameter "logfile" set to "/tmp/foofile"
+    And output "ramses" is send to #out 
+    Then file "/tmp/foofile" should contain output "ramses"

data/features/04-outputhandler_output.feature

@@ -0,0 +1,31 @@
+Feature: outputhandler should be aware of CR and NL
+
+  Scenario: #puts and #puts! should send with newline but without CR
+    Given a new instance is created
+    Then output should contain a NL but no CR when sent to "puts"
+    Then output should contain a NL but no CR when sent to "puts!"
+
+
+  Scenario: #puts(true) and #puts!(true) should send with NL but also with CR 
+    Given a new instance is created
+    Then output should contain a NL with leading CR when sent to "puts" with param true
+    Then output should contain a NL with leading CR when sent to "puts!" with param true
+    
+
+  Scenario: #print and #print! should send without newline
+    Given a new instance is created
+    Then output should contain neither NL nor CR when sent to "print"
+    Then output should contain neither NL nor CR when sent to "print!"
+
+  Scenario: #print(true) and #print!(true) should send without NL but with CR
+    Given a new instance is created 
+    Then output should contain a leading CR but no NL when sent to "print" with param true
+    Then output should contain a leading CR but no NL when sent to "print!" with param true
+
+  Scenario: #print(true) overwrite former #print(true)
+    Given an OutputHandler is created with parameter "logfile" set to "/tmp/barfile"
+    And "foo" is sent to the handler with print
+    Then file "/tmp/barfile" should contain output "foo"
+    And "bar" is sent to the handler with print and param true
+    Then file "/tmp/barfile" should contain output "bar"
+

data/features/step_definitions/01-outputhandler_new_steps.rb

@@ -0,0 +1,47 @@
+Given /a new OutputHandler is created/ do
+  require './lib/outputhandler.rb' 
+  @output_handler = OutputHandler.new
+end
+
+Then "it should return an object of class OutputHandler"  do
+  expect(@output_handler).to be_instance_of(OutputHandler)
+end
+
+Then /^it should have an instance variable "([^"]*)"$/  do |var|
+  expect(@output_handler.instance_variable_defined?(var.to_sym)).to be true
+end
+
+Then /^"([^"]*)" should be a Boolean$/ do |var|
+  expect(@output_handler.instance_variable_get(var.to_sym)).to be_instance_of(TrueClass).or be_instance_of(FalseClass)
+end
+
+Then /^"([^"]*)" should be nil$/ do |var|
+  expect(@output_handler.instance_variable_get(var.to_sym)).to be_nil
+end
+
+Then /^"([^"]*)" should be a "([^"]*)"$/ do |var, klass|
+  expect(@output_handler.instance_variable_get(var.to_sym)).to be_instance_of(Object.const_get(klass))
+end
+
+Then "it should be not paused?" do
+  expect(@output_handler.paused?).to be false
+end
+
+Then "it should not respond to #foo"  do
+  expect(@output_handler).not_to respond_to(:foo)
+end
+
+Then /^it should respond to "([^"]*)"$/ do |method|
+  expect(@output_handler).to respond_to(method.to_sym)
+end
+
+
+Then /^#(out!?) should send output with newline to console$/ do |method|
+  expect{@output_handler.send(method.to_sym,"foo"); sleep 0.25}.to output("foo\n").to_stdout_from_any_process
+end
+
+Then /^#(out!?) should send output to console without newline when added parameter false$/ do |method|
+  expect{@output_handler.send(method.to_sym,"foo",false); sleep 0.1}.to output("foo").to_stdout
+end
+
+

data/features/step_definitions/02-outputhander_pause.steps.rb

@@ -0,0 +1,57 @@
+Given("a new instance is created") do
+  require './lib/outputhandler.rb'
+  @output_handler = OutputHandler.new 
+end
+
+Given("it is paused") do
+  @output_handler.pause
+end
+
+Then("#out! should send output") do
+  expect { @output_handler.out!("foo")}.to output("foo\n").to_stdout
+end
+
+Then("#out should not send output") do
+  expect { @output_handler.out("foo")}.not_to output().to_stdout_from_any_process
+end
+
+Given("output is send to #out") do
+  @output_handler.out("foo")
+end
+
+Given /^output "([^"]*)" is send to #out$/ do |str|
+  @output_handler.out(str)
+  sleep 0.1
+end
+
+Then "#out should not send immediate output" do 
+  expect { @output_handler.out("foo"); sleep 0.25 }.not_to output.to_stdout_from_any_process
+end
+
+Then "#out should send immediate output when unpausing" do
+  expect { @output_handler.unpause; sleep 0.25 }.to output("foo\n").to_stdout_from_any_process
+end
+
+Given /^it is paused for (\d+) seconds$/ do |seconds|
+  @output_handler.pause(seconds)
+end
+
+Then /^should arrive after (\d+) seconds$/ do |seconds|
+  expect{ sleep seconds; }.to output("foo\n").to_stdout_from_any_process
+end
+
+Then "it should send immediate upon #flush" do
+  expect { @output_handler.flush; sleep 0.25 }.to output("foo\nfoo\n").to_stdout_from_any_process
+end
+
+Then "it should not send immediate upon silent #flush" do
+  expect { @output_handler.flush(true); sleep 0.25 }.not_to output.to_stdout_from_any_process
+end
+
+Then "#out should not send immediate output when unpausing" do
+  expect { @output_handler.unpause; sleep 0.25}.not_to output.to_stdout_from_any_process
+end
+
+
+
+

data/features/step_definitions/03-outputhandler_opts_steps.rb

@@ -0,0 +1,22 @@
+require './lib/outputhandler.rb'
+
+Given "a OutputHandler will be created" do 
+end
+
+But "with a String as parameter is should raise a TypeError" do 
+  expect { OutputHandler.new("foo")}.to raise_error(TypeError)
+end
+
+But "with a Hash as parameter it should not raise" do
+  expect { OutputHandler.new({})}.not_to raise_error
+end
+
+Given /^an OutputHandler is created with parameter "([^"]*)" set to "([^"]*)"$/ do |param, value|
+  File.open(value, "w"){|f| f.write "" } if param == "logfile"
+  eval "@output_handler = OutputHandler.new(#{param}:\"#{value}\")"
+end
+
+Then /^file "([^"]*)" should contain output "([^"]*)"$/ do |filename, str|
+  expect( `cat #{filename} | tail -n1`.split("\r").last.chomp).to eq(str.chomp)
+end
+  

data/features/step_definitions/04-outputhandler_output_steps.rb

@@ -0,0 +1,37 @@
+require './lib/outputhandler.rb'
+
+Then /^output should contain a NL but no CR when sent to "([^"]*)"$/ do |method|
+  expect { @output_handler.send(method.to_sym, "foo"); sleep 0.25}.
+    to output("foo\n").to_stdout_from_any_process
+end
+
+Then /^output should contain a NL with leading CR when sent to "([^"]*)" with param true$/ do |method|
+  expect { @output_handler.send(method.to_sym, "foo", true); sleep 0.25}.
+    to output("\rfoo\n").to_stdout_from_any_process
+end
+
+Then /^output should contain neither NL nor CR when sent to "([^"]*)"$/ do |method|
+  expect { @output_handler.send(method.to_sym, "foo"); sleep 0.25 }.
+    to output("foo").to_stdout_from_any_process
+end
+
+Then /^output should contain a leading CR but no NL when sent to "([^"]*)" with param true$/ do |method|
+  expect { @output_handler.send(method.to_sym, "foo", true); sleep 0.25 }.
+    to output("\rfoo").to_stdout_from_any_process
+end
+
+Given "{string} is sent to the handler with print" do |string|
+  puts "sent str is #{string}"
+  @output_handler.print(string)
+  sleep 0.1
+end
+
+Given "{string} is sent to the handler with print and param true" do |string|
+  puts "sent string is #{string}"
+  @output_handler.print(string, true)
+  sleep 0.1
+end
+
+#Then /^file "([^"]*)" should contain "([^"]*)"$/ do |filename, str|
+#  expect(File.read(filename)).to eq("\r#{str}")
+#end

data/features/support/env.rb

@@ -0,0 +1,6 @@
+require 'rspec' 
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/lib/outputhandler.rb

@@ -0,0 +1,171 @@
+#The main class of this gem
+class OutputHandler
+
+  # Aliasing puts and print, as they are included / inherited (?) from IO
+  alias_method :superputs,  :puts
+  # Aliasing puts and print, as they are included / inherited (?) from IO
+  alias_method :superprint, :print
+
+  # Creates a new instance of OutputHandler. It accepts an options hash.
+  #
+  # @param opts [Hash]  
+  # @option opts [Boolean] :console If set to true (default), the handler will output to STDOUT. 
+  # @option opts [String] :logfile If set to a target and the target is valid, the handler will output to logfile. 
+  #
+  def initialize(opts = {}, *args, &block)
+    raise TypeError unless opts.is_a? Hash
+    @outputQueue = Queue.new
+    @console = opts[:console].nil? ? true : opts[:console]
+    @logfile = opts[:logfile].nil? ? nil : opts[:logfile]
+    @file = @logfile.nil? ? false : true
+    @paused = false
+    @outputMonitor = Monitor.new
+    system("touch #{@logfile}") unless @logfile.nil?
+    self.spawn_output
+  end
+
+  # Convenience method, accepts a second parameter to force carriage return
+  # (while \\r in-line also is accepted)
+  #
+  # @param chunk [printable Object]
+  # @param cr    [Boolean] for carriage return
+  def puts(chunk = "", cr = false)
+      self.out(chunk, true, cr)
+  end
+
+  # (see #puts) 
+  def puts!(chunk = "", cr = false)
+    self.out!(chunk, true, cr)
+  end
+
+  # (see #puts)
+  def print(chunk = "", cr = false)
+      self.out(chunk, false, cr)
+  end
+
+  # (see #puts)
+  def print!(chunk = "", cr = false)
+    self.out!(chunk, false, cr)
+  end
+
+  # Returns whether output currently is paused.
+  #
+  # @return [Boolean] 
+  def paused?
+    @paused
+  end
+
+  # Pauses the output. If parameter is sent, output will autoresume after delay. Overrides currently
+  # set delay.
+  #
+  # @param limit [Numeric] Time to pause.
+  def pause(limit = 0)
+    unless self.paused?
+      Thread.kill(@outputThread)
+      @paused = true
+      self.spawn_output
+    end
+    if limit > 0
+      Thread.new do
+        sleep limit
+        @paused = false
+      end
+    end
+  end
+ 
+  # Unpauses currently paused output regardless of any set delay.
+  def unpause
+    @paused = false
+  end
+
+  # Flushes currently suspended output.
+  #
+  # @param silent [Boolean] If set to true, flushes to /dev/null, else 
+  # to configured output(s).
+  def flush(silent = false)
+    while not @outputQueue.empty?
+      el = @outputQueue.pop
+      self.out!(el[:chunk], el[:newline], el[:cr]) unless silent
+    end
+  end
+
+  # Sends next chunk to outputs. Will be queued if #paused, otherwise
+  # sent to output(s).
+  #
+  # @param chunk [printable Object]
+  # @param newline [Boolean] Indicates whether (default) or not to end 
+  # line with a newline character.
+  def out(chunk = "", newline = true, cr = false)
+    el = { chunk: chunk, newline: newline, cr: cr}
+    @outputQueue << el
+  end
+
+  # Sends next chunk to output(s) directly, regardless of #paused.
+  #
+  # @param (see #out)
+  def out!(chunk = "", newline = true, cr = false)
+    superprint "#{cr ? "\r" : "" 
+               }#{chunk.chomp
+               }#{newline ? "\n" : ""}" if @console
+    File.open(@logfile,'a+'){|f| f.write "#{cr ? "\r" : "" 
+                                         }#{chunk.chomp
+                                         }#{newline ? "\n" : "" }" }  if @file
+  end
+
+  # Spawns output thread
+  # @!visibility private
+  def spawn_output
+    @outputThread = Thread.new do
+      loop do
+        if self.paused?
+          sleep 0.1
+        else
+          o = @outputQueue.pop
+          superprint "#{o[:cr] ? "\r" : "" 
+                     }#{o[:chunk]
+                     }#{o[:newline] ? "\n" : ""}" if @console
+          File.open(@logfile,'a+') do |f| 
+            f.write  "#{o[:cr] ? "\r" : "" 
+                     }#{o[:chunk]
+                     }#{o[:newline] ? "\n" : "" }"
+          end if @file
+        end
+      end
+    end
+  end
+
+  # Provides inspection
+  #
+  # @!visibility private
+  def inspect
+    arr = []
+    tmpQueue = Queue.new
+    while not @outputQueue.empty?
+      el = @outputQueue.pop 
+      arr << el
+      tmpQueue << el
+    end
+    @outputQueue = tmpQueue
+    return "<#OutputHandler:0x#{self.object_id.to_s(16)}, paused: #{@paused}, queueLength: #{@outputQueue.size}, outputQueue: #{arr.inspect}>"
+  end
+
+  # Spawns a thread that creates some random output
+  #
+  # @!visibility private
+  def random_output
+    if @random_out_thread.nil?
+      @random_out_thread = Thread.new do
+        loop do
+          o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
+          string = (0...50).map { o[rand(o.length)] }.join
+          @outputQueue << { s: string, newline: true }
+          sleep 5
+        end
+      end
+    else
+      Thread.kill @random_out_thread
+      @random_out_thread = nil
+    end
+  end
+
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: outputhandler
+version: !ruby/object:Gem::Version
+  version: 0.1.3beta
+platform: ruby
+authors:
+- Benjamin L. Tischendorf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 'Wrapper class that enables asynchronious output (pausing / unpausing) '
+email: github@jtown.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- HISTORY
+- LICENSE
+- README.md
+- Rakefile
+- features/01-outputhandler_new.feature
+- features/02-outputhandler_pause.feature
+- features/03-outputhandler_opts.feature
+- features/04-outputhandler_output.feature
+- features/step_definitions/01-outputhandler_new_steps.rb
+- features/step_definitions/02-outputhander_pause.steps.rb
+- features/step_definitions/03-outputhandler_opts_steps.rb
+- features/step_definitions/04-outputhandler_output_steps.rb
+- features/support/env.rb
+- lib/outputhandler.rb
+homepage: https://github.com/donkeybridge/outputhandler
+licenses:
+- BSD-4-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Wrapper class that enables asynchronious output (pausing / unpausing)
+test_files: []