text-to-noise 0.1.2

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*
+
+# osx noise
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rvmrc

@@ -0,0 +1,4 @@
+rvm --create 1.9.2@sounds
+
+[[ -s "ts.gems" ]] && rvm gemset import ts.gems
+bundle install

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Toby Tripp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+TailSounds
+==========
+Ambient monitoring.
+
+Imagine if your servers created ambient noise instead of silent log messages.  What if your
+application infrastructure sounded like a jungle?  Page views are the chittering of crickets,
+logins are the cackle of monkeys, and errors are the roar of a lion.
+
+
+Installation
+------------
+
+Stuff that I had to do to get this running:
+
+1. Install the SDL Mixer library.  I used [Homebrew][homebrew]:
+    brew install sdl sdl_mixer
+
+2. Install text_to_noise via [Rubygems][rubygems]:
+    gem install rsdl text_to_noise
+
+
+Usage
+-----
+
+Pipe a log into the +tail_sound+ script and it will start chirping:
+
+    tail -f /var/log/mylog | text_to_noise
+
+
+TODO
+----
+
+  * Automatically refresh configurations
+  * Add generators to create stub configurations
+  * Support sound themes?
+
+
+[Homebrew]:http://mxcl.github.com/homebrew
+[Rubygems]:http://rubygems.org

data/Rakefile

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "text_to_noise/version"
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+namespace :gem do
+  task :build do
+    system "gem build text_to_noise.gemspec"
+  end
+ 
+  task :release => :build do
+    system "gem push text_to_noise-#{TailSounds::VERSION}"
+  end
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'cucumber/rake/task'
+namespace :cucumber do
+    Cucumber::Rake::Task.new( :ok, 'Run features that should pass' ) do |t|
+      t.fork = true
+      t.profile = 'default'
+    end
+
+    Cucumber::Rake::Task.new( :wip, 'Run features that are being worked on' ) do |t|
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = 'wip'
+  end
+end
+desc 'Alias for cucumber:ok'
+task :cucumber => 'cucumber:ok'
+
+task :default => [:spec, :cucumber]

data/bin/play

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require './lib/text_to_noise'
+
+player = TailSounds::Player.new
+
+ARGV.each do |sound|
+  player.play sound
+  sleep 1
+end
+
+sleep 1 while player.playing?

data/bin/text_to_noise

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+lib = File.expand_path( '../../lib/', __FILE__ )
+$:.unshift lib unless $:.include?( lib )
+
+require 'text_to_noise'
+
+options = {
+  :input  => $stdin,
+  :mute   => false,
+  :config => "sample.sounds.rb"
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+
+  opts.on( "-f", "--file FILE",
+    "Read input from FILE.  Defaults to stdin" ) { |f| options[:input] = File.open( f, "r" ) }
+  opts.on( "-c", "--config MAPPING_CONFIG",
+    "Read input to sound mapping configuration from MAPPING_CONFIG" ) { |c| options[:config] = c }
+  opts.on( "-m", "--mute",
+    "Don't play any sounds, just print what matched" ) { options[:mute] = true }
+end.parse!
+
+TextToNoise::CommandLine.new( options ).run

data/cucumber.yml

@@ -0,0 +1,2 @@
+default: --require features --strict --format pretty --tags ~@wip features
+wip:     --require features --tags @wip:3 --wip features

data/features/configuration.feature

@@ -0,0 +1,64 @@
+Feature: Mapping input lines to sounds for playback
+
+  Use the mapping configuration file to specify which sounds are played for
+  each line in the input stream.
+  
+  Scenario: Mapping a regular expression to a single sound
+    Given a file named "sound_mapping.rb" with:
+    """
+    map( /caw/ ).to "crow"
+
+    """
+    And a file named "stuff.log" with:
+    """
+    caw
+
+    """
+
+    When I run `text_to_noise --config sound_mapping.rb --file stuff.log --mute`
+
+    Then the output should contain:
+    """
+    Playing crow.wav
+    """
+
+  Scenario: Using a Hash to specify mappings
+    Given a file named "sound_mapping.rb" with:
+    """
+    map /caw/ => "crow", /bakawk/ => "chicken"
+    """
+
+    And a file named "input.log" with:
+    """
+    caw
+    bakawk!
+    """
+
+    When I run `text_to_noise -c sound_mapping.rb -f input.log -m`
+
+    Then the output should contain "Playing crow.wav"
+     And the output should contain "Playing chicken.wav"
+
+  Scenario: Configuring a dynamic matcher with a block
+    Given a file named "sound_mapping.rb" with:
+    """
+    map( /Completed in (\d+)ms/ ) { |match_data|
+      match_data[1].to_i > 500
+    }.to "slow_request"
+
+    map( /Load \(([\d.]+)ms\)/ ) { |match_data|
+      match_data[1].to_i > 5
+    }.to "slow_query"
+
+    """
+
+    And a file named "input.log" with:
+    """
+    Completed in 250ms
+    User Load (7.1ms)
+    """
+
+    When I run `text_to_noise -c sound_mapping.rb -f input.log -m`
+    
+    Then the output should contain "Playing slow_query.wav"
+     And the output should not contain "Playing slow_request.wav"

data/features/step_definitions/debugger_steps.rb

@@ -0,0 +1,4 @@
+When /^I am debugging$/ do
+  require 'ruby-debug'
+  debugger
+end

data/features/support/env.rb

@@ -0,0 +1,5 @@
+require 'aruba/cucumber'
+lib = File.expand_path( '../../../lib/', __FILE__ )
+$:.unshift lib unless $:.include?( lib )
+
+require 'text_to_noise'

data/lib/text_to_noise/command_line.rb

@@ -0,0 +1,27 @@
+module TextToNoise
+  class CommandLine
+    attr_reader :options, :mapping
+    
+    def initialize( options={} )
+      @options = {
+        :input  =>  $stdin
+      }.merge options
+      @mapping = Mapper.parse File.read( @options[:config] )
+      TextToNoise.player = self.player
+    rescue Errno::ENOENT => e
+      raise ArgumentError, "Could not locate configuration file: '#{@options[:config]}'"
+    end
+    
+    def run
+      LogReader.new( options[:input], mapping ).call
+      puts "Input processing complete.  Waiting for playback to finish..."
+      while TextToNoise.player.playing?
+        sleep 1
+      end
+    end
+
+    def player
+      @options[:mute] ? MutePlayer.new : Player.new
+    end
+  end
+end

data/lib/text_to_noise/log_reader.rb

@@ -0,0 +1,15 @@
+module TextToNoise
+  class LogReader
+    attr_reader :io
+    def initialize( io, mapper )
+      @io, @mapper = io, mapper
+    end
+
+    def call()
+      while line = io.gets
+        @mapper.dispatch line
+        sleep 0.200 # FIXME: Think of a better way to throttle playback.
+      end
+    end
+  end
+end

data/lib/text_to_noise/logging.rb

@@ -0,0 +1,9 @@
+require 'forwardable'
+
+module TextToNoise
+  module Logging
+    extend Forwardable
+    def_delegators :logger, :warn, :debug, :error, :info
+    def logger() TextToNoise.logger; end
+  end
+end

data/lib/text_to_noise/mapper.rb

@@ -0,0 +1,40 @@
+module TextToNoise
+  class Mapper
+    include Logging
+    attr_accessor :mappings
+
+    def initialize()
+      @mappings = []
+    end
+
+    def self.parse( config )
+      raise ArgumentError, "No configuration given" if config.nil? or config.strip.empty?
+      new.tap { |m|
+        m.instance_eval config
+        m.info "Configured #{m.mappings.size} mappings."
+      }
+    end
+
+    def dispatch( line )
+      debug "Dispatching: #{line.rstrip}"
+      matches = mappings.select { |m| m === line }
+      debug "#{matches.size} matched mappings"
+      matches.map { |m| m.call }
+    end
+
+    protected
+
+    def match( expression, &block )
+      if expression.kind_of?( Hash ) && expression.size > 1
+        expression.each do |k,v|
+          match k => v
+        end
+      else
+        debug "Creating map for #{expression.inspect}"
+        mappings << mapping = Mapping.new( expression, &block )
+        mapping
+      end
+    end
+    alias_method :map, :match
+  end
+end

data/lib/text_to_noise/mapping.rb

@@ -0,0 +1,58 @@
+module TextToNoise
+  class Mapping
+    include Logging
+    attr_accessor :targets, :matcher_proc
+    
+    def initialize( expression_or_map, &block )
+      case expression_or_map
+      when Regexp
+        @regex = expression_or_map
+      when Hash
+        @regex = expression_or_map.keys.first
+        self.to expression_or_map[@regex]
+      else
+        raise ArgumentError, "Unrecognized Mapping configuration: #{expression_or_map.inspect}"
+      end
+
+      @matcher_proc = block if block_given?
+    end
+
+    def ===( other )
+      match_data = @regex.match( other )
+      if matcher_proc
+        match_data && matcher_proc.call( match_data )
+      else
+        not match_data.nil?
+      end
+    end
+
+    def to( sound_or_sounds )
+      if sound_or_sounds.is_a? Array
+        sounds = sound_or_sounds
+      else
+        sounds = [sound_or_sounds]
+      end
+      
+      sounds.each do |sound|
+        s = sound
+        s += ".wav" unless sound =~ /.wav$/
+        self.targets << Proc.new {
+          info "#{@regex.inspect} -> #{sound}"
+          TextToNoise.player.play s
+        }
+      end
+    end
+
+    def call()
+      debug "Calling '#{@regex.inspect}' target..."
+      target.call
+    end
+
+    def targets() @targets ||= []; end
+    def target()
+      @i = -1 unless @i
+      @i = (@i + 1) % targets.size
+      self.targets[@i]
+    end
+  end
+end

data/lib/text_to_noise/mute_player.rb

@@ -0,0 +1,10 @@
+module TextToNoise
+  class MutePlayer
+    include Logging
+    def play( sound_name )
+      info "Playing #{sound_name}"
+    end
+
+    def playing?() false; end
+  end
+end

data/lib/text_to_noise/player.rb

@@ -0,0 +1,45 @@
+module TextToNoise
+  class Player
+    include Logging
+    
+    SOUND_DIR = File.expand_path File.join( APP_ROOT, 'sounds' )
+    class SoundNotFound < StandardError
+      def initialize( sound_name )
+        super "Could not locate '#{sound_name}' in #{Rubygame::Sound.autoload_dirs}"
+      end
+    end
+    
+    def initialize()
+      begin
+        require 'rubygame'
+      rescue LoadError
+        require 'rubygems'
+        require 'rubygame'
+      end
+
+      raise "No Mixer found!  Make sure sdl_mixer is installed." unless defined? Rubygame::Sound
+      
+      Rubygame::Sound.autoload_dirs << SOUND_DIR
+      themes = Dir.new(SOUND_DIR).entries.reject { |e| e =~ /[.]/ }
+      Rubygame::Sound.autoload_dirs.concat themes.map { |t| File.join SOUND_DIR, t }
+      
+      @sounds = []
+    end
+    
+    def play( sound_name )
+      sound = Rubygame::Sound[sound_name]
+      raise SoundNotFound, sound_name if sound.nil?
+
+      debug "Playing #{sound_name}"
+      sound.play :fade_out => 2
+      @sounds << sound
+
+      debug "#{@sounds.size} sounds in queue" if playing?
+    end
+
+    def playing?
+      @sounds = @sounds.select &:playing?
+      not @sounds.empty?
+    end
+  end
+end

data/lib/text_to_noise/version.rb

@@ -0,0 +1,3 @@
+module TextToNoise
+  VERSION = "0.1.2"
+end

data/lib/text_to_noise.rb

@@ -0,0 +1,28 @@
+LIB_DIR   = File.dirname File.expand_path( __FILE__ )
+APP_ROOT  = File.join LIB_DIR,  '..'
+$LOAD_PATH << LIB_DIR
+
+Dir["#{LIB_DIR}/text_to_noise/*.rb"].each { |lib|
+  lib =~ %r<lib/(.*)\.rb$>
+  require $1
+}
+require 'logger'
+
+module TextToNoise
+  def self.player
+    @player ||= Player.new
+  end
+
+  def self.player=( player )
+    @player = player
+  end
+
+  def self.logger
+    @logger ||= Logger.new( STDOUT ).tap { |l| l.level = Logger::INFO }
+  end
+
+  def self.logger=( logger )
+    @logger = logger
+    @logger
+  end
+end

data/sample.sounds.rb

@@ -0,0 +1,6 @@
+match /Rendered/  => %w(crickets canary)
+match /Rendering/ => "cardinal"
+match /User Load/ => "nightingale"
+match /Processing/ => "finch"
+match /SessionsController#new/ => "owl"
+match /404 Not Found/ => "hawk"

data/spec/spec.opts

@@ -0,0 +1 @@
+--format documentation

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+
+lib = File.expand_path( '../lib/', __FILE__ )
+$:.unshift lib unless $:.include?( lib )
+
+require 'text_to_noise'
+TextToNoise.logger.level = Logger::WARN
+
+Rspec.configure do |c|
+  c.mock_with :rspec
+end

data/spec/text_to_noise/command_line_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module TextToNoise
+describe TextToNoise::CommandLine do
+  let( :mapping ) { double( Mapping ) }
+  let( :reader  ) { double( LogReader, :call => nil ) }
+  
+  before :each do
+    Mapper.stub!( :parse ).and_return mapping
+    LogReader.stub!( :new ).and_return reader
+    File.stub!( :read ).with( "sound_map.rb" ).and_return "config"
+  end
+
+  describe "#initialize" do
+    it "accepts an options object" do
+      CommandLine.new( {} )
+    end
+
+    it "raises an error if the config file cannot be found" do
+      File.stub!( :read ).and_raise Errno::ENOENT
+      lambda {
+        CommandLine.new :config => "not_found"
+      }.should raise_error( ArgumentError )
+    end
+
+    context "when given a 'config' option" do
+      it "instantiates a Mapping object with the specified configuration" do
+        File.should_receive( :read ).with( "sound_map.rb" ).and_return "config"
+        Mapper.should_receive( :parse ).with( "config" )
+        
+        CommandLine.new :config => "sound_map.rb"
+      end
+    end
+
+    context "when given the 'mute' option" do
+      it "sets the global Player to an instance of MutePlayer" do
+        TextToNoise.should_receive( :player= ).with instance_of( MutePlayer )
+        CommandLine.new :mute => true
+      end
+    end
+  end
+
+  describe "#run" do
+    let( :options ) { Hash[:input, :io, :config, "sound_map.rb"] }
+    
+    subject { CommandLine.new( options ) }
+
+    
+    it "creates a new LogReader object" do
+      LogReader.should_receive( :new )
+      subject.run
+    end
+
+    it "passes the contents of the file in :input option to the reader" do
+      LogReader.should_receive( :new ).with( :io, anything )
+      subject.run      
+    end
+
+    it "passes an instance of a Mapping to the LogReader" do
+      LogReader.should_receive( :new ).with( anything, mapping )
+      subject.run
+    end
+
+    it "calls #call on the LogReader" do
+      reader.should_receive :call
+      subject.run
+    end
+  end
+end
+end

data/spec/text_to_noise/log_reader_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'stringio'
+
+module TextToNoise
+  describe LogReader do
+    let( :io ) { StringIO.new "phantasm" }
+    let( :mapper ) { double( "LineToSoundMapper" ) }
+
+    subject { LogReader.new io, mapper }
+    
+    describe "#call" do
+      it "reads lines from the provided IO object using #gets" do
+        io.should_receive( :gets )
+        subject.call
+      end
+
+      it "calls #dispatch on an instance of LineToSoundMapper with each line" do
+        mapper.should_receive( :dispatch ).with "phantasm"
+        subject.call
+      end
+    end
+  end
+end

data/spec/text_to_noise/mapper_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+module TextToNoise
+  describe Mapper do
+    it "reloads its configuration if it has changed"
+      
+    describe ".parse" do
+      let( :mapping ) { double( Mapping, :to => nil ) }
+
+      context "given a nil configuration" do
+        it "raises an ArgumentError" do
+          lambda {
+            Mapper.parse nil
+          }.should raise_error( ArgumentError )
+        end
+      end
+
+      context "given a blank configuration" do
+        it "raises an ArgumentError" do
+          lambda {
+            Mapper.parse " \t \n"
+          }.should raise_error( ArgumentError )
+        end
+      end
+      
+      context "given a single line configuration" do
+        let( :config  ) { "match( /brown/ ).to \"blue\"" }
+
+        it "creates a Mapping object for the given configuration line" do
+          Mapping.should_receive( :new ).with( /brown/ ).and_return mapping
+          Mapper.parse config
+        end
+
+        it "configures the mapping" do
+          Mapping.stub!( :new ).with( /brown/ ).and_return mapping
+          mapping.should_receive( :to ).with( "blue" )
+          
+          Mapper.parse config
+        end
+      end
+
+      context "given a multiple line configuration" do
+        let( :config ) { 'match( /brown/ ).to "blue"; map( /green/ ).to "orange"' }
+        before { Mapping.stub!( :new ).and_return mapping }
+
+        it "configures the second mapping in addition to the first" do
+          mapping.should_receive( :to ).with "blue"
+          mapping.should_receive( :to ).with "orange"
+          Mapper.parse config
+        end
+
+        it "stores the mappings" do
+          Mapper.parse( config ).should have( 2 ).mappings
+        end
+      end
+
+      context "given a hash-style configuration" do
+        let( :config ) { "match /brown/ => \"blue\"\n" }
+
+        it "configures the mapping" do
+          Mapping.should_receive( :new ).with( /brown/ => "blue" ).and_return mapping
+          Mapper.parse config
+        end
+      end
+
+      context "given a hash-style configuration with multiple mappings" do
+        let( :config ) { "match /brown/ => \"blue\", /green/ => \"red\"\n" }
+
+        it "configures both mappings" do
+          Mapping.should_receive( :new ).with( /brown/ => "blue" ).and_return mapping
+          Mapping.should_receive( :new ).with( /green/ => "red"  ).and_return mapping
+          
+          Mapper.parse config
+        end
+      end
+    end
+
+    describe "#dispatch" do
+      let( :blue )  { /blue/  }
+      let( :green ) { /green/ }
+      let( :blue2 ) { /blu/  }
+      
+      subject { Mapper.new.tap { |m| m.mappings = [blue, green, blue2] } }
+      
+      it "iterates over its mappings comparing them to the input with #===" do
+        blue.should_receive( :=== ).with( anything )
+        green.should_receive( :=== ).with( anything )
+        
+        subject.dispatch "orange"
+      end
+      
+      it "calls #call on all mappings that matched" do
+        blue.should_receive :call
+        blue2.should_receive :call
+        green.should_not_receive :call
+        
+        subject.dispatch( "blue" )
+      end
+    end
+  end
+end

data/spec/text_to_noise/mapping_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe TextToNoise::Mapping do
+  describe "#initialize" do
+    it "can accept a Hash" do
+      mapping = described_class.new /exp/ => "target"
+      mapping.target.should be_a( Proc )
+    end
+
+    it "stores a passed block for use in later matching" do
+      mapping = described_class.new(  /exp/ => "target" ) { |md| true }
+      mapping.matcher_proc.should be_a( Proc )
+    end
+  end
+
+  describe "#===" do
+    context "when matching against a regex" do
+      subject { described_class.new /green/ }
+      
+      it "returns true when the input matches its regex" do
+        subject.should === "green"
+      end
+      
+      it "returns false when the input does not match its regex" do
+        subject.should_not === "blue"
+      end
+    end
+
+    context "when matching against a Proc" do
+      subject do
+        described_class.new( /green (\d+)/ ) { |match_data| match_data[1].to_i > 5 }
+      end
+
+      it "matches if the block returns true" do
+        should === "green 6"
+      end
+
+      it "does not match if the block returns false" do
+        should_not === "green 1"
+      end
+    end
+  end
+
+  describe "#to" do
+    subject { described_class.new /green/ }
+
+    before { TextToNoise.player = double( TextToNoise::Player ) }
+
+    it "sets the target of the mapping to a Proc" do
+      subject.to( "bar" )
+      subject.target.should be_a( Proc )
+    end
+
+    it "sets the target to call Player#play on #call" do
+      subject.to( "bar.wav" )
+      TextToNoise.player.should_receive( :play ).with "bar.wav"
+
+      subject.target.call
+    end
+
+    it "automatically appends .wav, if it's not present" do
+      subject.to( "bar" )
+      TextToNoise.player.should_receive( :play ).with "bar.wav"
+
+      subject.target.call
+    end
+
+    it "can accept a list of target files" do
+      subject.to ["foo", "bar", "baz"]
+      TextToNoise.player.should_receive( :play ).with "foo.wav"
+      TextToNoise.player.should_receive( :play ).with "bar.wav"
+      TextToNoise.player.should_receive( :play ).with "baz.wav"
+      
+      subject.target.call
+      subject.target.call
+      subject.target.call
+    end
+  end
+
+  describe "#call" do
+    subject do
+      described_class.new( /green/ ).tap do |mapping|
+        mapping.targets = [Proc.new { "called" }]
+      end
+    end
+
+    it "calls #call on its target" do
+      subject.call.should == "called"
+    end
+  end
+end

data/spec/text_to_noise/sound_map.rb

@@ -0,0 +1,2 @@
+match /macaw/ => "blue_amazon_macaw.wav"
+match /canary/ => "canary.wav"

data/ssh.sounds.rb

@@ -0,0 +1 @@
+match /sshd.*Accepted/ => %w[rooster hawk chicken crow]

data/test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'rubygame'
+include Rubygame
+
+# Stuff that I had to do to get this running:
+#
+#     brew install sdl sdl_mixer
+#     gem install rubygame rsdl
+
+# Let's start by trying to play a random mp3 passed as an argument
+mp3 = ARGV.pop
+raise "No Mixer found!  Make sure sdl_mixer is installed." unless defined? Sound
+APP_ROOT = File.dirname File.expand_path( __FILE__ )
+
+Sound.autoload_dirs << File.join( APP_ROOT, "sounds" )
+
+# http://rubygame.org/wiki/NamedResources_tutorial#Autoloading_Resources
+sound = Sound[mp3]
+# sound = Sound.load mp3
+sound.play :stop_after => 4, :fade_out => 2
+
+while sound.playing?
+  sleep 1
+end
+
+# Kick Ass!

data/text_to_noise.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path( '../lib/', __FILE__ )
+$:.unshift lib unless $:.include?( lib )
+
+require 'text_to_noise/version'
+Gem::Specification.new do |spec|
+  spec.name     = "text-to-noise"
+  spec.version  = TextToNoise::VERSION
+  spec.platform = Gem::Platform::RUBY
+
+  spec.summary  = "Play sounds based on string matches."
+  spec.description = "Pipe a file, like a log file, into text_to_noise and it will play sound effects triggered by regex matches in the input."
+  spec.authors  = ["Toby Tripp", "Lydia Tripp"]
+  spec.email    = "toby.tripp+tailsounds@gmail.com"
+  spec.homepage = "https://github.com/tobytripp/text_to_noise"
+  
+  spec.required_rubygems_version = ">= 1.3.6"
+
+  spec.add_dependency "rubygame", "~> 2.6.4"
+
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "aruba"
+  spec.add_development_dependency "rspec"
+  
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  spec.require_path = 'lib'
+end

data/ts.gems

@@ -0,0 +1,2 @@
+bundler -v1.0.12
+rspec -v2.5.0

data/watchr.rb

@@ -0,0 +1,66 @@
+# Run me with:
+#   watchr watchr.rb
+#
+# I will automatically run the relevant specs when you change things.
+# Aren't I convenient?
+#
+begin
+  require "g"
+rescue LoadError
+end
+
+def announce( message )
+  puts message
+  g message if Kernel.respond_to? :g
+end
+
+def spec( *files )
+  announce "Running specs: #{files}"
+  execute "rspec #{files.join " "} --options spec/spec.opts"
+end
+
+def specs_matching( type, name )
+  puts "looking for specs of #{name}"
+  matching_specs = Dir["spec/**/*#{name}*_spec.rb"]
+  if matching_specs.empty?
+    $stderr.puts "No matching specs found!  Did you NOT TEST THIS?!"
+  else
+    spec *matching_specs
+  end
+end
+
+def run_all_tests
+  announce "Running full test suite"
+  execute "rake"
+end
+
+def execute( cmd )
+  puts "> #{cmd}"
+  system cmd
+end
+
+watch( '^spec/[^/]*/(.*)_spec\.rb'     ) { |m| spec m[0] }
+watch( '^spec/spec_helper\.rb'         ) { |m| execute "rake spec" }
+watch( '^spec/support/.*'              ) { |m| execute "rake spec" }
+watch( '^lib/([^/]+)/(.*)\.rb'         ) { |m| specs_matching m[1], m[2]   }
+watch( '^features/step_definitions/.*' ) { |m| execute "cucumber features" }
+watch( '^features/([^/]+\.feature)'    ) { |m|
+  execute "cucumber #{m[0]}" unless m[1].include? "step_definitions"
+}
+
+Signal.trap 'INT' do
+  if @sent_an_int then
+    puts "   A second INT?  Ok, I get the message.  Shutting down now."
+    exit
+  else
+    puts "   Did you just send me an INT? Ugh.  I'll quit for real if you do it again."
+    @sent_an_int = true
+    Kernel.sleep 1.5
+    run_all_tests
+  end
+end
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  run_all_tests
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification 
+name: text-to-noise
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Toby Tripp
+- Lydia Tripp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-30 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubygame
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.6.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Pipe a file, like a log file, into text_to_noise and it will play sound effects triggered by regex matches in the input.
+email: toby.tripp+tailsounds@gmail.com
+executables: 
+- play
+- text_to_noise
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/play
+- bin/text_to_noise
+- cucumber.yml
+- features/configuration.feature
+- features/step_definitions/debugger_steps.rb
+- features/support/env.rb
+- lib/text_to_noise.rb
+- lib/text_to_noise/command_line.rb
+- lib/text_to_noise/log_reader.rb
+- lib/text_to_noise/logging.rb
+- lib/text_to_noise/mapper.rb
+- lib/text_to_noise/mapping.rb
+- lib/text_to_noise/mute_player.rb
+- lib/text_to_noise/player.rb
+- lib/text_to_noise/version.rb
+- sample.sounds.rb
+- sounds/birds/australian_frogmouth.wav
+- sounds/birds/blue_amazon_macaw.wav
+- sounds/birds/canary.wav
+- sounds/birds/canary2.wav
+- sounds/birds/cardinal.wav
+- sounds/birds/chicken.wav
+- sounds/birds/crow-1.wav
+- sounds/birds/crow.wav
+- sounds/birds/finch.wav
+- sounds/birds/geese.wav
+- sounds/birds/hawk.wav
+- sounds/birds/lapwing.wav
+- sounds/birds/meadow_lark_long.wav
+- sounds/birds/meadow_lark_short.wav
+- sounds/birds/mexican_red_parrot.wav
+- sounds/birds/mockingbird.wav
+- sounds/birds/nightingale.wav
+- sounds/birds/owl.wav
+- sounds/birds/peacock.wav
+- sounds/birds/pigeons.wav
+- sounds/birds/red_lories.wav
+- sounds/birds/rooster.wav
+- sounds/birds/vulture.wav
+- sounds/birds/whipperwhill.wav
+- sounds/crickets.wav
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/text_to_noise/command_line_spec.rb
+- spec/text_to_noise/log_reader_spec.rb
+- spec/text_to_noise/mapper_spec.rb
+- spec/text_to_noise/mapping_spec.rb
+- spec/text_to_noise/sound_map.rb
+- ssh.sounds.rb
+- test.rb
+- text_to_noise.gemspec
+- ts.gems
+- watchr.rb
+has_rdoc: true
+homepage: https://github.com/tobytripp/text_to_noise
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Play sounds based on string matches.
+test_files: 
+- features/configuration.feature
+- features/step_definitions/debugger_steps.rb
+- features/support/env.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/text_to_noise/command_line_spec.rb
+- spec/text_to_noise/log_reader_spec.rb
+- spec/text_to_noise/mapper_spec.rb
+- spec/text_to_noise/mapping_spec.rb
+- spec/text_to_noise/sound_map.rb