alsa-backup 0.0.8

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/alsa_backup.rb'}"
+puts "Loading alsa_backup gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/alsa/pcm_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'alsa'
+
+describe ALSA::PCM do
+  
+end

data/spec/alsa_backup/cli_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'alsa_backup/cli'
+
+describe AlsaBackup::CLI, "execute" do
+  before(:each) do
+    @stdout_io = StringIO.new
+    @file = test_file
+
+    @recorder = AlsaBackup::Recorder.new(@file)
+    @recorder.stub!(:start)
+    AlsaBackup.stub!(:recorder).and_return(@recorder)
+  end
+
+  def execute_cli(options = {})
+    options = { :file => @file, :length => 2 }.update(options)
+    arguments = options.collect do |key,value| 
+      if value
+        returning "--#{key}" do |argument|
+          argument << "=#{value}" unless value == true
+        end
+      end
+    end.compact
+    
+    AlsaBackup::CLI.execute(@stdout_io, *arguments)
+    @stdout_io.rewind
+    @stdout = @stdout_io.read
+  end
+  
+  it "should use AlsaBackup.recorder" do
+    AlsaBackup.should_receive(:recorder).and_return(@recorder)
+    execute_cli
+  end
+
+  it "should set the record file with specified one" do
+    @recorder.should_receive(:file=).with(file = "dummy")
+    execute_cli :file => file
+  end
+
+  it "should start the AlsaBackup.recorder" do
+    @recorder.should_receive(:start)
+    execute_cli
+  end
+
+  it "should start the recorder with specified length" do
+    @recorder.should_receive(:start).with(length = 60)
+    execute_cli :length => length
+  end
+
+  it "should start the record without length if not specified" do
+    @recorder.should_receive(:start).with(nil)
+    execute_cli :length => nil
+  end
+
+  it "should execute specified config file" do
+    execute_cli :config => fixture_file('config_test.rb'), :file => nil
+    AlsaBackup.recorder.file.should == "config_test_ok"
+  end
+
+  it "should override config file values with command line arguments" do
+    argument_file = "dummy"
+    execute_cli :config => fixture_file('config_test.rb'), :file => argument_file
+    AlsaBackup.recorder.file.should == argument_file
+  end
+
+  it "should write pid in specified file" do
+    pid_file = test_file("pid")
+    execute_cli :pid => pid_file
+
+    IO.read(pid_file).strip.should == $$.to_s
+  end
+
+  it "should daemonize the process with option background" do
+    Daemonize.should_receive(:daemonize)
+    execute_cli :background => true
+  end
+
+end

data/spec/alsa_backup/core_ext_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe Time do
+  
+  describe "floor" do
+    
+    it "should change xh41 on xh49 for min with a modulo of 10" do
+      time = Time.now.change(:min => 49)
+      time.floor(:min, 10).should == time.change(:min => 40)
+    end
+
+  end
+
+end
+
+describe File do
+
+  describe "suffix_basename" do
+
+    def take_this_form(expected_file)
+      simple_matcher("have this #{expected_file}") do |actual|
+        File.suffix_basename(actual,'<prefix>') == expected_file
+      end
+    end
+
+    it { 'test.rb'.should take_this_form('test<prefix>.rb') }
+    
+    it "should return test<prefix> for test" do
+      File.suffix_basename('test','<prefix>').should == 'test<prefix>'
+    end
+
+    it "should return /path/test<prefix>.rb for /patest" do
+      File.suffix_basename('/path/test.rb','<prefix>').should == '/path/test<prefix>.rb'
+    end
+
+    it "should return /test<prefix>.rb for /test.rb" do
+      File.suffix_basename('/path/test.rb','<prefix>').should == '/path/test<prefix>.rb'
+    end
+
+  end
+
+end

data/spec/alsa_backup/recorder_spec.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'alsa_backup/recorder'
+
+describe AlsaBackup::Recorder do
+
+  before(:each) do
+    @file = test_file
+    @recorder = AlsaBackup::Recorder.new(@file)
+  end
+
+  it "should not raise an error on start" do
+    @recorder.start(2)
+    lambda { @recorder.start(2) }.should_not raise_error
+  end
+
+  it "should use the specified alsa device" do
+    @recorder.device = alsa_device = "dummy"
+    ALSA::PCM::Capture.should_receive(:open).with(alsa_device, anything)
+    @recorder.open_capture
+  end
+
+  it "should use the specified sample rate" do
+    @recorder.sample_rate = 48000
+    @recorder.format[:sample_rate].should == @recorder.sample_rate
+  end
+
+  it "should use the specified channels" do
+    @recorder.channels = 4
+    @recorder.format[:channels].should == @recorder.channels
+  end
+
+  it "should use 44100 as default sample rate" do
+    @recorder.sample_rate.should == 44100
+  end
+
+  it "should use 2 as default channels" do
+    @recorder.channels.should == 2
+  end
+
+  it "should use hw:0 as default device" do
+    @recorder.device.should == "hw:0"
+  end
+
+  it "should stop the recording on Interrupt error" do
+    @recorder.stub!(:open_writer).and_raise(Interrupt)
+    @recorder.start
+  end
+
+  describe "error handler" do
+
+    class TestErrorHandler
+
+      def initialize(proc)
+        proc = Proc.new { |e| proc } unless Proc == proc
+        @proc = proc
+      end
+
+      def call(e)
+        if @proc
+          response = @proc.call(e)
+          @proc = nil
+          response
+        end
+      end
+
+    end
+    
+    before(:each) do
+      AlsaBackup::Writer.stub!(:open).and_raise("dummy")
+      @recorder.stub!(:sleep)
+    end
+
+    it "should raise error when error handler is nil" do
+      @recorder.error_handler = nil
+      lambda { @recorder.start }.should raise_error
+    end
+
+    it "should raise error when error handler returns nil or false" do
+      @recorder.error_handler = TestErrorHandler.new(nil)
+      lambda { @recorder.start }.should raise_error
+    end
+
+    def start_recorder(limit = nil)
+      @recorder.start(limit)
+    rescue RuntimeError
+
+    end
+
+    it "should retry when error handler returns something (not false or nil)" do
+      @recorder.error_handler = TestErrorHandler.new(true)
+      AlsaBackup::Writer.should_receive(:open).twice().and_raise("dummy")
+
+      start_recorder
+    end
+
+    it "should use the error handler response as sleep time if numerical" do
+      @recorder.error_handler = TestErrorHandler.new(error_handler_response = 5)
+      @recorder.should_receive(:sleep).with(error_handler_response)
+      start_recorder
+    end
+
+    it "should sleep 5 seconds when the error handler response is a number" do
+      @recorder.error_handler = TestErrorHandler.new(true)
+      @recorder.should_receive(:sleep).with(5)
+      start_recorder
+    end
+
+    it "should not use error handler when recorder is started with a time length" do
+      @recorder.error_handler = mock("error_handler")
+      @recorder.error_handler.should_not_receive(:call)
+
+      start_recorder(2)
+    end
+
+  end
+
+  describe "open_writer" do
+    
+    it "should use the given on_close block" do
+      on_close_block = Proc.new {}
+      @recorder.on_close &on_close_block
+
+      AlsaBackup::Writer.should_receive(:open).with(hash_including(:on_close => on_close_block))
+      @recorder.open_writer {}
+    end
+
+    it "should use the directory" do
+      AlsaBackup::Writer.should_receive(:open).with(hash_including(:directory => @recorder.directory))
+      @recorder.open_writer {}
+    end
+
+    it "should use the file" do
+      AlsaBackup::Writer.should_receive(:open).with(hash_including(:file => @recorder.file))
+      @recorder.open_writer {}
+    end
+
+    it "should use the format wav pcm_16 with wanted sample_rate and channels" do
+      AlsaBackup::Writer.should_receive(:open).with(hash_including(:format => @recorder.format(:format => "wav pcm_16")))
+      @recorder.open_writer {}
+    end
+
+  end
+
+end

data/spec/alsa_backup/writer_spec.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe AlsaBackup::Writer do
+
+  before(:each) do
+    @file = "test.wav"
+    @directory = test_directory
+    @writer = AlsaBackup::Writer.new :directory => @directory, :file => @file
+  end
+
+  describe "when created" do
+
+    it "should use the :directory option as directory" do
+      AlsaBackup::Writer.new(:directory => @directory).directory.should == @directory
+    end
+
+    it "should use the :file option as file" do
+      AlsaBackup::Writer.new(:file => @file).file.should == @file
+    end
+
+    it "should use the :format option as format" do
+      format = {:format => "test"}
+      AlsaBackup::Writer.new(:format => format).format.should == format
+    end
+
+    it "should use default_format when no specified" do
+      AlsaBackup::Writer.new.format.should == AlsaBackup::Writer.default_format
+    end
+
+    it "should include the given :on_close proc in on_close_callbacks" do
+      on_close_proc = Proc.new {}
+      AlsaBackup::Writer.new(:on_close => on_close_proc).on_close_callbacks.should include(on_close_proc)
+    end
+    
+  end
+
+  describe "on_close" do
+    
+    it "should include a callback which delete empty file" do
+      AlsaBackup::Writer.should_receive(:delete_empty_file).with(@file)
+      @writer.on_close(@file)
+    end
+
+    it "should invoke all on_close_callbacks" do
+      file_given_to_proc = nil
+
+      @writer.on_close_callbacks << Proc.new do |file| 
+        file_given_to_proc = file
+      end
+      @writer.on_close(@file)
+
+      file_given_to_proc.should == @file
+    end
+
+    it "should ignore exception from callbacks" do
+      @writer.on_close_callbacks << Proc.new do |file| 
+        raise "Error"
+      end
+      lambda { @writer.on_close(@file) }.should_not raise_error
+    end
+
+  end
+
+  describe "file" do
+    
+    it "should accept file as string" do
+      @writer.file = file_name = "dummy"
+      @writer.file.should == file_name
+    end
+
+    it "should accept file as Proc" do
+      file_name = "dummy"
+      @writer.file = Proc.new { file_name }
+      @writer.file.should == file_name
+    end
+    
+  end
+
+  describe "rename_existing_file" do
+
+    it "should keep file if not exists" do
+      File.should_receive(:exists?).with(@file).and_return(false)
+      File.should_not_receive(:rename)
+      AlsaBackup::Writer.rename_existing_file(@file)
+    end
+
+    it "should try to suffix with '-n' to find a free name" do
+      File.stub!(:exists?).and_return(true)
+
+      free_file = File.suffix_basename(@file, "-99")
+      File.should_receive(:exists?).with(free_file).and_return(false)
+
+      File.should_receive(:rename).with(@file, free_file)
+      AlsaBackup::Writer.rename_existing_file(@file)
+    end
+
+    it "should raise an error when no free file is found" do
+      File.stub!(:exists?).and_return(true)
+      lambda do
+        AlsaBackup::Writer.rename_existing_file(@file)
+      end.should raise_error
+    end
+
+  end
+
+  describe "close" do
+
+    it "should close file (via close_file method)" do
+      @writer.should_receive(:close_file)
+      @writer.close
+    end
+    
+  end
+
+  describe "close_file" do
+    
+    it "should close current sndfile" do
+      sndfile = @writer.sndfile
+      sndfile.should_receive(:close)
+      @writer.close_file
+    end
+
+    it "should notify on_close callbacks (via on_close method)" do
+      @writer.should_receive(:on_close).with(@writer.sndfile.path)
+      @writer.close_file
+    end
+
+  end
+
+end