text-to-noise 0.2.2 → 0.3.0

data/.gitignore

@@ -3,6 +3,7 @@
 Gemfile.lock
 pkg/*
 tmp/*
+log/*
 
 # osx noise
 .DS_Store

data/README.md

@@ -19,13 +19,27 @@ Stuff that I had to do to get this running:
 2. Install `text_to_noise` via [Rubygems][rubygems]:
     `gem install text-to-noise`
 
+Usage
+-----
+
+First, create a sound mapping configuration as shown below. Then you can pipe
+a log into the `text_to_noise` script and it will start chirping:
+
+    tail -f /var/log/mylog | text_to_noise my.sounds.rb
+
+Alternatively, you can run `text_to_noise` on an existing file:
+
+    text_to_noise my.sounds.rb -f file.log
+
+Text-To-Noise will cease processing when it reaches the end of the file.
+
 
 Configuration
 =============
 
 Text-To-Noise is configured with a Ruby file. The configuration contains a set
 of rules for mapping a line of input text to a sound. Each mapping is a single
-method of the form `map( pattern ).to "sound"`.
+method of the form `map( pattern ).to "sound"`:
 
     map( /a regex matching log lines to trigger sounds/ ).to "a sound name to play"
 
@@ -55,9 +69,23 @@ object returned from the regular expression match:
       match_data[1].to_i > 500
     }.to "vulture"
 
-The above rule will play a vulture sound iff a line matches the expression _and_ the block
-returns true.  Applied to a Rails log, the above rule will play a vulture sound whenever a 
-page takes longer than 500ms to render.
+The above rule will play a vulture sound **iff** a line matches the expression
+_and_ the block returns true. Applied to a Rails log, the above rule will play
+a vulture sound whenever a page takes longer than 500ms to render.
+
+Additional patterns may be added with the `when` condition:
+
+    map( /Completed in (\d+)ms/ ) { |match_data|
+      match_data[1].to_i > 500
+    }.when { |match_data|
+      match_data[1].to_i < 55
+    }.to "vulture"
+
+The sound will play if _any_ of the given conditions match.
+
+Since the configuration file is Ruby, you could conceivable do just about
+anything you want in the condition block.
+
 
 For additional details, see the Cucumber [features][Features].  Also, have a 
 look at the [sample][SampleConfig] configuration.
@@ -87,6 +115,7 @@ configurations:
     mockingbird
     nightingale
     owl
+    owl-short
     peacock
     pigeons
     red_lories
@@ -94,23 +123,60 @@ configurations:
     vulture
     whipperwhill
 
-Soon you'll be able to add your own `wav` files for playback, but not just yet.
 
+Adding Your Own Sounds
+----------------------
 
-Usage
------
+To make your own sounds available for play, add `sound_path` declarations to
+your mapping configuration:
 
-First, create a sound mapping configuration as shown above. Then you can pipe
-a log into the `text_to_noise` script and it will start chirping:
+     sound_path "my_sounds/jungle"
+     sound_path "my_sounds/circus"
 
-    tail -f /var/log/mylog | text_to_noise -c my.sounds.rb
+     map /Session/ => "clown"
+     map /404/     => "monkeys"
 
-Alternatively, you can run `text_to_noise` on an existing file:
+Each `sound_path` is a directory containing wav files. Now you can specify
+mappings to wav files in the specified directories. As with the included
+sounds, the '.wav' extension is optional.
+
+
+
+Example
+=======
+
+Here's a starting point if you're sampling a Rails log:
 
-    text_to_noise -c my.sounds.rb -f file.log
+    # rails.configuration.rb
+    sound_path "tmp/sounds" # if you've got some of your own sounds you'd like to try
+
+    map /Rendered/   => %w(cardinal crickets canary), :every => 6
+    map /Processing/ => "crickets", :every => 4
+     
+    map /User Load/  => %w(nightingale crickets canary)
+    map /SessionsController#new/ => "owl-short"
+     
+    map /404 Not Found/ => "hawk"
+    map /RoutingError/  => "hawk"
+     
+    map( /Completed in (\d+)ms/ )  { |match_data|
+      match_data[1].to_i > 500
+    }
+
+Start it up with:
+
+    tail -f /var/www/myrailsapp/shared/logs/production.log | text_to_noise sample.configuration.rb
+
+Or perhaps you're interested in SSH activity on your server:
+
+    # ssh.sounds.rb
+    match /sshd.*Accepted/ => %w[rooster hawk chicken crow]
     
-Text-To-Noise will cease processing when it reaches the end of the file.
+Get this started with:
 
+    echo 'match /sshd.*Accepted/ => %w[rooster hawk chicken crow]' > ssh.sounds.rb
+    tail -f /var/log/secure.log | text_to_noise ssh.sounds.rb
+    
 
 TODO
 ----
@@ -118,12 +184,8 @@ TODO
 At the moment, this only supports playing some free bird songs that are included in the gem.
 Highest priority is the ability to add your own sound sets for playback.
 
-  * Add sounds to the available noises for playback
   * Capistrano integration
   * Automatically refresh configurations
-  * Add an 'every' option to throttle sounds for comman events
-  * Add generators to create stub configurations
-  * Support sound themes?
 
 
 [Homebrew]:http://mxcl.github.com/homebrew

data/bin/text_to_noise

@@ -19,8 +19,6 @@ arg_parser = OptionParser.new do |opts|
   
   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 }
   opts.on( "-t", "--throttle DELAY",
@@ -32,18 +30,18 @@ arg_parser = OptionParser.new do |opts|
   end
 end
 
-arg_parser.parse!
+mapping_files = arg_parser.parse!
 
 begin
-  TextToNoise::CommandLine.new( options ).run
-rescue ArgumentError
+  TextToNoise::CommandLine.new( mapping_files, options ).run
+rescue ArgumentError => e
   $stderr.puts arg_parser
   $stderr.puts <<-EOS
 
 ERROR!
 
-Could not locate a noise configuration.
-Specify a configuration with the -c option.
+Error parsing configuration file, or configuration missing.
+\t#{e}
 
 Try this one if you're processing a Rails log:
 
@@ -64,7 +62,7 @@ Copy one of those into a file and pass it along to text_to_noise.
 For example:
 
   echo 'match /sshd.*Accepted/ => %w[rooster hawk chicken crow]' > ssh.sounds.rb
-  tail -f /var/log/secure.log | text_to_noise -c ssh.sounds.rb
+  tail -f /var/log/secure.log | text_to_noise ssh.sounds.rb
 
 Still having problems?
   Try logging an issue at https://github.com/tobytripp/text_to_noise/issues

data/features/commandline.feature

@@ -8,9 +8,6 @@ Feature: Running text_to_noise
 
     Then the output should contain:
     """
-    Could not locate a noise configuration.
-    Specify a configuration with the -c option.
-
     Try this one if you're processing a Rails log:
 
       match /User Load/     => "nightingale"

data/features/configuration.feature

@@ -15,7 +15,7 @@ Feature: Mapping input lines to sounds for playback
 
     """
 
-    When I run `text_to_noise --config sound_mapping.rb --file stuff.log --mute`
+    When I run `text_to_noise sound_mapping.rb --file stuff.log --mute`
 
     Then the output should contain:
     """
@@ -25,7 +25,8 @@ Feature: Mapping input lines to sounds for playback
   Scenario: Using a Hash to specify mappings
     Given a file named "sound_mapping.rb" with:
     """
-    map /caw/ => "crow", /bakawk/ => "chicken"
+    map /caw/    => "crow"
+    map /bakawk/ => "chicken"
     """
 
     And a file named "input.log" with:
@@ -34,7 +35,7 @@ Feature: Mapping input lines to sounds for playback
     bakawk!
     """
 
-    When I run `text_to_noise -c sound_mapping.rb -f input.log -m`
+    When I run `text_to_noise sound_mapping.rb -f input.log -m`
 
     Then the output should contain "Playing crow.wav"
      And the output should contain "Playing chicken.wav"
@@ -58,7 +59,7 @@ Feature: Mapping input lines to sounds for playback
     User Load (7.1ms)
     """
 
-    When I run `text_to_noise -c sound_mapping.rb -f input.log -m`
+    When I run `text_to_noise 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"
@@ -66,7 +67,8 @@ Feature: Mapping input lines to sounds for playback
   Scenario: Inputs that match multiple rules should fire all sounds
     Given a file named "sound_mapping.rb" with:
     """
-    map /caw/ => "crow", /bakawk/ => "chicken"
+    map /caw/    => "crow"
+    map /bakawk/ => "chicken"
     """
 
     And a file named "input.log" with:
@@ -74,14 +76,13 @@ Feature: Mapping input lines to sounds for playback
     caw    bakawk!
     """
 
-    When I run `text_to_noise -c sound_mapping.rb -f input.log -m`
+    When I run `text_to_noise sound_mapping.rb -f input.log -m`
 
     Then the output should contain "Playing crow.wav"
      And the output should contain "Playing chicken.wav"
 
-  @wip
   Scenario: Throttling a match
-    Given a file named "sound_mapping" with:
+    Given a file named "sound_mapping.rb" with:
     """
     map /Rendered/ => 'crickets', :every => 5
     map( /page/ ).to( 'crickets' ).every( 5 )
@@ -103,10 +104,49 @@ Feature: Mapping input lines to sounds for playback
     Rendered a page
     """
 
-    When I run `text_to_noise -c sound_mapping -f input.short.log -m`
+    When I run `text_to_noise sound_mapping.rb -f input.short.log -m`
 
     Then the output should not contain "Playing crickets.wav"
 
-    When I run `text_to_noise -c sound_mapping -f input.long.log -m`
+    When I run `text_to_noise sound_mapping.rb -f input.long.log -m`
 
     Then the output should contain "Playing crickets.wav"
+
+  Scenario: Throttling with a Proc
+    Given a file named "sound_mapping" with:
+    """
+    map( /Rendered (\w+) page/ ).to( 'frogs' ).when { |md| md[1] == 'A' }
+    map( /Rendered (\w+) page/ ).to( 'crickets' ).when { |md| md[1] == 'B' }
+    """
+
+    And a file named "input.log" with:
+    """
+    Rendered A page
+    """
+    
+    When I run `text_to_noise sound_mapping -f input.log -m`
+
+    Then the output should not contain "Playing crickets.wav"
+     But the output should contain "Playing frogs.wav"
+
+  Scenario: Adding sound directories
+    Given a file named "sound_mapping" with:
+    """
+    sound_path 'other_sounds'
+    map /Rendered/ => 'blurp'
+    """
+
+    And a directory named "other_sounds"
+    And an empty file named "blurp.wav"
+
+    And a file named "input.log" with:
+    """
+    Rendered a page
+    """
+
+    When I run `text_to_noise sound_mapping -f input.log -m`
+
+    Then the output should contain "Playing blurp.wav"
+
+    @wip
+    Scenario: Set volume for a sound

data/features/support/env.rb

@@ -3,3 +3,6 @@ lib = File.expand_path( '../../../lib/', __FILE__ )
 $:.unshift lib unless $:.include?( lib )
 
 require 'text_to_noise'
+
+TextToNoise.logger = Logger.new "log/cucumber.log"
+TextToNoise.logger.level = Logger::DEBUG

data/lib/text_to_noise/command_line.rb

@@ -7,20 +7,23 @@ module TextToNoise
 
     DEFAULT_FILE_DELAY = 100
     
-    def initialize( options={} )
+    def initialize( mapping_configurations, options={} )
       @options = {
         :input  =>  $stdin
       }.merge options
 
-      raise ArgumentError, "No configuration file provided." unless @options[:config]
+      configs = Array === mapping_configurations ? mapping_configurations : [mapping_configurations]
+
+      raise ArgumentError, "No configuration file provided." if configs.empty?
+      
+      @mapping = Router.parse File.read( configs.first )
       
-      @mapping = Mapper.parse File.read( @options[:config] )
       TextToNoise.player = self.player
       TextToNoise.throttle_delay = @options[:throttle] if @options[:throttle]
       TextToNoise.throttle_delay = @options[:throttle] || DEFAULT_FILE_DELAY if @options[:input] != $stdin
-      TextToNoise.logger.level = Logger::DEBUG if @options[:debug]
+      TextToNoise.logger.level   = Logger::DEBUG if @options[:debug]
     rescue Errno::ENOENT => e
-      raise ArgumentError, "Could not locate configuration file: '#{@options[:config]}'"
+      raise ArgumentError, "Could not locate configuration file: '#{configs.first}' (#{e})"
     end
     
     def run

data/lib/text_to_noise/iteration_mapping_condition.rb

@@ -0,0 +1,24 @@
+module TextToNoise
+  class IterationMappingCondition
+    attr_accessor :count
+    
+    def initialize( count )
+      self.count = count
+      @iteration = 0
+    end
+    
+    def play?( match_data=nil )
+      @iteration += 1
+      count == 1 || (@iteration % count == 0)
+    end
+    alias_method :call, :play?
+    
+    def count=( new_count )
+      if new_count > 0
+        @count = new_count
+      else
+        @count = 1
+      end
+    end
+  end
+end

data/lib/text_to_noise/noise_mapping.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+module TextToNoise
+  class NoiseMapping
+    include Logging
+    attr_accessor :targets, :matcher_conditions
+    
+    def initialize( expression_or_map, &block )
+      debug "Parsing expression: #{expression_or_map.inspect}"
+
+      @matcher_conditions = []
+      @regex = nil
+      
+      case expression_or_map
+      when Regexp
+        @regex = expression_or_map
+      when Hash
+        expression_or_map.each do |k,v|
+          case k
+          when Regexp
+            @regex = k
+            self.to v
+          else
+            self.send k.to_sym, v
+          end
+        end
+      else
+        raise ArgumentError, "Unrecognized Mapping configuration: #{expression_or_map.inspect}"
+      end
+
+      raise ArgumentError,
+      "Bad configuration line.  Missing match expression in \"#{expression_or_map.inspect}\"" if @regex.nil?
+
+      matcher_conditions << block if block_given?
+    end
+
+    def ===( other )
+      match_data = @regex.match( other )
+      !match_data.nil? && play?( match_data )
+    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 "#{self.class.name} : #{@regex.inspect} -> #{sound}"
+          TextToNoise.player.play s
+        }
+      end
+
+      self
+    end
+
+    def every( iteration_count )
+      @matcher_conditions << IterationMappingCondition.new( iteration_count )
+      self
+    end
+
+    def when( &clause )
+      @matcher_conditions << clause
+      self
+    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
+
+    private
+
+    def play?( match_data )
+      return true if @matcher_conditions.empty?
+      @matcher_conditions.any? { |c| c.call match_data }
+    end
+  end
+end

data/lib/text_to_noise/player.rb

@@ -13,7 +13,7 @@ module TextToNoise
       self.class.load_rubygame
       
       Rubygame::Sound.autoload_dirs << SOUND_DIR
-      themes = Dir.new(SOUND_DIR).entries.reject { |e| e =~ /[.]/ }
+      themes = Dir.new(SOUND_DIR).entries.reject { |e| e =~ /^[.]/ }
       Rubygame::Sound.autoload_dirs.concat themes.map { |t| File.join SOUND_DIR, t }
       
       @sounds = []
@@ -35,6 +35,10 @@ module TextToNoise
       not @sounds.empty?
     end
 
+    def sound_dirs()
+      Rubygame::Sound.autoload_dirs
+    end
+    
     def available_sounds()
       Rubygame::Sound.autoload_dirs.map do |dir|
         Dir[ "#{dir}/*.wav" ].map { |f| File.basename f }
@@ -44,6 +48,9 @@ module TextToNoise
     def self.load_rubygame()
       old_verbose, $VERBOSE = $VERBOSE, nil
       old_stream, stream = $stdout.dup, $stdout
+
+      return if defined? Rubygame::Sound
+      
       stream.reopen '/dev/null'
       stream.sync = true
       

data/lib/text_to_noise/{mapper.rb → router.rb}

@@ -1,5 +1,5 @@
 module TextToNoise
-  class Mapper
+  class Router
     include Logging
     attr_accessor :mappings
 
@@ -22,18 +22,14 @@ module TextToNoise
       matches.map { |m| m.call }
     end
 
-    protected
+    def sound_path( path )
+      TextToNoise.player.sound_dirs << path
+    end
 
     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
+      debug "Creating map for #{expression.inspect}"
+      mappings << mapping = NoiseMapping.new( expression, &block )
+      mapping
     end
     alias_method :map, :match
   end

data/lib/text_to_noise/version.rb

@@ -1,3 +1,3 @@
 module TextToNoise
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/sample.sounds.rb

@@ -1,6 +1,14 @@
-# match /Rendered/  => %w(crickets canary), :every => 6
-# match /Rendering/ => "cardinal"
-match /User Load/ => %w"nightingale crickets canary"
-match /Processing/ => "crickets"
-match /SessionsController#new/ => "owl"
-match /404 Not Found/ => "hawk"
+sound_path "tmp/sounds"
+
+map /Rendered/  => %w(cardinal crickets canary), :every => 6
+map /Processing/ => "crickets", :every => 4
+
+map /User Load/ => %w"nightingale crickets canary"
+map /SessionsController#new/ => "owl-short"
+
+map /404 Not Found/ => "hawk"
+map /RoutingError/  => "hawk"
+
+map( /Completed in (\d+)ms/ )  { |match_data|
+  match_data[1].to_i > 500
+}

data/spec/spec_helper.rb

@@ -4,7 +4,8 @@ lib = File.expand_path( '../lib/', __FILE__ )
 $:.unshift lib unless $:.include?( lib )
 
 require 'text_to_noise'
-TextToNoise.logger.level = Logger::WARN
+TextToNoise.logger = Logger.new "log/test.log"
+TextToNoise.logger.level = Logger::DEBUG
 
 Rspec.configure do |c|
   c.mock_with :rspec

data/spec/text_to_noise/command_line_spec.rb

@@ -2,18 +2,18 @@ require 'spec_helper'
 
 module TextToNoise
   describe TextToNoise::CommandLine do
-    let( :mapping ) { double( Mapping ) }
+    let( :mapping ) { double( NoiseMapping ) }
     let( :reader  ) { double( LogReader, :call => nil ) }
     
     before :each do
-      Mapper.stub!( :parse ).and_return mapping
+      Router.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( { :config => "sound_map.rb" } )
+        CommandLine.new "sound_map.rb", {}
       end
       
       it "throws an error if no config file is given" do
@@ -25,45 +25,45 @@ module TextToNoise
       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"
+          CommandLine.new "not_found"
         }.should raise_error( ArgumentError )
       end
 
       context "when given a 'config' option" do
-        it "instantiates a Mapping object with the specified configuration" do
+        it "instantiates a NoiseMapping object with the specified configuration" do
           File.should_receive( :read ).with( "sound_map.rb" ).and_return "config"
-          Mapper.should_receive( :parse ).with( "config" )
+          Router.should_receive( :parse ).with( "config" )
           
-          CommandLine.new :config => "sound_map.rb"
+          CommandLine.new "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, :config => "sound_map.rb"
+          CommandLine.new "sound_map.rb", :mute => true
         end
       end
 
       context "when given the 'throttle' option" do
         it "sets the throttle_delay attribute on TextToNoise" do
           TextToNoise.should_receive( :throttle_delay= ).with 100
-          CommandLine.new :config => "sound_map.rb", :throttle => 100
+          CommandLine.new "sound_map.rb", :throttle => 100
         end
       end
 
       context "when given a 'file' option" do
         it "sets a default throttle_delay" do
           TextToNoise.should_receive( :throttle_delay= ).with 100
-          CommandLine.new :config => "sound_map.rb", :input => "sample.log"
+          CommandLine.new "sound_map.rb", :input => "sample.log"
         end
       end
     end
 
     describe "#run" do
-      let( :options ) { Hash[:input, :io, :config, "sound_map.rb"] }
+      let( :options ) { Hash[:input, :io] }
       
-      subject { CommandLine.new( options ) }
+      subject { CommandLine.new( "sound_map.rb", options ) }
 
       
       it "creates a new LogReader object" do
@@ -76,7 +76,7 @@ module TextToNoise
         subject.run      
       end
 
-      it "passes an instance of a Mapping to the LogReader" do
+      it "passes an instance of a NoiseMapping to the LogReader" do
         LogReader.should_receive( :new ).with( anything, mapping )
         subject.run
       end

data/spec/text_to_noise/iteration_mapping_condition_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe TextToNoise::IterationMappingCondition do
+  describe "construction" do
+    it "accepts a count" do
+      described_class.new 4
+    end
+  end
+
+  context "for value 1" do
+    subject { described_class.new 1 }
+    
+    it "#play? returns true for all calls" do
+      3.times do
+        subject.play?.should be_true
+      end
+    end
+  end
+
+  context "for value 2" do
+    subject { described_class.new 2 }
+
+    it "#play? returns true on every other call" do
+      subject.play?.should be_false
+      subject.play?.should be_true
+      subject.play?.should be_false
+      subject.play?.should be_true
+    end
+  end
+end

data/spec/text_to_noise/noise_mapping_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe TextToNoise::NoiseMapping do
+
+  before { TextToNoise.player = double( TextToNoise::Player ) }
+  
+  describe "#initialize" do
+    it "can accept a Hash" do
+      mapping = described_class.new /exp/ => "target"
+      mapping.target.should be_a( Proc )
+    end
+
+    it "allows the 'every' option to be specified in the Hash" do
+      mapping = described_class.new /exp/ => "target", :every => 3
+      mapping.matcher_conditions.should_not be_empty
+    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/ }
+
+    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
+
+    it "returns self" do
+      subject.to( "foo" ).should == subject
+    end
+  end
+
+  describe "#every" do
+    context "when passed the value '3'" do
+      subject { described_class.new( /green/ ).to( "red" ).every( 3 ) }
+
+      it "does not match immediately" do
+        subject.should_not === 'green'
+      end
+
+      it "only matches on the given iteration" do
+        subject.should_not === 'green'
+        subject.should_not === 'green'
+        subject.should === 'green'
+        subject.should_not === 'green'
+        subject.should_not === 'green'
+      end
+    end
+
+    context "when passed the value 1" do
+      subject { described_class.new( /green/ ).to( "red" ).every( 1 ) }
+
+      it "matches on every iteration" do
+        subject.should === 'green'
+        subject.should === 'green'
+        subject.should === 'green'
+      end
+    end
+
+    context "when passed the value 0" do
+      subject { described_class.new( /green/ ).to( "red" ).every( 0 ) }
+
+      it "matches on every iteration" do
+        subject.should === 'green'
+        subject.should === 'green'
+        subject.should === 'green'
+      end
+    end
+
+    context "when passed the value -1" do
+      subject { described_class.new( /green/ ).to( "red" ).every( 0 ) }
+
+      it "matches on every iteration" do
+        subject.should === 'green'
+        subject.should === 'green'
+        subject.should === 'green'
+      end
+    end
+
+    context "when called multiple times" do
+      subject do
+        described_class.new( /green/ ).to( "red" ).
+          every( 3 ).
+          every( 5 )
+      end
+
+      it "fires when any rule matches" do
+        TextToNoise.player.should_receive( :play ).exactly( 3 ).times
+        8.times { subject.call if subject === "green" }
+      end
+    end
+  end
+
+  describe "#when" do
+    let( :player ) { TextToNoise.player }
+    
+    context "given a Proc that returns true" do
+      subject { described_class.new( /blue/ ).to( "green" ).when { true } }
+      
+      it "will match the given input" do
+        subject.should === "blue"
+      end
+    end
+    
+    context "given a Proc that returns false" do
+      subject { described_class.new( /blue/ ).to( "green" ).when { false } }
+
+      it "does not match the input" do
+        subject.should_not === "blue"
+      end
+    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/player_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+module Rubygame
+  class Sound
+    class << self
+      attr_accessor :autoload_dirs
+      
+      def []( sound_name )
+      end
+
+      def autoload_dirs()
+        @autoload_dirs ||= []
+      end
+    end
+  end
+end
+  
+describe TextToNoise::Player do
+  describe "construction" do
+    it "adds the default folder to the autoload paths" do
+      described_class.new
+      Rubygame::Sound.autoload_dirs.should include( TextToNoise::Player::SOUND_DIR )
+    end
+  end
+
+  describe "#sound_dirs" do
+    it "delegates to the underlying rubygame attribute" do
+      subject.sound_dirs << "bar"
+      Rubygame::Sound.autoload_dirs.should include( "bar" )
+    end
+  end
+end

data/spec/text_to_noise/{mapper_spec.rb → router_spec.rb}

@@ -1,15 +1,15 @@
 require 'spec_helper'
 module TextToNoise
-  describe Mapper do
+  describe Router do
     it "reloads its configuration if it has changed"
       
     describe ".parse" do
-      let( :mapping ) { double( Mapping, :to => nil ) }
+      let( :mapping ) { double( NoiseMapping, :to => nil ) }
 
       context "given a nil configuration" do
         it "raises an ArgumentError" do
           lambda {
-            Mapper.parse nil
+            Router.parse nil
           }.should raise_error( ArgumentError )
         end
       end
@@ -17,7 +17,7 @@ module TextToNoise
       context "given a blank configuration" do
         it "raises an ArgumentError" do
           lambda {
-            Mapper.parse " \t \n"
+            Router.parse " \t \n"
           }.should raise_error( ArgumentError )
         end
       end
@@ -26,30 +26,30 @@ module TextToNoise
         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
+          NoiseMapping.should_receive( :new ).with( /brown/ ).and_return mapping
+          Router.parse config
         end
 
         it "configures the mapping" do
-          Mapping.stub!( :new ).with( /brown/ ).and_return mapping
+          NoiseMapping.stub!( :new ).with( /brown/ ).and_return mapping
           mapping.should_receive( :to ).with( "blue" )
           
-          Mapper.parse config
+          Router.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 }
+        before { NoiseMapping.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
+          Router.parse config
         end
 
         it "stores the mappings" do
-          Mapper.parse( config ).should have( 2 ).mappings
+          Router.parse( config ).should have( 2 ).mappings
         end
       end
 
@@ -57,20 +57,20 @@ module TextToNoise
         let( :config ) { "match /brown/ => \"blue\"\n" }
 
         it "configures the mapping" do
-          Mapping.should_receive( :new ).with( /brown/ => "blue" ).and_return mapping
-          Mapper.parse config
+          NoiseMapping.should_receive( :new ).with( /brown/ => "blue" ).and_return mapping
+          Router.parse config
         end
       end
+    end
 
-      context "given a hash-style configuration with multiple mappings" do
-        let( :config ) { "match /brown/ => \"blue\", /green/ => \"red\"\n" }
+    describe "#sound_path" do
+      subject { described_class.new }
+      before { TextToNoise.player = double( TextToNoise::Player ) }
 
-        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
+      it "adds the argument to the player's sound paths" do
+        paths = []
+        TextToNoise.player.should_receive( :sound_dirs ).and_return paths
+        subject.sound_path "foo"
       end
     end
 
@@ -79,7 +79,7 @@ module TextToNoise
       let( :green ) { /green/ }
       let( :blue2 ) { /blu/  }
       
-      subject { Mapper.new.tap { |m| m.mappings = [blue, green, blue2] } }
+      subject { Router.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 )

data/watchr.rb

@@ -6,7 +6,9 @@
 #
 begin
   require "g"
+  puts "Growl loaded"
 rescue LoadError
+  puts "No growl library found"
 end
 
 def announce( message )
@@ -21,12 +23,7 @@ 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
+  spec *Dir["spec/**/*#{name}*_spec.rb"]
 end
 
 def run_all_tests
@@ -37,16 +34,15 @@ end
 def execute( cmd )
   puts "> #{cmd}"
   system cmd
+  system 'date'
 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( '^app/([^/]+)/(.*)\.rb'         ) { |m| specs_matching m[1], m[2]   }
+watch( '^features/(.*)'                ) { |m| execute "cucumber #{m[0]}"  }
 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
@@ -59,8 +55,3 @@ Signal.trap 'INT' do
     run_all_tests
   end
 end
-
-# Ctrl-\
-Signal.trap 'QUIT' do
-  run_all_tests
-end

metadata

@@ -2,7 +2,7 @@
 name: text-to-noise
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors: 
 - Toby Tripp
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-03 00:00:00 Z
+date: 2011-05-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rubygame
@@ -83,12 +83,13 @@ files:
 - features/support/env.rb
 - lib/text_to_noise.rb
 - lib/text_to_noise/command_line.rb
+- lib/text_to_noise/iteration_mapping_condition.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/noise_mapping.rb
 - lib/text_to_noise/player.rb
+- lib/text_to_noise/router.rb
 - lib/text_to_noise/version.rb
 - sample.sounds.rb
 - sounds/birds/australian_frogmouth.wav
@@ -108,6 +109,7 @@ files:
 - sounds/birds/mexican_red_parrot.wav
 - sounds/birds/mockingbird.wav
 - sounds/birds/nightingale.wav
+- sounds/birds/owl-short.wav
 - sounds/birds/owl.wav
 - sounds/birds/peacock.wav
 - sounds/birds/pigeons.wav
@@ -119,9 +121,11 @@ files:
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/text_to_noise/command_line_spec.rb
+- spec/text_to_noise/iteration_mapping_condition_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/noise_mapping_spec.rb
+- spec/text_to_noise/player_spec.rb
+- spec/text_to_noise/router_spec.rb
 - spec/text_to_noise/sound_map.rb
 - ssh.sounds.rb
 - text_to_noise.gemspec
@@ -162,7 +166,9 @@ test_files:
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/text_to_noise/command_line_spec.rb
+- spec/text_to_noise/iteration_mapping_condition_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/noise_mapping_spec.rb
+- spec/text_to_noise/player_spec.rb
+- spec/text_to_noise/router_spec.rb
 - spec/text_to_noise/sound_map.rb

data/lib/text_to_noise/mapping.rb

@@ -1,58 +0,0 @@
-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, target = expression_or_map.to_a.flatten
-        self.to target
-      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/spec/text_to_noise/mapping_spec.rb

@@ -1,91 +0,0 @@
-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