tagomatic 0.0.2

data/lib/tagomatic/options.rb

@@ -0,0 +1,21 @@
+require 'optparse'
+
+module Tagomatic
+
+  class Options < Hash
+
+    def initialize
+      self[:cleartags] = false
+      self[:files] = []
+      self[:formats] = []
+      self[:errorstops] = false
+      self[:guess] = false
+      self[:list] = false
+      self[:recurse] = false
+      self[:showtags] = false
+      self[:verbose] = false
+    end
+
+  end
+
+end

data/lib/tagomatic/options_parser.rb

@@ -0,0 +1,90 @@
+require 'optparse'
+
+module Tagomatic
+
+  class OptionsParser
+
+    def initialize(options)
+      @options = options
+      @parser = create_parser
+    end
+
+    def parse!(arguments)
+      @parser.parse!(arguments)
+      @options[:files].concat(arguments)
+    end
+
+    def show_help
+      @parser.to_s
+    end
+
+    protected
+
+    def create_parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options..] files.."
+
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        opts.on("-b", "--album [ALBUM]", "Set this album name.") do |album|
+          @options[:album] = album
+        end
+        opts.on("-a", "--artist [ARTIST]", "Set this artist name.") do |artist|
+          @options[:artist] = artist
+        end
+        opts.on("-d", "--discnum [DISCNUM]", "Set disc number of a disc set. Will be appended to album.") do |discnum|
+          @options[:discnum] = discnum
+        end
+        opts.on("-g", "--genre [GENRE]", "Set this genre.") do |genre|
+          @options[:genre] = genre
+        end
+        opts.on("-t", "--title [TITLE]", "Set this title.") do |title|
+          @options[:title] = title
+        end
+        opts.on("-n", "--tracknum [TRACKNUMBER]", "Set this number.") do |tracknum|
+          @options[:tracknum] = tracknum
+        end
+        opts.on("-y", "--year [YEAR]", "Set this year/date.") do |year|
+          @options[:year] = year
+        end
+
+        opts.on("-f", "--format [FORMAT]", "Try applying this format string to determine tags. Multiple occurrences allowed.") do |format|
+          @options[:formats] << format
+        end
+
+        opts.on("-k", "--cleartags", "Clear any existing v1 and v2 tags.") do |cleartags|
+          @options[:cleartags ]= cleartags
+        end
+        opts.on("-e", "--errorstops", "Stop execution if an error occurs.") do |errorstops|
+          @options[:errorstops ]= errorstops
+        end
+        opts.on("-s", "--guess", "Use format guessing. Can be combined with --format.") do |guess|
+          @options[:guess] = guess
+        end
+        opts.on("-l", "--list", "List available formats for guessing.") do |list|
+          @options[:list] = list
+        end
+        opts.on("-r", "--recurse", "Scan for files recursively.") do |recurse|
+          @options[:recurse] = recurse
+        end
+        opts.on("-w", "--showtags", "Show the resulting tags.") do |showtags|
+          @options[:showtags] = showtags
+        end
+
+        opts.separator ""
+        opts.separator "Common options:"
+
+        opts.on("-v", "--verbose", "Run verbosely.") do |verbose|
+          @options[:verbose] = verbose
+        end
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+    end
+
+  end
+
+end

data/lib/tagomatic/scanner.rb

@@ -0,0 +1,101 @@
+require 'tagomatic/local_options_matcher'
+
+module Tagomatic
+
+  class Scanner
+
+    def initialize(options, parser, local_options_matcher_factory, logger)
+      @options = options
+      @parser = parser
+      @local_options_matcher_factory = local_options_matcher_factory
+      @logger = logger
+      @options_stack = []
+    end
+
+    def process!(path_prefix, file_or_folder, &block)
+      @file_path = path_prefix.nil? ? file_or_folder : File.join(path_prefix, file_or_folder)
+      @logger.verbose "processing #{@file_path}"
+      if is_taggable_file?
+        yield @file_path
+      elsif is_scannable?
+        enter_scannable_folder(&block)
+      end
+    end
+
+    protected
+
+    def is_taggable_file?
+      File.file?(@file_path) and File.extname(@file_path).downcase == '.mp3'
+    end
+
+    def is_scannable?
+      @options[:recurse] and File.directory?(@file_path)
+    end
+
+    def enter_scannable_folder(&block)
+      save_current_options
+      apply_local_options if has_local_options?
+      do_scan_folder(@file_path, &block)
+      pop_local_options
+    end
+
+    def save_current_options
+      cloned = @options.clone
+      cloned[:formats] = @options[:formats].clone
+      @options_stack << cloned
+    end
+
+    def has_local_options?
+      File.exist?(determine_local_config_file_path)
+    end
+
+    def determine_local_config_file_path
+      File.join(@file_path, LOCAL_CONFIG_FILE_NAME)
+    end
+
+    def apply_local_options
+      local_options = read_local_options
+      @parser.parse!(local_options)
+    end
+
+    def read_local_options
+      local_options = []
+      matcher = @local_options_matcher_factory.create_local_options_matcher
+      lines = File.readlines(determine_local_config_file_path)
+      lines.each do |line|
+        matcher.process!(line)
+        local_options.concat matcher.to_argv
+      end
+      local_options
+    end
+
+    def do_scan_folder(folder_path, &block)
+      @logger.verbose "scanning #{folder_path}"
+      entries = Dir.entries(folder_path)
+
+      local_formats = entries.select { |entry| entry.starts_with?('.format=') }
+      apply_local_formats(local_formats)
+
+      entries.each do |entry|
+        next if entry == '.' or entry == '..' or entry.starts_with?('.format=')
+        process!(folder_path, entry, &block)
+      end
+    end
+
+    def apply_local_formats(list_of_local_format_file_names)
+      local_formats = list_of_local_format_file_names.map do |file_name|
+        format = file_name.sub('.format=', '')
+        format.gsub!('|', '/')
+      end
+      @options[:formats].concat(local_formats)
+    end
+
+    def pop_local_options
+      @options.replace(@options_stack.pop)
+    end
+
+    LOCAL_CONFIG_FILE_NAME = '.tagomatic'
+
+  end
+
+end

data/lib/tagomatic/system_configuration.rb

@@ -0,0 +1,64 @@
+require 'monkey/string'
+
+module Tagomatic
+
+  class SystemConfiguration < Hash
+
+    def initialize(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    alias :super_method_missing :method_missing
+
+    def method_missing(name, *arguments)
+      handler = MetaHandler.new(self, name)
+      handler.invoke(arguments)
+    end
+
+    def retrieve(key)
+      key = key.to_sym
+      self[key] || raise("global object #{key} not registered")
+    end
+
+    def register(assignment_hash)
+      assignment_hash.each do |key, value|
+        key = key.to_sym
+        self[key] = value
+      end
+    end
+
+    class MetaHandler
+
+      def initialize(target, name)
+        @target = target
+        @name = name
+      end
+
+      def invoke(arguments)
+        if is_calling?(:register)
+          execute_invoke :register, arguments
+        elsif is_calling?(:retrieve) or is_calling?(:get)
+          execute_invoke :retrieve, arguments
+        else
+          raise "unsupported invocation: #{@name}"
+        end
+      end
+
+      def is_calling?(method)
+        @name.to_s.starts_with?("#{method}_")
+      end
+
+      def execute_invoke(method, arguments)
+        key = extract_key
+        full_arguments = [key] + arguments
+        @target.send(method, *full_arguments)
+      end
+
+      def extract_key
+        @name.to_s.sub(/^[^_]+_/, '')
+      end
+
+    end
+  end
+
+end

data/lib/tagomatic/tagger.rb

@@ -0,0 +1,190 @@
+require 'tagomatic/info_updater'
+
+module Tagomatic
+
+  class Tagger
+
+    FORMAT_ID_ARTIST = 'a'
+    FORMAT_ID_ALBUM = 'b'
+    FORMAT_ID_DISC = 'd'
+    FORMAT_ID_GENRE = 'g'
+    FORMAT_ID_IGNORE = 'i'
+    FORMAT_ID_TITLE = 't'
+    FORMAT_ID_TRACKNUM = 'n'
+    FORMAT_ID_YEAR = 'y'
+
+    KNOWN_FORMATS = [
+            "%g/%a/%y %b/%n_-_%t.mp3",
+            "%g/%a/%y %b/%n_%t.mp3",
+            "%g/%a/%y %b/%n-%t.mp3",
+            "%g/%a/%b [%y]/%n-%t.mp3",
+
+            "%g/%a/%a_%b_%y/%n_%t.mp3",
+            "%g/%a/%b [%y]/%n - %t.mp3",
+            "%g/%a/%b/%a - %n - %t.mp3",
+            "%g/%a/%b/%n - %t.mp3",
+            "%g/%a/%b/%n-%t.mp3",
+            "%g/%a/%b/%n_%t.mp3",
+            "%g/%a/%b/%n %t.mp3",
+            "%g/%a/%a- %b/%n %t.mp3",
+            "%g/%a/%b/%a - %t.mp3",
+            "%g/%a/(%y) %b/%n - %t.mp3",
+            "%g/%a/%y %b/%n - %t.mp3",
+            "%a/%b/%n - %t.mp3",
+            "%a - %y - %b/%n - %t.mp3",
+            "%a - %b/%n - %t.mp3",
+    ]
+
+    def initialize(options, compiler, mp3info, info_updater_factory, logger)
+      @options = options
+      @compiler = compiler
+      @mp3info = mp3info
+      @info_updater_factory = info_updater_factory
+      @logger = logger
+    end
+
+    def process!(file_path)
+      @logger.verbose "tagging #{file_path}"
+
+      prepare_for_current_file(file_path)
+      apply_formats
+      apply_forced_tags
+      try_updating_mp3file
+    end
+
+    protected
+
+    def prepare_for_current_file(file_path)
+      @file_path = file_path
+      @tags = nil
+    end
+
+    def apply_formats
+      apply_custom_formats if custom_formats_available?
+      apply_known_formats if no_tags_set? and guessing_allowed?
+    end
+
+    def custom_formats_available?
+      @options[:formats] and not @options[:formats].empty?
+    end
+
+    def apply_custom_formats
+      @tags = guess_tags_using(@options[:formats])
+      show_error("no custom format matched #{@file_path}") unless @tags
+    end
+
+    def show_error(message, optional_exception = nil)
+      @logger.error("failed updating #{@file_path}", optional_exception)
+      exit 10 if @options[:errorstops]
+    end
+
+    def no_tags_set?
+      @tags.nil? or @tags.empty?
+    end
+
+    def guessing_allowed?
+      @options[:guess]
+    end
+
+    def apply_known_formats
+      @tags = guess_tags_using(KNOWN_FORMATS)
+      show_error("no format guess matched #{@file_path}") unless @tags
+    end
+
+    def guess_tags_using(formats)
+      compile_if_necessary(formats)
+      formats.each do |format|
+        matched_tags = format.match(@file_path)
+        return matched_tags unless matched_tags.nil? or matched_tags.empty?
+      end
+      nil
+    end
+
+    def compile_if_necessary(formats)
+      formats.map! { |f| f.is_a?(FormatMatcher) ? f : @compiler.compile_format(f) }
+    end
+
+    def apply_forced_tags
+      @tags ||= Hash.new
+      @tags[:album] if @options[:album]
+      @tags[:artist] if @options[:artist]
+      @tags[:discnum] if @options[:discnum]
+      @tags[:genre] if @options[:genre]
+      @tags[:title] if @options[:title]
+      @tags[:tracknum] if @options[:tracknum]
+      @tags[:year] if @options[:year]
+    end
+
+    def try_updating_mp3file
+      update_mp3file
+    rescue
+      show_error "failed updating #{@file_path}", $1
+    end
+
+    def update_mp3file
+      open_mp3file
+      clear_tags if @options[:cleartags]
+      show_mp3info if @options[:verbose]
+      apply_tags
+      show_tags if @options[:showtags]
+    ensure
+      close_mp3file
+    end
+
+    def open_mp3file
+      @mp3 = @mp3info.open(@file_path)
+    end
+
+    def clear_tags
+      @mp3.removetag1
+      @mp3.removetag2
+    end
+
+    def show_mp3info
+      puts @mp3
+    end
+
+    def apply_tags
+      updater = @info_updater_factory.create_info_updater(@mp3)
+
+      discnum = @tags[FORMAT_ID_DISC]
+      discnum_suffix = discnum ? " CD#{discnum}" : ''
+
+      @tags.each do |tag, value|
+        next unless tag and value
+        next if tag == FORMAT_ID_IGNORE
+
+        updater.album = value + discnum_suffix if tag == FORMAT_ID_ALBUM
+        updater.artist = value if tag == FORMAT_ID_ARTIST
+        updater.genre_s = value if tag == FORMAT_ID_GENRE
+        updater.title = value if tag == FORMAT_ID_TITLE
+        updater.tracknum = value.to_i if tag == FORMAT_ID_TRACKNUM
+        updater.year = value if tag == FORMAT_ID_YEAR
+      end
+
+      updater.apply if updater.dirty?
+    end
+
+    def show_tags
+      output = 'g='
+      output << ( @mp3.tag.genre_s || '<genre>' )
+      output << '/a='
+      output << ( @mp3.tag.artist || '<artist>' )
+      output << '/b='
+      output << ( @mp3.tag.album || '<album>' )
+      output << '/y='
+      output << ( @mp3.tag.year ? "#{@mp3.tag2.TYER}" : '<year>' )
+      output << '/n='
+      output << ( @mp3.tag.tracknum ? "#{@mp3.tag2.TRCK}" : '<tracknum>' )
+      output << '/t='
+      output << ( @mp3.tag.title || '<title>' )
+      puts output
+    end
+
+    def close_mp3file
+      @mp3.close
+    end
+
+  end
+
+end