rutaci 0.1.0

data/lib/rutaci/application.rb

@@ -0,0 +1,232 @@
+# This file is part of rutaci, see the README for more information
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'optparse'
+require 'ostruct'
+
+module Rutaci
+  class Application
+    attr_reader :options
+    
+    def initialize
+      @options = OpenStruct.new(
+      # default values
+      :command => :get,
+      :fields => [:track, :title, :artist, :album, :year, :genre, :comment], # FIXME: patch tagalib to provilde a list of all available fields
+      :destination => ".",
+      :files => []
+      )
+      #puts "default options: #{@options}"
+    end
+    
+    def parse_options
+      # The general form of the parameters to parse is:
+      # "<general options> <command> <field otions> <filenames...>"
+      # Since GetoptLong and ParseOptions don't know handle this structure (options os a
+      # command in the middle) but I don't want to do all by hand, ARGV is split  at the command
+      # position in two, the command is analysed manualy and the two parts are passed to GetoptLong
+      # seperately.
+      command_position = (ARGV.index('set') or ARGV.index('get') or ARGV.index('rename'))
+      if command_position
+        field_options = ARGV.slice! command_position..ARGV.length # splitt ARGV at the command_position
+        @options.fields = nil # don't use the default files when a command is given
+        @options.command = field_options.shift.to_sym
+      else
+        field_options = []
+      end
+      
+      get_parser = OptionParser.new do |opts|
+        opts.banner = "fields to use with the get command (or set with --format/--muscibrains):"
+        opts.on("--title", "-t", "get the title") do 
+          @options.fields ||= Array.new
+          @options.fields.push :title
+        end
+        opts.on("--artist", "-i", "get the artist") do 
+          @options.fields ||= Array.new
+          @options.fields.push :artist
+        end
+        opts.on("--album", "-a", "get the album") do 
+          @options.fields ||= Array.new
+          @options.fields.push :album
+        end
+        opts.on("--track", "-n", "get the tracknumer") do 
+          @options.fields ||= Array.new
+          @options.fields.push :track
+        end
+        opts.on("--year", "-y", "get the year") do 
+          @options.fields ||= Array.new
+          @options.fields.push :year
+        end
+        opts.on("--genre", "-g", "get the genre") do
+          @options.fields ||= Array.new
+          @options.fields.push :genre
+        end
+        opts.on("--comment", "-c", "get the comment") do 
+          @options.fields ||= Array.new
+          @options.fields.push :comment
+        end
+      end # get_parser
+      
+      set_parser = OptionParser.new do |opts|
+        opts.banner = "fields to use with the set command:"
+        opts.on("--title TITLE", "-t", "set the title to TITLE") do |title|
+          @options.fields ||= Hash.new
+          @options.fields[:title] = title
+        end
+        opts.on("--artist ARTIST", "-i", "set the artist to ARTIST") do |artist|
+          @options.fields ||= Hash.new
+          @options.fields[:artist] = artist
+        end
+        opts.on("--album ALBUM", "-a", "set the album to ALBUM") do |album|
+          @options.fields ||= Hash.new
+          @options.fields[:album] = album
+        end
+        opts.on("--track N", "-n", "set the tracknumer to N") do |track|
+          @options.fields ||= Hash.new
+          @options.fields[:track] = track
+        end
+        opts.on("--year YEAR", "-y", "set the year to YEAR") do |year|
+          @options.fields ||= Hash.new
+          @options.fields[:year] = year
+        end
+        opts.on("--genre GENRE", "-g", "set the genre to GENRE") do |genre|
+          @options.fields ||= Hash.new
+          @options.fields[:genre] = genre
+        end
+        opts.on("--comment COMMENT", "-c", "set the comment to COMMENT") do |comment|
+          @options.fields ||= Hash.new
+          @options.fields[:comment] = comment
+        end
+
+        opts.separator ""
+        opts.separator "Note: When using the --format option, the set parameters take no argument"
+        opts.separator "      (like when used with get) The value is extracted via FORMAT from the"
+        opts.separator "      the path/filename. Without parameters, every field appearing in FORMAT"
+        opts.separator "      is used."
+#        opts.separator ""
+#        opts.separator "Note: When using the --musicbrainz option, the set parameters take no argument"
+#        opts.separator "      (like when used with get) The value are looked up at musicbrains.org"
+#        opts.separator "      using an acoustic fingerprint of the music file. Without parameters,"
+#        opts.separator "      every field provided by musicbrains.org is used."
+      end # set_parser
+
+      general_parser = OptionParser.new do |opts|
+        opts.banner = "general options:"
+        opts.on("--dry-run", "-d", "Don't really execute the command, just show what would happen",
+                "Has no effect with the get command") do
+          @options.dry_run = true
+        end
+        opts.on("--interactive", "-i", "Give the user the chance to edit any value/filename",
+                "Has no effect with the get command; requires GNU readline") do
+          @options.interactive = true
+        end
+        opts.on("--keep-empty-fields", "-k", "Keep empty fields instead of removeing them when",
+                "displaying or setting an empty value.",
+                "Don't affects the rename command, we will never set an empty filename") do
+          @options.keep_empty_fields = true
+        end
+        opts.on("--format FORMAT", "-f", "Use FORMAT to parse input or format output and filenames",
+                "Used with a get command, it will format the output",
+                "Used with a set command, it's the pattern for parsing the filename",
+                "Used with a rename command, it will give the new filename",
+                "An example is '%n - %t.mp3', see the manual for details") do |format|
+          @options.format = format
+        end
+#        opts.on("--musicbrainz", "-m", "use musicbrainz.org to find the right taggs for you music",
+#                "This is just an other source for the metadata") do
+#          @options.musicbrainz = true
+#        end
+
+        opts.separator ""
+        opts.separator "options to use with the get command:"
+        opts.on("--values-only", "-o", "Print out only the values themselfs (one per line)",
+                "Fieldnames and the normaly displayed filename are ommited.") do
+          @options.values_only = true
+        end
+
+        opts.separator ""
+        opts.separator "options to use with the rename command:"
+        opts.on("--destination DESTINATION", "-D", "Set the destination directory to DESTINATION",
+                "default '#{@options.destination}'") do |destination|
+          @options.destination = destination
+        end
+
+        opts.separator ""
+        opts.separator "generic options:"
+
+        opts.on("--help", "-h", "-?", "Shows this message and quit") do
+          puts "rutaci is a cli tool for manipulating music file's metadata"
+          puts
+          puts "Useage: #{$0} [<options>] [get [<fields>]] <filenames...>"
+          puts "        #{$0} [<options>] set <fields and values> <filenames...>"
+          puts "        #{$0} [<options>] --format FORMAT rename <filenames...>"
+          puts
+          puts general_parser
+          puts
+          puts get_parser
+          puts
+          puts set_parser
+          exit
+        end
+        opts.on("--version", "Shows version and exit") do
+          puts VERSION_STRING
+          exit
+        end
+      end #general_parser
+    
+      general_parser.parse! ARGV
+      @options.files.push *ARGV # the remaining args are filenames, when no command is given
+
+      if @options.command == :get or (@options.command == :set and (@options.format or @options.musicbrainz))
+        # note: when a format is given, we parse get-style,
+        # even with set since the values come from the filename or muscibrains (not the command line)
+        get_parser.parse! field_options
+      else
+        set_parser.parse! field_options if @options.command == :set
+      end
+      @options.files.push *field_options # the remaining args are filenames
+
+      if @options.files.empty?
+        puts "sorry, I need at least one filename to work with!"
+        puts "try the manpage or #{$0} --help"
+        exit 1
+      end
+
+      if @options.command == :rename and not @options.format
+        puts "sorry, I need a format for the rename command!"
+        puts "try the manpage or #{$0} --help"
+        exit 1
+      end
+    end
+    
+    def run
+      parse_options
+      executor = case @options.command
+                 when :get
+                   require 'rutaci/getter'
+                   Getter.new @options
+                 when :set
+                   require 'rutaci/setter'
+                   Setter.new @options
+                 when :rename
+                   require 'rutaci/renamer'
+                   Renamer.new @options
+                 end
+      executor.run @options.files
+    end
+  end # class Application
+end # module Rutaci

data/lib/rutaci/filename_source.rb

@@ -0,0 +1,59 @@
+# rutaci is a ruby tagger with a command line interface
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'rutaci/formater'
+
+module Rutaci
+  # This class collects the taginfo from various sources.
+  class FilenameSource < Source
+    attr_reader :info
+    def initialize(filename, options)
+      raise ArgumentError, "options.format doesn't exist" unless options.format
+      @filename = File.expand_path filename # we may need the full path
+      @wanted_fields = options.fields # if this is not nil it should contain a positive-list of fileds
+      @regexp, @fieldlist = self.create_regexp options.format
+      @info = self.get_fields
+    end
+
+    def get_fields
+      match = @regexp.match @filename
+      return nil unless match
+      groups = match.to_a
+      groups.shift # get rid of the first field, since it's the whole match (we need only the groups)
+      info = Hash.new
+      @fieldlist.each_with_index do |field, index|
+        next if @wanted_fields and not @wanted_fields.include? field
+        info[field] = groups[index]
+      end
+      return info
+    end
+
+    def create_regexp(format)
+      str = String.new
+      fieldlist = Array.new
+      Formater.tokenize format do |token, is_placeholder|
+        if is_placeholder
+          str += "([^#{File::SEPARATOR}]*)" # match any char appart File::SEPARATOR into a group
+          fieldlist.push Formater::PLACEHOLDERS[token]
+        else
+          str += Regexp.escape token
+        end
+      end # tokenize
+      return Regexp.new(str + "$"), fieldlist
+    end
+  end # class FilenameSource
+end # module Rutaci

data/lib/rutaci/formater.rb

@@ -0,0 +1,81 @@
+# rutaci is a ruby tagger with a command line interface
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+module Rutaci
+  class Formater
+    # translation of format string tokens to info field names
+    PLACEHOLDERS = {
+      "t" => :title,
+      "i" => :artist,
+      "a" => :album,
+      "n" => :track,
+      "y" => :year,
+      "g" => :genre,
+      "c" => :comment
+    }
+
+    # performs a lexical analysis for strings like "%n - %t"
+    # and yields every token found. A token may be a normal char or a placeholder
+    # the argumetns passed to the block is the current token and if it's a placeholder or not
+    # Note that a placeholder token is passed without the leading '%'
+    # A placeholder token always ends with a lower case letter and may have some leading flags
+    # A flag is everything which isn't a lower case letter or the '%' sign
+    def self.tokenize(format)
+      raise ArgumentError, "need a block to handle the tokens" unless block_given?
+      is_placeholder = false # true if the previous char was a '%'
+      multichar_token = "" # here the chars for multichar tokens are acculumated before the comleate token is send out
+      format.each_byte do |c|
+        if is_placeholder
+          if c == ?%
+            yield c.chr, false # '%%' is not the placeholder '%' but a normal '%'
+          else
+            # look out for multichar tokens
+            multichar_token += c.chr
+            if /[a-z]/.match multichar_token
+              yield multichar_token, true
+              multichar_token = ""
+            else
+              next
+            end
+          end
+          is_placeholder = false
+        else
+          if c == ?%
+            is_placeholder = true
+          else
+            yield c.chr, false
+          end
+        end # is_placeholder?
+      end # each_byte
+    end # def self.tokenize
+
+    def self.string_for_token(token, info)
+      placeholder = token[-1].chr # the placeholder is the last letter
+      flags = token[0..-2] # the rest are flags
+      value = info[PLACEHOLDERS[placeholder]]
+      case value
+      when Fixnum, Bignum
+        value = sprintf "%#{flags}d", value
+      when String
+        value = sprintf "%#{flags}s", value
+      else # for other classes no flags are defined (yet ;-)
+        value = value.to_s
+      end
+      return value
+    end
+  end # class Formater
+end # module Rutaci

data/lib/rutaci/getter.rb

@@ -0,0 +1,79 @@
+# rutaci is a ruby tagger with a command line interface
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'rutaci/source'
+
+module Rutaci
+  # gets info from a source and display it
+  # it is a command executor, so it has tp provide an initializer which takes the options
+  # and a method 'run' which takes an array of filenames
+  class Getter
+    def initialize(options)
+      @options = options
+      if @options.format
+        require 'rutaci/formater'
+        # make sure we get all fields nessesary for the expanding the format string
+        @options.fields = Array.new
+        Formater::PLACEHOLDERS.each_pair do |token, field|
+          @options.fields.push field if /%[^a-z]*#{token}/.match @options.format
+        end
+      end
+    end
+
+    # invoke this executor for an array of filenames
+    def run(files)
+      output = Array.new
+      files.each do |file|
+        output.push self.get(file) + "\n"
+      end
+      puts output.join("\n") # a blank line between the items
+    end
+
+    # get and return the actual info for a specific file
+    def get(file)
+      source = Source.factory file, @options
+      # use the format string if available
+      return self.format(source.info, @options.format) if @options.format
+      # esle create the standard format
+      output = Array.new
+      output.push "Filename: #{file}" unless @options.values_only
+      source.info.each_pair do |key, value|
+        value = nil if value == 0 # HACK: rtaglib seems to return non-existing numeric values as 0 instead of nil
+        value = value.to_s
+        next if value.empty? unless @options.keep_empty_fields
+        element = String.new
+        element += key.to_s.capitalize + ": " unless @options.values_only
+        element += value
+        output.push element
+      end
+      return output.join("\n")
+    end
+
+    # return the info formated, format may be something like "%n - %t"
+    def format(info, format)
+      str = String.new
+      Formater.tokenize format do |token, is_placeholder|
+        if is_placeholder
+          str += Formater.string_for_token token, info
+        else
+          str += token
+        end
+      end
+      return str
+    end
+  end # class Getter
+end # module Rutaci

data/lib/rutaci/interaction.rb

@@ -0,0 +1,57 @@
+# rutaci is a ruby tagger with a command line interface
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'readline'
+
+module Rutaci
+  # writes info from a source into the files
+  # it is a command executor, so it has tp provide an initializer which takes the options
+  # and a method 'run' which takes an array of filenames
+  module Interaction
+    def self.print_lineedit_help
+      puts "Use <TAB> on an empty line will insert the default value, else completion is done"
+      puts "Use <Ctrl-C> to discard your changes and use the default value"
+    end
+
+    # use GNU readline for the interactive input
+    def self.lineedit(promt, default_value, completion_strings = [])
+      # FIXME: display the default value and don't wait for the user to press TAB
+      # it seems that this requires hacking the readline module
+      add_to_history = true
+      Readline.completion_proc = Proc.new do |current_line|
+        if current_line.empty?
+          # if we haven't typed anything, the completion is the default value
+          candidates = [default_value]
+        else
+          # completion: look which completion string starts with what we've typed
+          # TODO: don't search for the whole current_line, but also substrings.
+          # example: current_file = "some foob" and completion_strings = ["foobar"]
+          candidates = completion_strings.select {|str| str.index(current_line) == 0}
+        end
+        candidates
+      end
+      Readline.completion_append_character = "" # per default a space will be append
+      begin
+        value = Readline.readline promt, add_to_history
+      rescue Interrupt
+        puts # just to have the linebreak
+        value = default_value
+      end
+      return value
+    end
+  end # module Interaction
+end # module Rutaci

data/lib/rutaci/renamer.rb

@@ -0,0 +1,63 @@
+# rutaci is a ruby tagger with a command line interface
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'ftools'
+
+require 'rutaci/getter'
+
+module Rutaci
+  # renames files using a format string, uses the Getter
+  # it is a command executor, so it has tp provide an initializer which takes the options
+  # and a method 'run' which takes an array of filenames
+  class Renamer
+    def initialize(options)
+      @options = options
+      @getter = Getter.new options
+      if @options.interactive
+        require 'rutaci/interaction'
+        puts "in interactive mode you can edit the new filename before renaming"
+        Interaction::print_lineedit_help
+        puts
+      end
+    end
+
+    # invoke this executor for an array of filenames
+    def run(files)
+      files.each do |file|
+        self.rename(file)
+      end
+    end
+
+    # get and return the actual info for a specific file
+    def rename(file)
+      puts "current file: \"#{file}\""
+      new_name = File.join @options.destination, @getter.get(file).strip
+      new_name = Interaction::lineedit "  new name: ", new_name if @options.interactive
+      if new_name.empty?
+        puts "  can't rename to an empty filename!"
+        return
+      end
+      if @options.dry_run
+        puts "  renaming to: \"#{new_name}\" (if we where not doing a dry-run)"
+      else
+        puts "  renaming to: \"#{new_name}\""
+        File.makedirs File.dirname(new_name) # create missing directories
+        File.move file, new_name
+      end
+    end
+  end # class Renamer
+end # module Rutaci

data/lib/rutaci/setter.rb

@@ -0,0 +1,71 @@
+# rutaci is a ruby tagger with a command line interface
+# Copyright (C) 2008 Jonas Bähr <jonas.baehr@fs.ei.tum.de>
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'rtaglib'
+
+require 'rutaci/source'
+
+module Rutaci
+  # writes info from a source into the files
+  # it is a command executor, so it has tp provide an initializer which takes the options
+  # and a method 'run' which takes an array of filenames
+  class Setter
+    def initialize(options)
+      @options = options
+      if @options.interactive
+        require 'rutaci/interaction'
+        puts "Using interactive mode you can specify the value for the current field."
+        Interaction::print_lineedit_help
+        puts
+      end
+    end
+
+    # invoke this executor for an array of filenames
+    def run(files)
+      files.each do |file|
+        if @options.dry_run
+          puts "dry run for #{file}:"
+        else
+          puts "processing #{file}:"
+        end
+        self.set(file)
+        puts unless file == files.last # seperator between the files
+      end
+    end
+
+    # gets writes the actual info into a specific file
+    def set(file)
+      source = Source.factory file, @options
+      tagfile = TagFile::File.new file
+      source.info.each_pair do |key, value|
+        value = Interaction::lineedit "  #{key.to_s.capitalize}: ", value if @options.interactive
+        if value.empty? and not @options.keep_empty_fields
+          puts "  ignoring empty value"
+          next
+        end
+        puts "  setting #{key} to \"#{value}\""
+        tagfile.send key.to_s+"=", value unless @options.dry_run
+      end
+      if @options.dry_run
+        puts "  writing the metadata (if it was not a dry run ;-)"
+      else
+        puts "  writing the metadata"
+        tagfile.save
+      end
+    end
+  end # class Getter
+end # module Rutaci