flac2mp3 0.2.8 → 0.3.0

data/History.txt

@@ -1,3 +1,10 @@
+== 0.3.0 2008-07-29
+
+* 2 enhancements:
+  * Now has a configuration file, ~/.flac2mp3, where options can be stored.
+    Options given on the command-line override any configuration options.
+	* Greatly refactored internals, though the command-line operation remains the same.
+
 == 0.2.8 2008-07-21
 
 * 1 enhancement:

data/Manifest.txt

@@ -7,7 +7,6 @@ bin/flac2mp3
 config/hoe.rb
 config/requirements.rb
 lib/flac2mp3.rb
-lib/flac2mp3/string_extensions.rb
 lib/flac2mp3/version.rb
 log/debug.log
 script/destroy
@@ -17,7 +16,6 @@ spec/flac2mp3_command_spec.rb
 spec/flac2mp3_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
-spec/string_extensions_spec.rb
 tasks/deployment.rake
 tasks/environment.rake
 tasks/rspec.rake

data/bin/flac2mp3

@@ -15,7 +15,7 @@ require 'flac2mp3/version'
 
 # NOTE: the option -p/--path= is given as an example, and should probably be replaced in your application.
 
-OPTIONS = { :delete => false, :silent => false }
+OPTIONS = {}
 MANDATORY_OPTIONS = %w[]
 
 parser = OptionParser.new do |opts|
@@ -32,7 +32,7 @@ BANNER
   opts.on('-s', '--silent',
           "Don't show progress") { |silent|  OPTIONS[:silent] = silent }
   opts.on('-e', '--encoding=ENCODING', String,
-          "Set lame encoding options", "Default: --preset standard") { |encoding|  OPTIONS[:encoding] = encoding }
+          "Set lame encoding options", "Default: #{Flac2mp3.default_encoding}") { |encoding|  OPTIONS[:encoding] = encoding }
   opts.on('-h', '--help',
           'Show this help message.') { puts opts; exit }
   opts.parse!(ARGV)
@@ -50,4 +50,4 @@ unless filename
   exit
 end
 
-Flac2mp3.convert(filename.dup, OPTIONS)
+Flac2mp3.convert(filename, OPTIONS)

data/lib/flac2mp3.rb

@@ -1,30 +1,116 @@
 $:.unshift File.dirname(__FILE__)
-require 'flac2mp3/string_extensions'
 require 'flacinfo'
 require 'mp3info'
+require 'yaml'
 
-module Flac2mp3
-  class << self
-    def convert(filename, options = {})
-      raise TypeError, "'#{filename}' is not a file" unless FileTest.file?(filename)
-      filename.extend(Flac2mp3::StringExtensions)
-      out_filename = output_filename(filename)
-      out_filename.extend(Flac2mp3::StringExtensions)
-      
-      commands = { :flac => 'flac', :mp3 => 'lame' }
-      commands.each { |k, v|  v << ' --silent' } if options[:silent]
-      encoding = options[:encoding]
-      encoding = default_encoding if encoding.to_s.strip.empty?
-      
-      system "#{commands[:flac]} --stdout --decode #{filename.safequote} | #{commands[:mp3]} #{encoding} - #{out_filename.safequote}"
-      
-      mp3data(out_filename, flacdata(filename))
+class Flac2mp3
+  def initialize(options = {})
+    @config = {}
+    load_config
+    set_options(options)
+  end
+  
+  def convert(filename)
+    raise TypeError, "'#{filename}' is not a file" unless FileTest.file?(filename)
+    process_conversion(filename)
+    File.delete(filename) if delete?
+  end
+  
+  def process_conversion(filename)
+    outfile = output_filename(filename)
+    convert_data(filename, outfile)
+    convert_metadata(filename, outfile)
+  end
+  
+  def convert_data(filename, outfile)
+    system "#{flac_command(filename)} | #{mp3_command(outfile)}"
+  end
+  
+  def flac_command(filename)
+    command = 'flac'
+    command << ' --silent' if silent?
+    
+    "#{command} --stdout --decode #{safequote(filename)}"
+  end
+  
+  def mp3_command(filename)
+    command = 'lame'
+    command << ' --silent' if silent?
+    
+    "#{command} #{encoding} - #{safequote(filename)}"
+  end
+  
+  def convert_metadata(filename, outfile)
+    set_mp3data(outfile, get_flacdata(filename))
+  end
+  
+  def get_flacdata(filename)
+    FlacInfo.new(filename).tags.inject({}) do |hash, (key, value)|
+      key = key.to_s.downcase.to_sym
+      value = value.to_i if value.respond_to?(:match) and value.match(/^\d+$/)
+      value = value.to_s if self.class.string_fields.include?(key)
       
-      File.delete(filename) if options[:delete]
+      hash[key] = value
+      hash
     end
-    
-    def output_filename(filename)
-      filename.chomp('.flac') + '.mp3'
+  end
+  
+  def set_mp3data(filename, tags)
+    raise TypeError, "Tags must be a hash" unless tags.is_a?(Hash)
+    Mp3Info.open(filename) do |mp3|
+      self.class.convert_tags(tags).each do |mp3tag, data|
+        tag = mp3.send(data[:target])
+        tag.send("#{mp3tag}=", data[:value])
+      end
+    end
+  end
+  
+  def load_config
+    yaml = YAML.load(File.read(File.expand_path('~/.flac2mp3'))) || {}
+    @config = yaml.inject({}) do |hash, (key, value)|
+      hash[key.to_sym] = value
+      hash
+    end
+  rescue Errno::ENOENT
+    @config = {}
+  end
+  
+  def set_options(options)
+    raise TypeError, 'options must be a hash' unless options.is_a?(Hash)
+    @options = config.merge(options)
+  end
+  
+  def options
+    @options.dup
+  end
+  
+  def config
+    @config.dup
+  end
+  
+  def delete?
+    !!options[:delete]
+  end
+  
+  def silent?
+    !!options[:silent]
+  end
+  
+  def encoding
+    options[:encoding] || self.class.default_encoding
+  end
+  
+  def output_filename(filename)
+    filename.chomp('.flac') + '.mp3'
+  end
+  
+  def safequote(filename)
+    filename.gsub(/(\W)/, '\\\\\1')
+  end
+  
+  class << self
+    def convert(filename, options = {})
+      new(options).convert(filename)
     end
     
     def tag_mapping
@@ -45,45 +131,6 @@ module Flac2mp3
       }
     end
     
-    def flacdata(filename)
-      data = FlacInfo.new(filename)
-      data.tags.inject({}) do |hash, (key, value)|
-        key = key.to_s.downcase.to_sym
-        value = value.to_i if value.respond_to?(:match) and value.match(/^\d+$/)
-        value = value.to_s if string_fields.include?(key)
-        hash[key] = value
-        hash
-      end
-    end
-    
-    def mp3data(filename, tags)
-      raise TypeError, "Tags must be a hash" unless tags.is_a?(Hash)
-      Mp3Info.open(filename) do |mp3|
-        convert_tags(tags).each do |mp3tag, data|
-          tag = mp3.send(data[:target])
-          tag.send("#{mp3tag}=", data[:value])
-        end
-      end
-    end
-    
-    
-    private
-    
-    def string_fields
-      [:title, :description]
-    end
-    
-    def tag2_fields
-      [:bpm, :composer, :compilation, :tracktotal, :tracknumber, :disctotal, :discnumber]
-    end
-    
-    def tag_formats
-      {
-        :TRCK => ':tracknumber/:tracktotal',
-        :TPOS => ':discnumber/:disctotal'
-      }
-    end
-    
     def convert_tags(tags)
       mp3_tags = {}
       
@@ -100,14 +147,27 @@ module Flac2mp3
         target = tag2_fields.include?(key) ? :tag2 : :tag
         mp3_tags[mp3tag] = { :target => target, :value => value }
       end
+      
       mp3_tags
     end
     
-    
-    private
-    
     def default_encoding
       '--preset standard'
     end
+    
+    def string_fields
+      [:title, :description]
+    end
+    
+    def tag2_fields
+      [:bpm, :composer, :compilation, :tracktotal, :tracknumber, :disctotal, :discnumber]
+    end
+    
+    def tag_formats
+      {
+        :TRCK => ':tracknumber/:tracktotal',
+        :TPOS => ':discnumber/:disctotal'
+      }
+    end
   end
 end

data/lib/flac2mp3/version.rb

@@ -1,8 +1,8 @@
-module Flac2mp3 #:nodoc:
+class Flac2mp3 #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 2
-    TINY  = 8
+    MINOR = 3
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/flac2mp3_command_spec.rb

@@ -36,12 +36,6 @@ describe 'flac2mp3 command' do
     run_command('blah')
   end
   
-  it 'should duplicate the filename' do
-    filename = 'blah'
-    filename.expects(:dup).returns(filename)
-    run_command(filename)
-  end
-  
   it 'should pass on a true flac-deletion option if specified on the command line (using --delete)' do
     Flac2mp3.expects(:convert).with(anything, has_entry(:delete => true))
     run_command('blah', '--delete')
@@ -57,8 +51,8 @@ describe 'flac2mp3 command' do
     run_command('blah', '-d')
   end
   
-  it 'should pass on a false flac-deletion option if nothing specified on the command line' do
-    Flac2mp3.expects(:convert).with(anything, has_entry(:delete => false))
+  it 'should not pass on any flac-deletion option if nothing specified on the command line' do
+    Flac2mp3.expects(:convert).with(anything, Not(has_key(:delete)))
     run_command('blah')
   end
   
@@ -72,8 +66,8 @@ describe 'flac2mp3 command' do
     run_command('blah', '-s')
   end
   
-  it 'should pass on a false silence option if nothing specified on the command line' do
-    Flac2mp3.expects(:convert).with(anything, has_entry(:silent => false))
+  it 'should not pass on any silence option if nothing specified on the command line' do
+    Flac2mp3.expects(:convert).with(anything, Not(has_key(:silent)))
     run_command('blah')
   end
   

data/spec/flac2mp3_spec.rb

@@ -1,459 +1,876 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe Flac2mp3 do
-  it 'should convert' do
-    Flac2mp3.should respond_to(:convert)
-  end
-  
-  it 'should provide output filename' do
-    Flac2mp3.should respond_to(:output_filename)
-  end
-  
-  it 'should provide tag mapping' do
-    Flac2mp3.should respond_to(:tag_mapping)
-  end
-  
-  it 'should get FLAC tag data' do
-    Flac2mp3.should respond_to(:flacdata)
-  end
-  
-  it 'should set MP3 tag data' do
-    Flac2mp3.should respond_to(:mp3data)
-  end
-end
-
-describe Flac2mp3, 'when converting' do
   before :each do
-    Flac2mp3.stubs(:system)
-    Flac2mp3.stubs(:flacdata)
-    Flac2mp3.stubs(:mp3data)
-    File.stubs(:delete)
-  end
-
-  it 'should require a filename' do
-    lambda { Flac2mp3.convert }.should raise_error(ArgumentError)
+    @flac2mp3 = Flac2mp3.new
   end
   
-  it 'should accept a filename' do
-    lambda { Flac2mp3.convert('blah.flac') }.should_not raise_error(ArgumentError)
-  end
-  
-  it 'should check if the filename belongs to a regular file' do
-    filename = 'blah.flac'
-    FileTest.expects(:file?).with(filename).returns(true)
-    Flac2mp3.convert(filename)
-  end
-end
-
-describe Flac2mp3, 'when converting and given a filename belonging to a regular file' do
-  before :each do
-    @filename = 'blah.flac'
-    FileTest.stubs(:file?).with(@filename).returns(true)
-    @output_filename = 'blah.mp3'
-    Flac2mp3.stubs(:output_filename).with(@filename).returns(@output_filename)
-    Flac2mp3.stubs(:system)
-    
-    @filename.stubs(:safequote).returns('-blah-flac-')
-    @output_filename.stubs(:safequote).returns('-blah-mp3-')
-    
-    @flacdata = {}
-    Flac2mp3.stubs(:flacdata).with(@filename).returns(@flacdata)
-    Flac2mp3.stubs(:mp3data)
-  end
-  
-  it 'should not error' do
-    lambda { Flac2mp3.convert(@filename) }.should_not raise_error(TypeError)
-  end
-  
-  it 'should extend the filename with the string extensions' do
-    @filename.expects(:extend).with(Flac2mp3::StringExtensions).returns(@filename)
-    Flac2mp3.convert(@filename)
-  end
-  
-  it 'should get the output filename' do
-    Flac2mp3.expects(:output_filename).with(@filename).returns('outfile')
-    Flac2mp3.convert(@filename)
-  end
-  
-  it 'should extend the output filename with the string extensions' do
-    @output_filename.expects(:extend).with(Flac2mp3::StringExtensions).returns(@output_filename)
-    Flac2mp3.convert(@filename)
-  end
-  
-  it 'should use system commands to convert the FLAC to an MP3' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename)
-  end
-  
-  it 'should set the MP3 tags from the FLAC data' do
-    Flac2mp3.expects(:mp3data).with(@output_filename, @flacdata)
-    Flac2mp3.convert(@filename)
-  end
-  
-  it 'should accept an option to delete the flac' do
-    lambda { Flac2mp3.convert(@filename, :delete => true) }.should_not raise_error(ArgumentError)
-  end
-  
-  it 'should delete the original file if given a true value for the option' do
-    File.expects(:delete).with(@filename)
-    Flac2mp3.convert(@filename, :delete => true)
-  end
-  
-  it 'should not delete the original file if given a false value for the option' do
-    File.expects(:delete).never
-    Flac2mp3.convert(@filename, :delete => false)
-  end
-  
-  it 'should not delete the original file by default' do
-    File.expects(:delete).never
-    Flac2mp3.convert(@filename)
-  end
-  
-  it 'should accept an option to run silently' do
-    lambda { Flac2mp3.convert(@filename, :silent => true) }.should_not raise_error(ArgumentError)
+  describe 'when initialized' do
+    before :each do
+      @options = { :silent => true, :delete => false }
+    end
+    
+    it 'should accept options' do
+      lambda { Flac2mp3.new(@options) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should not require options' do
+      lambda { Flac2mp3.new }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should load the configuration' do
+      Flac2mp3.any_instance.expects(:load_config)
+      Flac2mp3.new
+    end
+    
+    it 'should set the options' do
+      Flac2mp3.any_instance.expects(:set_options).with(@options)
+      Flac2mp3.new(@options)
+    end
+    
+    it 'should default to empty options' do
+      Flac2mp3.any_instance.expects(:set_options).with({})
+      Flac2mp3.new
+    end
   end
   
-  it 'should tell the system commands to be silent if given a true value for the option' do
-    Flac2mp3.expects(:system).with("flac --silent --stdout --decode #{@filename.safequote} | lame --silent --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename, :silent => true)
+  it 'should load the configuration' do
+    @flac2mp3.should respond_to(:load_config)
   end
   
-  it 'should not tell the system commands to be silent if given a true value for the option' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename, :silent => false)
+  describe 'loading the configuration' do
+    it 'should look for a config file' do
+      File.expects(:read).with(File.expand_path('~/.flac2mp3')).returns('')
+      @flac2mp3.load_config
+    end
+    
+    describe 'when a config file is found' do
+      before :each do
+        @config = { :silent => true, :delete => false }
+        @contents = @config.to_yaml
+        File.stubs(:read).returns(@contents)
+      end
+      
+      it 'should parse the file as YAML' do
+        YAML.expects(:load).with(@contents)
+        @flac2mp3.load_config
+      end
+      
+      it 'should store the config' do
+        @flac2mp3.load_config
+        @flac2mp3.config.should == @config
+      end
+      
+      it 'should convert string keys to symbols' do
+        File.stubs(:read).returns({ 'silent' => true, 'delete' => false }.to_yaml)
+        @flac2mp3.load_config
+        @flac2mp3.config.should == @config
+      end
+      
+      it 'should handle an empty file' do
+        File.stubs(:read).returns('')
+        @flac2mp3.load_config
+        @flac2mp3.config.should == {}
+      end
+      
+      it 'should not allow changes to the config' do
+        @flac2mp3.load_config
+        @flac2mp3.config[:some_key] = 'some value'
+        @flac2mp3.config.should == @config
+      end
+    end
+    
+    describe 'when no config file is found' do
+      before :each do
+        File.stubs(:read).raises(Errno::ENOENT)
+      end
+      
+      it 'should store an empty config' do
+        Flac2mp3.new.config.should == {}
+      end
+    end
   end
   
-  it 'should not tell the system commands to be silent by default' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename)
+  it 'should set options' do
+    @flac2mp3.should respond_to(:set_options)
   end
   
-  it 'should accept an option for encoding options' do
-    lambda { Flac2mp3.convert(@filename, :encoding => '--preset fast standard') }.should_not raise_error(ArgumentError)
+  describe 'setting options' do
+    before :each do
+      @options = { :silent => true, :delete => false }
+    end
+    
+    it 'should accept options' do
+      lambda { @flac2mp3.set_options(:silent => true) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require options' do
+      lambda { @flac2mp3.set_options }.should raise_error(ArgumentError)
+    end
+    
+    it 'should accept a hash of options' do
+      lambda { @flac2mp3.set_options(:silent => true) }.should_not raise_error(TypeError)
+    end
+    
+    it 'should require a hash of options' do
+      lambda { @flac2mp3.set_options('silent') }.should raise_error(TypeError)
+    end
+    
+    it 'should store the options' do
+      @flac2mp3.set_options(@options)
+      @flac2mp3.options.should == @options
+    end
+    
+    it 'should not allow changes to the options' do
+      @flac2mp3.set_options(@options.dup)
+      @flac2mp3.options[:some_key] = 'some value'
+      @flac2mp3.options.should == @options
+    end
+  end
+  
+  describe 'querying options' do
+    it 'should indicate the original file should be deleted when a true option is given' do
+      @flac2mp3.set_options(:delete => true)
+      @flac2mp3.delete?.should be(true)
+    end
+    
+    it 'should indicate the original file should not be deleted when a false option is given' do
+      @flac2mp3.set_options(:delete => false)
+      @flac2mp3.delete?.should be(false)
+    end
+    
+    it 'should indicate the original file should not be deleted when no option is given' do
+      @flac2mp3.set_options({})
+      @flac2mp3.delete?.should be(false)
+    end
+    
+    it 'should indicate the conversion should be silent when a true option is given' do
+      @flac2mp3.set_options(:silent => true)
+      @flac2mp3.silent?.should be(true)
+    end
+    
+    it 'should indicate the conversion should not be silent when a false option is given' do
+      @flac2mp3.set_options(:silent => false)
+      @flac2mp3.silent?.should be(false)
+    end
+    
+    it 'should indicate the conversion should not be silent when no option is given' do
+      @flac2mp3.set_options({})
+      @flac2mp3.silent?.should be(false)
+    end
+    
+    it 'should store the given encoding' do
+      encoding = '-VAWESOME'
+      @flac2mp3.set_options(:encoding => encoding)
+      @flac2mp3.encoding.should == encoding
+    end
+    
+    it 'should default the encoding to --preset standard' do
+      @flac2mp3.set_options({})
+      @flac2mp3.encoding.should == '--preset standard'
+    end
+    
+    it 'should use values from the configuration' do
+      config = {:silent => true}
+      File.stubs(:read).returns(config.to_yaml)
+      Flac2mp3.new.silent?.should be(true)
+    end
+    
+    it 'should override configuration values with options' do
+      config = {:silent => true}
+      File.stubs(:read).returns(config.to_yaml)
+      Flac2mp3.new(:silent => false).silent?.should be(false)
+    end
+    
+    it 'should combine configuration and option values' do
+      config = {:silent => true}
+      File.stubs(:read).returns(config.to_yaml)
+      flac2mp3 = Flac2mp3.new(:delete => true)
+      
+      flac2mp3.silent?.should be(true)
+      flac2mp3.delete?.should be(true)
+    end
   end
   
-  it 'should use the encoding options if given' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --vbr-new -V2 -h - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename, :encoding => '--vbr-new -V2 -h')
+  it 'should convert' do
+    @flac2mp3.should respond_to(:convert)
   end
   
-  it 'should default the encoding to --preset standard if no encoding options given' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename)
+  describe 'when converting' do
+    before :each do
+      @filename = 'test.flac'
+      @flac2mp3.stubs(:process_conversion)
+    end
+    
+    it 'should accept a filename' do
+      lambda { @flac2mp3.convert(@filename) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.convert }.should raise_error(ArgumentError)
+    end
+    
+    it 'should check if the filename belongs to a regular file' do
+      FileTest.expects(:file?).with(@filename).returns(true)
+      @flac2mp3.convert(@filename)
+    end
+    
+    describe 'when given a filename belonging to a regular file' do
+      before :each do
+        FileTest.stubs(:file?).returns(true)
+      end
+      
+      it 'should not error' do
+        lambda { @flac2mp3.convert(@filename) }.should_not raise_error(TypeError)
+      end
+            
+      it 'should process the conversion' do
+        @flac2mp3.expects(:process_conversion).with(@filename)
+        @flac2mp3.convert(@filename)
+      end
+      
+      it 'should check if the original file should be deleted' do
+        @flac2mp3.expects(:delete?)
+        @flac2mp3.convert(@filename)
+      end
+      
+      describe 'when the original file should be deleted' do
+        before :each do
+          @flac2mp3.stubs(:delete?).returns(true)
+        end
+        
+        it 'should delete the original file' do
+          File.expects(:delete).with(@filename)
+          @flac2mp3.convert(@filename)
+        end
+      end
+      
+      describe 'when the original file should not be deleted' do
+        before :each do
+          @flac2mp3.stubs(:delete?).returns(false)
+        end
+        
+        it 'should not delete the original file' do
+          File.expects(:delete).never
+          @flac2mp3.convert(@filename)
+        end
+      end
+    end
+    
+    describe 'when given a filename not belonging to a regular file' do
+      before :each do
+        FileTest.stubs(:file?).returns(false)
+      end
+      
+      it 'should error' do
+        lambda { @flac2mp3.convert(@filename) }.should raise_error(TypeError)
+      end
+    end
+  end
+  
+  it 'should process conversion' do
+    @flac2mp3.should respond_to(:process_conversion)
+  end
+  
+  describe 'when processing conversion' do
+    before :each do
+      @filename     = 'test.flac'
+      @out_filename = 'test.mp3'
+      @flac2mp3.stubs(:output_filename).returns(@out_filename)
+      @flac2mp3.stubs(:convert_data)
+      @flac2mp3.stubs(:convert_metadata)
+    end
+    
+    it 'should accept a filename' do
+      lambda { @flac2mp3.process_conversion(@filename) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.process_conversion }.should raise_error(ArgumentError)
+    end
+    
+    it 'get the output filename from the given filename' do
+      @flac2mp3.expects(:output_filename).with(@filename)
+      @flac2mp3.process_conversion(@filename)
+    end
+    
+    it 'should convert data' do
+      @flac2mp3.expects(:convert_data).with(@filename, @out_filename)
+      @flac2mp3.process_conversion(@filename)
+    end
+    
+    it 'should convert metadata' do
+      @flac2mp3.expects(:convert_metadata).with(@filename, @out_filename)
+      @flac2mp3.process_conversion(@filename)
+    end
   end
   
-  it 'should default the encoding to --preset standard if nil encoding options given' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename, :encoding => nil)
+  it 'should provide an output filename' do
+    @flac2mp3.should respond_to(:output_filename)
   end
   
-  it 'should default the encoding to --preset standard if blank encoding options given' do
-    Flac2mp3.expects(:system).with("flac --stdout --decode #{@filename.safequote} | lame --preset standard - #{@output_filename.safequote}")
-    Flac2mp3.convert(@filename, :encoding => ' ')
-  end
-end
+  describe 'providing an output filename' do
+    it 'should accept a filename' do
+      lambda { @flac2mp3.output_filename('blah.flac') }.should_not raise_error(ArgumentError)
+    end
 
-describe Flac2mp3, 'when converting and given a filename not belonging to a regular file' do
-  before :each do
-    @filename = 'blah.flac'
-    FileTest.stubs(:file?).with(@filename).returns(false)
-  end
-  
-  it 'should error' do
-    lambda { Flac2mp3.convert(@filename) }.should raise_error(TypeError)
-  end
-end
+    it 'should require a filename' do
+      lambda { @flac2mp3.output_filename }.should raise_error(ArgumentError)
+    end
 
-describe Flac2mp3, 'when getting an output filename' do
-  it 'should require a filename' do
-    lambda { Flac2mp3.output_filename }.should raise_error(ArgumentError)
-  end
-  
-  it 'should accept a filename' do
-    lambda { Flac2mp3.output_filename('blah.flac') }.should_not raise_error(ArgumentError)
-  end
-  
-  it 'should convert a .flac extension to an .mp3 extension' do
-    Flac2mp3.output_filename('blah.flac').should == 'blah.mp3'
-  end
-  
-  it 'should append an .mp3 extension if no .flac extension exists' do
-    Flac2mp3.output_filename('blah').should == 'blah.mp3'
-  end
-end
+    it 'should convert a .flac extension to an .mp3 extension' do
+      @flac2mp3.output_filename('blah.flac').should == 'blah.mp3'
+    end
 
-describe Flac2mp3, 'providing a mapping of tags' do
-  it 'should return a hash' do
-    Flac2mp3.tag_mapping.should be_kind_of(Hash)
-  end
-  
-  it "should map 'album' to 'album'" do
-    Flac2mp3.tag_mapping[:album].should == :album
-  end
-  
-  it "should map 'artist' to 'artist'" do
-    Flac2mp3.tag_mapping[:artist].should == :artist
-  end
-  
-  it "should map 'bpm' to 'TBPM'" do
-    Flac2mp3.tag_mapping[:bpm].should == :TBPM
-  end
-  
-  it "should map 'description' to 'comments'" do
-    Flac2mp3.tag_mapping[:description].should == :comments
-  end
-  
-  it "should map 'composer' to 'TCOM'" do
-    Flac2mp3.tag_mapping[:composer].should == :TCOM
-  end
-  
-  it "should map 'date' to 'year'" do
-    Flac2mp3.tag_mapping[:date].should == :year
+    it 'should append an .mp3 extension if no .flac extension exists' do
+      @flac2mp3.output_filename('blah').should == 'blah.mp3'
+    end
   end
   
-  it "should map 'genre' to 'genre_s'" do
-    Flac2mp3.tag_mapping[:genre].should == :genre_s
+  it 'should convert data' do
+    @flac2mp3.should respond_to(:convert_data)
   end
   
-  it "should map 'title' to 'title'" do
-    Flac2mp3.tag_mapping[:title].should == :title
-  end
-  
-  it "should map 'tracknumber' to 'TRCK'" do
-    Flac2mp3.tag_mapping[:tracknumber].should == :TRCK
+  describe 'when converting data' do
+    before :each do
+      @filename     = 'test.flac'
+      @out_filename = 'test.mp3'
+      @flac_command = 'flac command'
+      @mp3_command  = 'mp3 command'
+      @flac2mp3.stubs(:flac_command).returns(@flac_command)
+      @flac2mp3.stubs(:mp3_command).returns(@mp3_command)
+      @flac2mp3.stubs(:system)
+    end
+    
+    it 'should accept a filename and an output filename' do
+      lambda { @flac2mp3.convert_data(@filename, @out_filename) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require an output filename' do
+      lambda { @flac2mp3.convert_data(@filename) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.convert_data }.should raise_error(ArgumentError)
+    end
+    
+    it 'should call the flac command with the given filename' do
+      @flac2mp3.expects(:flac_command).with(@filename)
+      @flac2mp3.convert_data(@filename, @out_filename)
+    end
+    
+    it 'should call the mp3 command with the given output filename' do
+      @flac2mp3.expects(:mp3_command).with(@out_filename)
+      @flac2mp3.convert_data(@filename, @out_filename)
+    end
+    
+    it 'should shell out to the system with the flac and mp3 commands' do
+      @flac2mp3.expects(:system).with("#{@flac_command} | #{@mp3_command}")
+      @flac2mp3.convert_data(@filename, @out_filename)
+    end
   end
   
-  it "should map 'tracktotal' to 'TRCK'" do
-    Flac2mp3.tag_mapping[:tracktotal].should == :TRCK
+  it 'should provide a flac command' do
+    @flac2mp3.should respond_to(:flac_command)
   end
   
-  it "should map 'discnumber' to 'TPOS'" do
-    Flac2mp3.tag_mapping[:discnumber].should == :TPOS
+  describe 'when providing a flac command' do
+    before :each do
+      @filename = 'test.flac'
+      @safe_filename = 'safetest.safeflac'
+      @flac2mp3.stubs(:safequote).returns(@safe_filename)
+      @flac2mp3.stubs(:silent?)
+    end
+    
+    it 'should accept a filename' do
+      lambda { @flac2mp3.flac_command(@filename) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.flac_command }.should raise_error(ArgumentError)
+    end
+    
+    it 'should safequote the filename' do
+      @flac2mp3.expects(:safequote).with(@filename)
+      @flac2mp3.flac_command(@filename)
+    end
+    
+    it 'should check if the command should be silent' do
+      @flac2mp3.expects(:silent?)
+      @flac2mp3.flac_command(@filename)
+    end
+    
+    describe 'when the command should be silent' do
+      before :each do
+        @flac2mp3.stubs(:silent?).returns(true)
+      end
+      
+      it 'should provide a flac shell command that will be silent' do
+        @flac2mp3.flac_command(@filename).should == "flac --silent --stdout --decode #{@safe_filename}"
+      end
+    end
+    
+    describe 'when the command should not be silent' do
+      before :each do
+        @flac2mp3.stubs(:silent?).returns(false)
+      end
+      
+      it 'should provide a flac shell command that will not be silent' do
+        @flac2mp3.flac_command(@filename).should == "flac --stdout --decode #{@safe_filename}"
+      end
+    end
+  end
+  
+  it 'should provide an mp3 command' do
+    @flac2mp3.should respond_to(:mp3_command)
+  end
+  
+  describe 'when providing an mp3 command' do
+    before :each do
+      @filename = 'test.mp3'
+      @safe_filename = 'safetest.safemp3'
+      @flac2mp3.stubs(:safequote).returns(@safe_filename)
+      @flac2mp3.stubs(:silent?)
+      @encoding = '--VAWESOME'
+      @flac2mp3.stubs(:encoding).returns(@encoding)
+    end
+    
+    it 'should accept a filename' do
+      lambda { @flac2mp3.mp3_command(@filename) }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.mp3_command }.should raise_error(ArgumentError)
+    end
+    
+    it 'should safequote the filename' do
+      @flac2mp3.expects(:safequote).with(@filename)
+      @flac2mp3.mp3_command(@filename)
+    end
+    
+    it 'should check if the command should be silent' do
+      @flac2mp3.expects(:silent?)
+      @flac2mp3.mp3_command(@filename)
+    end
+    
+    it 'should check the encoding to use' do
+      @flac2mp3.expects(:encoding)
+      @flac2mp3.mp3_command(@filename)
+    end
+    
+    describe 'when the command should be silent' do
+      before :each do
+        @flac2mp3.stubs(:silent?).returns(true)
+      end
+      
+      it 'should provide an mp3 shell command that will be silent' do
+        @flac2mp3.mp3_command(@filename).should == "lame --silent #{@encoding} - #{@safe_filename}"
+      end
+    end
+    
+    describe 'when the command should not be silent' do
+      before :each do
+        @flac2mp3.stubs(:silent?).returns(false)
+      end
+      
+      it 'should provide an mp3 shell command that will not be silent' do
+        @flac2mp3.mp3_command(@filename).should == "lame #{@encoding} - #{@safe_filename}"
+      end
+    end
   end
   
-  it "should map 'disctotal' to 'TPOS'" do
-    Flac2mp3.tag_mapping[:disctotal].should == :TPOS
+  it 'should quote filenames safely' do
+    @flac2mp3.should respond_to(:safequote)
   end
   
-  it "should map 'compilation' to 'TCMP'" do
-    Flac2mp3.tag_mapping[:compilation].should == :TCMP
-  end
-end
+  describe 'when quoting a filename safely' do
+    it 'should accept a filename' do
+      lambda { @flac2mp3.safequote('test.flac') }.should_not raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.safequote }.should raise_error(ArgumentError)
+    end
+    
+    it 'should leave alphanumeric characters alone' do
+      @flac2mp3.safequote('abc_123').should == 'abc_123'
+    end
 
-describe Flac2mp3, 'when getting FLAC tag data' do
-  before :each do
-    @filename = 'blah.flac'
-    @tags = {}
-    @flacinfo = stub('flacinfo', :tags => @tags)
-    FlacInfo.stubs(:new).with(@filename).returns(@flacinfo)
+    it 'should escape non-alphanumeric characters' do
+      @flac2mp3.safequote(%q[a-b"c 12'3]).should == %q[a\-b\"c\ 12\'3]
+    end
   end
   
-  it 'should require a filename' do
-    lambda { Flac2mp3.flacdata }.should raise_error(ArgumentError)
+  it 'should convert metadata' do
+    @flac2mp3.should respond_to(:convert_metadata)
   end
   
-  it 'should accept a filename' do
-    lambda { Flac2mp3.flacdata('blah.flac') }.should_not raise_error(ArgumentError)
-  end
-  
-  it 'should create a FlacInfo object' do
-    FlacInfo.expects(:new).with(@filename).returns(@flacinfo)
-    Flac2mp3.flacdata(@filename)
-  end
-  
-  it 'should use the FlacInfo object tags' do
-    @flacinfo.expects(:tags).returns(@tags)
-    Flac2mp3.flacdata(@filename)
-  end
-  
-  it 'should return a hash of the tag data' do
-    @tags[:artist] = 'blah'
-    @tags[:blah] = 'boo'
-    @tags[:comment] = 'hey'
-    
-    data = Flac2mp3.flacdata(@filename)
-    data[:artist].should == 'blah'
-    data[:blah].should == 'boo'
-    data[:comment].should == 'hey'
-  end
-  
-  it 'should convert tags to symbols' do
-    @tags['artist'] = 'blah'
-    @tags['blah'] = 'boo'
-    @tags['comment'] = 'hey'
-    
-    data = Flac2mp3.flacdata(@filename)
-    data[:artist].should == 'blah'
-    data[:blah].should == 'boo'
-    data[:comment].should == 'hey'
-    
-    data.should_not have_key('artist')
-    data.should_not have_key('blah')
-    data.should_not have_key('comment')
-  end
-  
-  it 'should convert tags to lowercase' do
-    @tags['Artist'] = 'blah'
-    @tags[:BLAH] = 'boo'
-    @tags['cOmMeNt'] = 'hey'
-    
-    data = Flac2mp3.flacdata(@filename)
-    data[:artist].should == 'blah'
-    data[:blah].should == 'boo'
-    data[:comment].should == 'hey'
-    
-    data.should_not have_key('Artist')
-    data.should_not have_key(:BLAH)
-    data.should_not have_key('cOmMeNt')
-  end
-  
-  it 'should convert values consisting only of digits to actual numbers' do
-    @tags[:track] = '12'
+  describe 'when converting metadata' do
+    before :each do
+      @filename     = 'test.flac'
+      @out_filename = 'test.mp3'
+      @flacdata = stub('flacdata')
+      @flac2mp3.stubs(:get_flacdata).returns(@flacdata)
+      @flac2mp3.stubs(:set_mp3data)
+    end
     
-    data = Flac2mp3.flacdata(@filename)
-    data[:track].should == 12
-  end
-  
-  it 'should leave numeric titles as strings' do
-    @tags[:title] = '45'  # This was my first run-in with this problem, the opening track on Elvis Costello's /When I Was Cruel/
+    it 'should accept a filename and an output filename' do
+      lambda { @flac2mp3.convert_metadata(@filename, @out_filename) }.should_not raise_error(ArgumentError)
+    end
     
-    data = Flac2mp3.flacdata(@filename)
-    data[:title].should == '45'
-  end
-  
-  it 'should leave numeric titles as strings even if the title key is not a simple downcased symbol' do
-    @tags['TITLE'] = '45'
+    it 'should require an output filename' do
+      lambda { @flac2mp3.convert_metadata(@filename) }.should raise_error(ArgumentError)
+    end
     
-    data = Flac2mp3.flacdata(@filename)
-    data[:title].should == '45'
-  end
-  
-  it 'should leave numeric descriptions as strings' do
-    @tags[:description] = '1938'  # This was my first run-in with this problem, from the Boilermakers' version of "Minor Swing" where for the description all I had was the year of the original
+    it 'should require a filename' do
+      lambda { @flac2mp3.convert_metadata }.should raise_error(ArgumentError)
+    end
     
-    data = Flac2mp3.flacdata(@filename)
-    data[:description].should == '1938'
-  end
-  
-  it 'should leave numeric descriptions as strings even if the description key is not a simple downcased symbol' do
-    @tags['DESCRIPTION'] = '1938'
+    it 'should get the flac metadata' do
+      @flac2mp3.expects(:get_flacdata).with(@filename)
+      @flac2mp3.convert_metadata(@filename, @out_filename)
+    end
     
-    data = Flac2mp3.flacdata(@filename)
-    data[:description].should == '1938'
-  end
-end
-
-describe Flac2mp3, 'when setting MP3 tag data' do
-  before :each do
-    @filename = 'blah.mp3'
-    @tags = {}
-    @mp3tags = stub('mp3info tags')
-    @mp3tags2 = stub('mp3info tags 2')
-    @mp3info = stub('mp3info obj', :tag => @mp3tags, :tag2 => @mp3tags2)
-    Mp3Info.stubs(:open).with(@filename).yields(@mp3info)
-  end
-  
-  it 'should require a filename' do
-    lambda { Flac2mp3.mp3data }.should raise_error(ArgumentError)
-  end
-  
-  it 'should require tag data' do
-    lambda { Flac2mp3.mp3data('blah.mp3') }.should raise_error(ArgumentError)
+    it 'should set the mp3 metadata with the flac metadata' do
+      @flac2mp3.expects(:set_mp3data).with(@out_filename, @flacdata)
+      @flac2mp3.convert_metadata(@filename, @out_filename)
+    end
   end
   
-  it 'should accept a filename and tag data' do
-    lambda { Flac2mp3.mp3data('blah.mp3', 'tags') }.should_not raise_error(ArgumentError)
+  it 'should get flac metadata' do
+    @flac2mp3.should respond_to(:get_flacdata)
   end
   
-  it 'should require a hash of tags' do
-    lambda { Flac2mp3.mp3data('blah.mp3', 'blah') }.should raise_error(TypeError)
-  end
-  
-  it 'should accept a hash of tags' do
-    lambda { Flac2mp3.mp3data('blah.mp3', {}) }.should_not raise_error(TypeError)
-  end
-  
-  it 'should use an Mp3Info object' do
-    Mp3Info.expects(:open).with(@filename).yields(@mp3info)
-    Flac2mp3.mp3data(@filename, @tags)
-  end
-  
-  it 'should set tags in the Mp3Info object' do
-    @tags[:album] = 'blah'
-    @tags[:artist] = 'boo'
-    @tags[:genre] = 'bang'
+  describe 'when getting flac metadata' do
+    before :each do
+      @filename = 'test.flac'
+      @tags = {}
+      @flacinfo = stub('flacinfo', :tags => @tags)
+      FlacInfo.stubs(:new).returns(@flacinfo)
+    end
     
-    @mp3tags.expects(:album=).with(@tags[:album])
-    @mp3tags.expects(:artist=).with(@tags[:artist])
-    @mp3tags.expects(:genre_s=).with(@tags[:genre])
+    it 'should accept a filename' do
+      lambda { @flac2mp3.get_flacdata(@filename) }.should_not raise_error(ArgumentError)
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
-  end
-  
-  it 'should not set tags not given' do
-    @tags[:album] = 'blah'
-    @tags[:artist] = 'boo'
-    @tags[:genre] = 'bang'
+    it 'should require a filename' do
+      lambda { @flac2mp3.get_flacdata }.should raise_error(ArgumentError)
+    end
     
-    @mp3tags.stubs(:album=)
-    @mp3tags.stubs(:artist=)
-    @mp3tags.stubs(:genre_s=)
+    it 'should create a FlacInfo object' do
+      FlacInfo.expects(:new).with(@filename).returns(@flacinfo)
+      @flac2mp3.get_flacdata(@filename)
+    end
+
+    it 'should use the FlacInfo object tags' do
+      @flacinfo.expects(:tags).returns(@tags)
+      @flac2mp3.get_flacdata(@filename)
+    end
     
-    @mp3tags.expects(:comments=).never
-    @mp3tags.expects(:year=).never
+    it 'should return a hash of the tag data' do
+      @tags[:artist] = 'blah'
+      @tags[:blah] = 'boo'
+      @tags[:comment] = 'hey'
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:artist].should == 'blah'
+      data[:blah].should == 'boo'
+      data[:comment].should == 'hey'
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
-  end
-  
-  it 'should not set tags not known' do
-    @tags[:blah] = 'blah'
-    @tags[:bang] = 'bang'
+    it 'should convert tags to symbols' do
+      @tags['artist'] = 'blah'
+      @tags['blah'] = 'boo'
+      @tags['comment'] = 'hey'
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:artist].should == 'blah'
+      data[:blah].should == 'boo'
+      data[:comment].should == 'hey'
+
+      data.should_not have_key('artist')
+      data.should_not have_key('blah')
+      data.should_not have_key('comment')
+    end
     
-    @mp3tags.expects(:blah=).never
-    @mp3tags.expects(:bang=).never
+    it 'should convert tags to lowercase' do
+      @tags['Artist'] = 'blah'
+      @tags[:BLAH] = 'boo'
+      @tags['cOmMeNt'] = 'hey'
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:artist].should == 'blah'
+      data[:blah].should == 'boo'
+      data[:comment].should == 'hey'
+
+      data.should_not have_key('Artist')
+      data.should_not have_key(:BLAH)
+      data.should_not have_key('cOmMeNt')
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
-  end
-  
-  it 'should use tag2 for bpm' do
-    @tags[:bpm] = '5'
+    it 'should convert values consisting only of digits to actual numbers' do
+      @tags[:track] = '12'
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:track].should == 12
+    end
     
-    @mp3tags2.expects(:TBPM=).with(@tags[:bpm])
+    it 'should leave numeric values as numbers' do
+      @tags[:track] = 12
+      
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:track].should == 12
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
+    it 'should leave numeric titles as strings' do
+      @tags[:title] = '45'  # This was my first run-in with this problem, the opening track on Elvis Costello's /When I Was Cruel/
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:title].should == '45'
+    end
+
+    it 'should leave numeric titles as strings even if the title key is not a simple downcased symbol' do
+      @tags['TITLE'] = '45'
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:title].should == '45'
+    end
+
+    it 'should leave numeric descriptions as strings' do
+      @tags[:description] = '1938'  # This was my first run-in with this problem, from the Boilermakers' version of "Minor Swing" where for the description all I had was the year of the original
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:description].should == '1938'
+    end
+
+    it 'should leave numeric descriptions as strings even if the description key is not a simple downcased symbol' do
+      @tags['DESCRIPTION'] = '1938'
+
+      data = @flac2mp3.get_flacdata(@filename)
+      data[:description].should == '1938'
+    end
   end
   
-  it 'should use tag2 for composer' do
-    @tags[:composer] = 'Il Maestro'
-    
-    @mp3tags2.expects(:TCOM=).with(@tags[:composer])
-    
-    Flac2mp3.mp3data(@filename, @tags)
+  it 'should set mp3 metadata' do
+    @flac2mp3.should respond_to(:set_mp3data)
   end
   
-  it 'should use tag2 for compilation' do
-    @tags[:compilation] = '1'
+  describe 'when setting mp3 metadata' do
+    before :each do
+      @filename = 'test.mp3'
+      @tags = {}
+      @mp3tags  = stub('mp3info tags')
+      @mp3tags2 = stub('mp3info tags 2')
+      @mp3info  = stub('mp3info obj', :tag => @mp3tags, :tag2 => @mp3tags2)
+      Mp3Info.stubs(:open).yields(@mp3info)
+    end
     
-    @mp3tags2.expects(:TCMP=).with(@tags[:compilation])
+    it 'should accept a filename and tag data' do
+      lambda { @flac2mp3.set_mp3data(@filename, 'tag data') }.should_not raise_error(ArgumentError)
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
-  end
-  
-  it 'should set tag2 track to be a combination of tracknumber and tracktotal' do
-    @tags[:tracknumber] = 4
-    @tags[:tracktotal]  = 15
+    it 'should require tag data' do
+      lambda { @flac2mp3.set_mp3data(@filename) }.should raise_error(ArgumentError)
+    end
+    
+    it 'should require a filename' do
+      lambda { @flac2mp3.set_mp3data }.should raise_error(ArgumentError)
+    end
+    
+    it 'should accept a hash of tag data' do
+      lambda { @flac2mp3.set_mp3data(@filename, 'tag data') }.should raise_error(TypeError)
+    end
+    
+    it 'should require a hash of tag data' do
+      lambda { @flac2mp3.set_mp3data(@filename, {}) }.should_not raise_error(TypeError)
+    end
     
-    @mp3tags2.expects(:TRCK=).with('4/15')
+    it 'should use an Mp3Info object' do
+      Mp3Info.expects(:open).with(@filename)
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
+    it 'should set tags in the Mp3Info object' do
+      @tags[:album] = 'blah'
+      @tags[:artist] = 'boo'
+      @tags[:genre] = 'bang'
+
+      @mp3tags.expects(:album=).with(@tags[:album])
+      @mp3tags.expects(:artist=).with(@tags[:artist])
+      @mp3tags.expects(:genre_s=).with(@tags[:genre])
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it 'should not set tags not given' do
+      @tags[:album] = 'blah'
+      @tags[:artist] = 'boo'
+      @tags[:genre] = 'bang'
+
+      @mp3tags.stubs(:album=)
+      @mp3tags.stubs(:artist=)
+      @mp3tags.stubs(:genre_s=)
+
+      @mp3tags.expects(:comments=).never
+      @mp3tags.expects(:year=).never
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it 'should not set tags not known' do
+      @tags[:blah] = 'blah'
+      @tags[:bang] = 'bang'
+
+      @mp3tags.expects(:blah=).never
+      @mp3tags.expects(:bang=).never
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it 'should use tag2 for bpm' do
+      @tags[:bpm] = '5'
+
+      @mp3tags2.expects(:TBPM=).with(@tags[:bpm])
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it 'should use tag2 for composer' do
+      @tags[:composer] = 'Il Maestro'
+
+      @mp3tags2.expects(:TCOM=).with(@tags[:composer])
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it 'should use tag2 for compilation' do
+      @tags[:compilation] = '1'
+
+      @mp3tags2.expects(:TCMP=).with(@tags[:compilation])
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it 'should set tag2 track to be a combination of tracknumber and tracktotal' do
+      @tags[:tracknumber] = 4
+      @tags[:tracktotal]  = 15
+
+      @mp3tags2.expects(:TRCK=).with('4/15')
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
+
+    it "should set tag2 'pos' to be a combination of discnumber and disctotal" do
+      @tags[:discnumber] = 1
+      @tags[:disctotal]  = 2
+
+      @mp3tags2.expects(:TPOS=).with('1/2')
+
+      @flac2mp3.set_mp3data(@filename, @tags)
+    end
   end
   
-  it "should set tag2 'pos' to be a combination of discnumber and disctotal" do
-    @tags[:discnumber] = 1
-    @tags[:disctotal]  = 2
+  describe 'as a class' do
+    it 'should convert' do
+      Flac2mp3.should respond_to(:convert)
+    end
     
-    @mp3tags2.expects(:TPOS=).with('1/2')
+    describe 'when converting' do
+      before :each do
+        @filename = 'test.flac'
+        @options  = { :silent => true, :delete => false, :fish => :flat }
+        @flac2mp3 = stub('flac2mp3 object', :convert => nil)
+        Flac2mp3.stubs(:new).returns(@flac2mp3)
+      end
+      
+      it 'should accept a filename and a hash of options' do
+        lambda { Flac2mp3.convert(@filename, @options) }.should_not raise_error(ArgumentError)
+      end
+      
+      it 'should not require options' do
+        lambda { Flac2mp3.convert(@filename) }.should_not raise_error(ArgumentError)
+      end
+      
+      it 'should require a filename' do
+        lambda { Flac2mp3.convert }.should raise_error(ArgumentError)
+      end
+      
+      it 'should instantiate a new Flac2mp3 object' do
+        Flac2mp3.expects(:new).returns(@flac2mp3)
+        Flac2mp3.convert(@filename)
+      end
+      
+      it 'should pass the options when instantiating the Flac2mp3 object' do
+        Flac2mp3.expects(:new).with(@options).returns(@flac2mp3)
+        Flac2mp3.convert(@filename, @options)
+      end
+      
+      it 'should use the Flac2mp3 object to convert the given file' do
+        @flac2mp3.expects(:convert).with(@filename)
+        Flac2mp3.convert(@filename)
+      end
+    end
     
-    Flac2mp3.mp3data(@filename, @tags)
+    it 'should provide a tag mapping' do
+      Flac2mp3.should respond_to(:tag_mapping)
+    end
+    
+    describe 'providing a tag mapping' do
+      it 'should return a hash' do
+        Flac2mp3.tag_mapping.should be_kind_of(Hash)
+      end
+
+      it "should map 'album' to 'album'" do
+        Flac2mp3.tag_mapping[:album].should == :album
+      end
+
+      it "should map 'artist' to 'artist'" do
+        Flac2mp3.tag_mapping[:artist].should == :artist
+      end
+
+      it "should map 'bpm' to 'TBPM'" do
+        Flac2mp3.tag_mapping[:bpm].should == :TBPM
+      end
+
+      it "should map 'description' to 'comments'" do
+        Flac2mp3.tag_mapping[:description].should == :comments
+      end
+
+      it "should map 'composer' to 'TCOM'" do
+        Flac2mp3.tag_mapping[:composer].should == :TCOM
+      end
+
+      it "should map 'date' to 'year'" do
+        Flac2mp3.tag_mapping[:date].should == :year
+      end
+
+      it "should map 'genre' to 'genre_s'" do
+        Flac2mp3.tag_mapping[:genre].should == :genre_s
+      end
+
+      it "should map 'title' to 'title'" do
+        Flac2mp3.tag_mapping[:title].should == :title
+      end
+
+      it "should map 'tracknumber' to 'TRCK'" do
+        Flac2mp3.tag_mapping[:tracknumber].should == :TRCK
+      end
+
+      it "should map 'tracktotal' to 'TRCK'" do
+        Flac2mp3.tag_mapping[:tracktotal].should == :TRCK
+      end
+
+      it "should map 'discnumber' to 'TPOS'" do
+        Flac2mp3.tag_mapping[:discnumber].should == :TPOS
+      end
+
+      it "should map 'disctotal' to 'TPOS'" do
+        Flac2mp3.tag_mapping[:disctotal].should == :TPOS
+      end
+
+      it "should map 'compilation' to 'TCMP'" do
+        Flac2mp3.tag_mapping[:compilation].should == :TCMP
+      end
+    end
   end
 end