tagomatic 0.0.2

data/.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project relativePaths="false" version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="" />
+  </component>
+</project>
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Daniel Lukic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,25 @@
+= tagomatic
+
+Simple command-line mp3 tagger based on mp3info gem. Supports folder-specific configuration files.
+
+Another mp3 tagger the world does not need.
+
+But I needed it. I have a large collection of old mp3 files. From times when tagging was mostly
+based on the file and folder names. When v2 tags where nowhere close..
+
+Modes of operation:
+
+* The tagger will try to guess the tags from the full file path by applying a set of known formats.
+* The tagger will apply specific tags given on the command-line.
+* The tagger will match specific formats given on the command-line.
+* Arbitraty combination of the before-mentioned modes.
+
+The scanner supports recursive folder handling. Of course.
+
+Right now v2 tags are the focus.
+
+It is probably best to call this alpha ware.
+
+== Copyright
+
+Copyright (c) 2009 Daniel Lukic. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "tagomatic"
+    gem.summary = %Q{Simple command-line mp3 tagger based on mp3info gem. Supports folder-specific configuration files.}
+    gem.description = File.read('README.rdoc')
+    gem.email = "daniel.lukic@berlinfactor.com"
+    gem.homepage = "http://github.com/DanielLukic/tagomatic"
+    gem.authors = ["Daniel Lukic"]
+    gem.add_dependency "ruby-mp3info", ">= 0"
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tagomatic #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/bin/tagomatic

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'tagomatic/main'
+Tagomatic::Main.run!(*ARGV)

data/lib/monkey/string.rb

@@ -0,0 +1,10 @@
+class String
+
+  def starts_with?(prefix)
+    pattern = Regexp.new "^#{Regexp.escape(prefix)}"
+    ( pattern =~ self ) == MATCHED_AT_CHAR_POSITION_ZERO
+  end
+
+  MATCHED_AT_CHAR_POSITION_ZERO = 0
+
+end

data/lib/tagomatic/format_compiler.rb

@@ -0,0 +1,44 @@
+module Tagomatic
+
+  class FormatCompiler
+
+    FORMAT_REGEXP_ARTIST = '([^\/]+)'
+    FORMAT_REGEXP_ALBUM = '([^\/]+)'
+    FORMAT_REGEXP_DISC = '([0-9]+)'
+    FORMAT_REGEXP_GENRE = '([^\/]+)'
+    FORMAT_REGEXP_IGNORE = '([^\/]+)'
+    FORMAT_REGEXP_TITLE = '([^\/]+)'
+    FORMAT_REGEXP_TRACKNUM = '([0-9]+)'
+    FORMAT_REGEXP_YEAR = '([0-9]+)'
+
+    def initialize(format_matcher_factory)
+      @format_matcher_factory = format_matcher_factory
+    end
+
+    def compile_format(format)
+      parts = format.split('%')
+      prefix = parts.shift
+      tag_mapping = []
+      regexp = Regexp.escape(prefix)
+      parts.each do |tag_and_tail|
+        tag = tag_and_tail[0, 1]
+        tail = tag_and_tail[1..-1]
+        tag_mapping << tag
+        regexp << FORMAT_REGEXP_ALBUM if tag == Tagomatic::Tagger::FORMAT_ID_ALBUM
+        regexp << FORMAT_REGEXP_ARTIST if tag == Tagomatic::Tagger::FORMAT_ID_ARTIST
+        regexp << FORMAT_REGEXP_DISC if tag == Tagomatic::Tagger::FORMAT_ID_DISC
+        regexp << FORMAT_REGEXP_GENRE if tag == Tagomatic::Tagger::FORMAT_ID_GENRE
+        regexp << FORMAT_REGEXP_IGNORE if tag == Tagomatic::Tagger::FORMAT_ID_IGNORE
+        regexp << FORMAT_REGEXP_TITLE if tag == Tagomatic::Tagger::FORMAT_ID_TITLE
+        regexp << FORMAT_REGEXP_TRACKNUM if tag == Tagomatic::Tagger::FORMAT_ID_TRACKNUM
+        regexp << FORMAT_REGEXP_YEAR if tag == Tagomatic::Tagger::FORMAT_ID_YEAR
+        regexp << Regexp.escape(tail)
+      end
+
+      compiled = Regexp.compile(regexp)
+      @format_matcher_factory.create_format_matcher(compiled, tag_mapping, format)
+    end
+
+  end
+
+end

data/lib/tagomatic/format_matcher.rb

@@ -0,0 +1,35 @@
+module Tagomatic
+
+  class FormatMatcher
+
+    def initialize(compiled_regexp, tag_mapping, original_format)
+      @regexp = compiled_regexp
+      @mapping = tag_mapping
+      @format = original_format
+    end
+
+    def match(file_path)
+      matchdata = @regexp.match(file_path)
+      return nil unless matchdata
+      return nil unless matchdata.captures.size == @mapping.size
+      tags = {}
+      0.upto(@mapping.size) do |index|
+        value = matchdata.captures[index]
+        if value
+          value = value.gsub('_', ' ')
+          parts = value.split(' ')
+          capitalized = parts.map {|p| p.capitalize}
+          value = capitalized.join(' ')
+        end
+        tags[@mapping[index]] = value
+      end
+      tags
+    end
+
+    def to_s
+      @format
+    end
+
+  end
+
+end

data/lib/tagomatic/info_updater.rb

@@ -0,0 +1,62 @@
+module Tagomatic
+
+  class InfoUpdater
+
+    def initialize(mp3info)
+      @info = mp3info
+      @updates = {}
+    end
+
+    def apply
+      @updates.each { |tag, value| write(tag, value) }
+    end
+
+    def dirty?
+      @updates.each do |tag, value|
+        current_value = read(tag).to_s
+        return true if current_value != value.to_s
+      end
+      false
+    end
+
+    def album=(value)
+      update :album, value
+    end
+
+    def artist=(value)
+      update :artist, value
+    end
+
+    def genre_s=(value)
+      update :genre_s, value
+    end
+
+    def title=(value)
+      update :title, value
+    end
+
+    def tracknum=(value)
+      update :tracknum, value
+    end
+
+    def year=(value)
+      update :year, value
+    end
+
+    protected
+
+    def update(tag, value)
+      @updates[tag] = value
+    end
+
+    def read(tag)
+      @info.tag2.send(tag)
+    end
+
+    def write(tag, value)
+      @info.tag.send "#{tag}=".to_sym, value
+    end
+
+  end
+
+end

data/lib/tagomatic/local_options_matcher.rb

@@ -0,0 +1,40 @@
+module Tagomatic
+
+  class LocalOptionsMatcher
+
+    def process!(line)
+      @matchdata = LOCAL_OPTIONS_ENTRY_REGEX.match(line)
+    end
+
+    def is_valid_option?
+      @matchdata.captures.size > 0
+    end
+
+    def get_option
+      @matchdata.captures[OPTION_MATCH_GROUP_INDEX]
+    end
+
+    def has_value?
+      @matchdata.captures.size > 2
+    end
+
+    def get_value
+      @matchdata.captures[VALUE_MATCH_GROUP_INDEX]
+    end
+
+    def to_argv
+      argv = []
+      argv << get_option if is_valid_option?
+      argv << get_value if has_value?
+      argv
+    end
+
+    LOCAL_OPTIONS_ENTRY_REGEX = /(--[^ ]+)( (.+))?/
+
+    OPTION_MATCH_GROUP_INDEX = 0
+
+    VALUE_MATCH_GROUP_INDEX = 2
+
+  end
+
+end

data/lib/tagomatic/logger.rb

@@ -0,0 +1,20 @@
+module Tagomatic
+
+  class Logger
+
+    def initialize(options)
+      @options = options
+    end
+
+    def error(message, optional_exception = nil)
+      puts "ERROR: #{message}"
+      $stderr.puts optional_exception.backtrace if optional_exception
+    end
+
+    def verbose(message)
+      puts message if @options[:verbose]
+    end
+
+  end
+
+end

data/lib/tagomatic/main.rb

@@ -0,0 +1,68 @@
+require 'tagomatic/format_compiler'
+require 'tagomatic/object_factory'
+require 'tagomatic/logger'
+require 'tagomatic/mp3info_wrapper'
+require 'tagomatic/options'
+require 'tagomatic/options_parser'
+require 'tagomatic/scanner'
+require 'tagomatic/system_configuration'
+require 'tagomatic/tagger'
+
+module Tagomatic
+
+  class Main
+
+    def self.run!(*arguments)
+      configuration = Tagomatic::SystemConfiguration.new do
+        register :options => Tagomatic::Options.new
+        register :parser => Tagomatic::OptionsParser.new(get_options)
+        register :local_options_matcher_factory => Tagomatic::ObjectFactory.new
+        register :logger => Tagomatic::Logger.new(get_options)
+        register :scanner => Tagomatic::Scanner.new(get_options, get_parser, get_local_options_matcher_factory, get_logger)
+        register :format_matcher_factory => Tagomatic::ObjectFactory.new
+        register :compiler => Tagomatic::FormatCompiler.new(get_format_matcher_factory)
+        register :mp3info => Tagomatic::Mp3InfoWrapper.new
+        register :info_updater_factory => Tagomatic::ObjectFactory.new
+        register :tagger => Tagomatic::Tagger.new(get_options, get_compiler, get_mp3info, get_info_updater_factory, get_logger)
+      end
+
+      parser = configuration[:parser]
+      parser.parse!(arguments)
+
+      new(configuration).run!
+    end
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def run!
+      options = @configuration[:options]
+
+      show_known_formats_and_exit if options[:list]
+      show_usage_and_exit if options[:files].empty?
+
+      scanner = @configuration[:scanner]
+      tagger = @configuration[:tagger]
+
+      files = options[:files]
+      files.each do |file|
+        scanner.process!(nil, file) do |mp3filepath|
+          tagger.process!(mp3filepath)
+        end
+      end
+    end
+
+    def show_usage_and_exit
+      puts @configuration[:parser].show_help
+      exit 1
+    end
+
+    def show_known_formats_and_exit
+      puts Tagomatic::Tagger::KNOWN_FORMATS
+      exit 1
+    end
+
+  end
+
+end

data/lib/tagomatic/mp3info_wrapper.rb

@@ -0,0 +1,14 @@
+require "rubygems"
+require "mp3info"
+
+module Tagomatic
+
+  class Mp3InfoWrapper
+
+    def open(file_path, &block)
+      Mp3Info.open(file_path, &block)
+    end
+
+  end
+
+end

data/lib/tagomatic/object_factory.rb

@@ -0,0 +1,23 @@
+require 'tagomatic/format_matcher'
+require 'tagomatic/info_updater'
+require 'tagomatic/local_options_matcher'
+
+module Tagomatic
+
+  class ObjectFactory
+
+    def create_local_options_matcher(*arguments)
+      Tagomatic::LocalOptionsMatcher.new(*arguments)
+    end
+
+    def create_format_matcher(*arguments)
+      Tagomatic::FormatMatcher.new(*arguments)
+    end
+
+    def create_info_updater(*arguments)
+      Tagomatic::InfoUpdater.new(*arguments)
+    end
+
+  end
+
+end