easytag 0.4.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53a9645ec483ba68cc28dffd34002d149b43d24d
-  data.tar.gz: 0cf232f7f04a0f1e3bf6606c8abf363cc2d4ef9f
+  metadata.gz: 16662d29b534ff4cc4ec6e52e35b1f725387c01d
+  data.tar.gz: f7b35f5fa59150c4937a3781fc206420741e6c8f
 SHA512:
-  metadata.gz: 026bbbf0959293a24f17103bc0fa4d53e83c3edf80bf2c1e4553ff8cfefff3c930af5dca8ba205853d20a747be0c20c114f076121c9f8145e45c6497afb45e45
-  data.tar.gz: 78507cf793dc807eeb7ee8d32ebd57cbf0937cf453a7ced4578d4b495a2016a80b4d8165ece596e534dc511bf89a23651e27684cbe8ea62065a32ff7a94053fc
+  metadata.gz: 23e58b9d0726dff60df794e0595fc6fbeac6a8b8a07c3bc82c47a13094cbdc44899886393ba14f491f3c732758866a4d163154c7aa9a6ad313beac9342668ddd
+  data.tar.gz: b2b80e1092243a8fa6f0ff6969ea29ef38b3dfa744fff6502376cb4dac412c9b886225351e8782861a0b357cddf69db2146ecda7c3825faf3ed29c2c2267c969

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+##### v1.0.0 (2013-05-26) #####
+* added: detecting file type from file signature
+* first major release
+
+##### v0.6.0 (2013-05-25) #####
+* complete overhaul, this release is not compatible with any previous release
+* FLAC, Ogg support added
+
+##### v0.4.3 (2013-08-20) #####
+* fixed: uninitialized constant error with regard to file unsupported exception
+
 ##### v0.4.2 (2013-06-23) #####
 * added: interal support for `TagLib::ID3v2::UnknownFrame`
 * info: because a new version of taglib-ruby hasn't been officially released

data/Gemfile

@@ -1,7 +1,12 @@
 source 'https://rubygems.org'
 
-# for TDAT fix, temporary until maintainers push a new version
-gem 'taglib-ruby', github: 'robinst/taglib-ruby', ref: 'bb6453e2e3404cbc8d1e3056880922797167a218'
+source 'http://rubygems.org'
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'coveralls'
+end
 
 # read dependencies from gemspec file
 gemspec

data/README.md

@@ -1,52 +1,58 @@
 EasyTag is an abstract interface to the [TagLib](http://taglib.github.io/) audio tagging library. It is designed to provide a simple and consistent API regardless of file format being read.
 
+Currently support file formats are: MP3, MP4, FLAC, and Ogg.
 A quick reference to which attributes are currently supported can be found [here](https://github.com/cjlucas/ruby-easytag/wiki/Currently-Supported-Attributes).
 
 [![Build Status (master)](https://travis-ci.org/cjlucas/ruby-easytag.png?branch=master "Branch: master")](https://travis-ci.org/cjlucas/ruby-easytag)
 [![Build Status (develop)](https://travis-ci.org/cjlucas/ruby-easytag.png?branch=develop "Branch: develop")](https://travis-ci.org/cjlucas/ruby-easytag)
 
+NOTE: v0.6.0+ is not compatible with any version prior to v0.6.0.
+
 ---
 ## Synopsis ##
+
 ```ruby
 require 'easytag'
 
-mp3 = EasyTag::File.new("01 Shout Out Loud.mp3")
-
-# easy access to attributes
-mp3.title
-# => "Shout Out Loud"
-mp3.artist
-# => "Amos Lee"
-mp3.year
-# => 2006
-mp3.date
-# => #<DateTime: 2006-10-03T00:00:00+00:00 ((2454012j,0s,0n),+0s,2299161j)>
-mp3.album_art
-# => [#<EasyTag::Image:0x007f7fa542f528>]
-
-# get access to the taglib-powered backend
-mp3.info
-# => #<TagLib::MPEG::File:0x007f7fa539e050 @__swigtype__="_p_TagLib__MPEG__File">
-mp3.close
-
-# A block interface is also available
-EasyTag::File.open('01 Shout Out Loud.m4a') do |m4a|
-  puts m4a.title
-  puts m4a.comments
-  puts m4a.genre
+tagger = EasyTag.open('audio.flac') # calls EasyTag::TaggerFactory::open
+tagger                       # => <EasyTag::FLACTagger:0x007fc28aba4c90>
+tagger.title                 # => "She Lives in My Lap"
+tagger.artist                # => "OutKast feat. Rosario Dawson"
+tagger.album_artist          # => "OutKast"
+tagger.musicbrainz_artist_id # => ["73fdb566-a9b1-494c-9f32-51768ec9fd27", "9facf8dc-df23-4561-85c5-ece75d692f21"]
+
+# The backing taglib object is also available 
+f.taglib # => <TagLib::FLAC::File:0x007fc28aba4c68 @__swigtype__="_p_TagLib__FLAC__File">
+
+f.close
+
+# A block can also be specified
+EasyTag.open('audio.mp3') do |tagger|
+ tagger.title         # => "She Lives in My Lap"
+ tagger.artist        # => "OutKast feat. Rosario Dawson"
+ tagger.album_artist  # => "OutKast"
+ 
+ # tagger.close will be called after the block is executed
+end
+
+# Taggers also return consistent defaults for missing attributes
+EasyTag..open('no_tags.ogg') do |tagger|
+  tagger.year       # => 0 (for any int attribute)
+  tagger.album_art  # => [] (for any list attribute)
+  tagger.title      # => nil (for any non-int, non-list attribute)
 end
 ```
+
+
 ## Requirements ##
 - Ruby versions
-  - 1.9
   - 2.0
+  - 2.1
 - Dependencies
   - [TagLib](http://taglib.github.io/) (1.8+)
   - [taglib-ruby](https://github.com/robinst/taglib-ruby) (0.6.0+)
-  - [ruby-mp3info](https://github.com/moumar/ruby-mp3info)
   - [ruby-imagespec](https://github.com/andersonbrandon/ruby-imagespec)
 
 ## TODO ##
 - API Documentation
-- FLAC and OGG support
 - Write support

data/Rakefile

@@ -1,16 +1,16 @@
 $LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
 
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
 require 'easytag/version'
 
-task :default => [:test]
+task :default => [:spec]
+task :test => :spec
 
-task :test do
-  Rake::TestTask.new do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/test_*.rb']
-    t.verbose = false
+task :spec do
+  RSpec::Core::RakeTask.new do |task|
+    task.verbose = false
+    task.rspec_opts = '--color'
   end
 end
 

data/easytag.gemspec

@@ -19,9 +19,7 @@ Gem::Specification.new do |s|
   s.test_files  = s.files.select { |f| f.match(/^test\/.*\.rb$/) }
   s.platform    = Gem::Platform::RUBY
 
-  #s.add_runtime_dependency('taglib-ruby', '>= 0.6.0')
+  s.add_runtime_dependency('taglib-ruby', '>= 0.6.0')
   s.add_runtime_dependency('ruby-imagespec', '>= 0.3.1')
-  s.add_runtime_dependency('ruby-mp3info', '>= 0.8')
-
-  s.add_development_dependency('rake')
 end
+

data/lib/easytag.rb

@@ -1,5 +1,15 @@
 require 'bundler/setup'
 
 require 'easytag/util'
-require 'easytag/file'
-require 'easytag/interfaces'
+require 'easytag/taggers/mp3'
+require 'easytag/taggers/mp4'
+require 'easytag/taggers/vorbis'
+require 'easytag/taggers/flac'
+require 'easytag/taggers/ogg'
+require 'easytag/taggers/factory'
+
+module EasyTag
+  def self.open(file, &block)
+    TaggerFactory.open(file, &block)
+  end
+end

data/lib/easytag/attributes/base.rb

@@ -1,143 +1,47 @@
-module EasyTag::Attributes
-  # for type casting
-  module Type
-    STRING      = 0
-    INT         = 1
-    FLOAT       = 2
-    INT_LIST    = 3
-    STRING_LIST = 4
-    BOOLEAN     = 5
-    DATETIME    = 6
-    LIST        = 7
-  end
-  class BaseAttribute
-    Utilities = EasyTag::Utilities
-    
-    attr_reader :name, :aliases, :ivar
-
-    def initialize(args)
-      @name         = args[:name]
-      @type         = args[:type]
-      @default      = args[:default] || self.class.default_for_type(@type)
-      @options      = args[:options] || {}
-      @handler_opts = args[:handler_opts] || {}
-      @aliases      = args[:aliases] || []
-      @ivar         = BaseAttribute.name_to_ivar(@name)
-
-      if args[:handler].is_a?(Symbol)
-        @handler = method(args[:handler])
-      elsif args[:handler].is_a?(Proc)
-        @handler = args[:handler]
-      end
-
-      # fill default options
-      
-      # Remove nil objects from array (post process)
-      @options[:compact]        ||= false
-      # Delete empty objects in array (post process)
-      @options[:delete_empty]   ||= false
-      # normalizes key (if hash) (handler or post process)
-      @options[:normalize]      ||= false
-      # cast key (if hash) to symbol (handler or post process)
-      @options[:to_sym]         ||= false
-
-    end
-    
-    def self.can_clone?(obj)
-      obj.is_a?(String) || obj.is_a?(Array) || obj.is_a?(Hash)
-    end
-
-    def self.deep_copy(obj)
-      Marshal.load(Marshal.dump(obj))
-    end
-
-    def self.default_for_type(type)
-      case type
-      when Type::STRING
-        ''
-      when Type::DATETIME
-        nil
-      when Type::INT
-        0
-      when Type::INT_LIST
-        [0, 0] # TODO: don't assume an INT_LIST is always an int pair
-      when Type::BOOLEAN
-        false
-      when Type::LIST
-        []
+module EasyTag
+  module BaseAttributeAccessors
+
+    def audio_prop_reader(attr_name, prop_name = nil, **opts)
+      prop_name = attr_name if prop_name.nil?
+      define_method(attr_name) do
+        v = self.class.read_audio_property(taglib, prop_name)
+        self.class.post_process(v, opts)
       end
     end
 
-    def default
-      BaseAttribute.can_clone?(@default) ?
-        BaseAttribute.deep_copy(@default) : @default
-    end
-    
-    def call(iface)
-      data = @handler.call(iface)
-      data = type_cast(data)
-      post_process(data)
-    end
-
-    def type_cast(data)
-      case @type
-      when Type::INT
-        data = data.to_i
-      when Type::DATETIME
-        data = Utilities.get_datetime(data.to_s)
-      when Type::LIST
-        data = Array(data)
+    def cast(data, key, **opts)
+      case opts[key]
+      when :int
+        data.to_i
+      when :int_pair
+        Utilities.get_int_pair(data)
+      when :datetime
+        Utilities.get_datetime(data.to_s)
+      when :list
+        Array(data)
+      when :bool
+        [1, '1', true].include?(data)
+      else
+        data
       end
-      
-      data
     end
 
-    def post_process(data)
-      if @options[:is_flag]
-        data = data.to_i == 1 ? true : false
-      end
-
-      # fall back to default if data is nil
-      data ||= default
-
-      # REVIEW: the compact option may not be needed anymore
-      #   since we've done away with casting empty strings to nil
-      data.compact! if @options[:compact] && data.respond_to?(:compact!)
-
-      if @options[:delete_empty]
-        data.select! { |item| !item.empty? if item.respond_to?(:empty?) }
-      end
-
-      data = Utilities.normalize_object(data) if @options[:normalize]
-
-      # TODO: roll this out to a method that supports more than just array
-      if @options[:to_sym] && data.is_a?(Array)
-        data.map! { |item| item.to_sym if item.respond_to?(:to_sym) }
+    def extract(data, **opts)
+      if opts.has_key?(:extract_list_pos)
+        data = data[opts[:extract_list_pos]]
       end
-
       data
     end
-    
-    def self.name_to_ivar(name)
-      name.to_s.gsub(/\?/, '').insert(0, '@').to_sym
-    end
-
-    # read handlers
 
-    def read_default(iface)
-      default
+    def post_process(data, opts)
+      data = cast(data, :cast, **opts)
+      data = extract(data, **opts)
+      cast(data, :returns, **opts)
     end
 
-    def read_audio_property(iface)
-      key = @handler_opts[:key]
-      warn "@handler_opts[:key] doesn't exist" if key.nil?
-      iface.info.audio_properties.send(key)
-    end
-
-    def user_info_lookup(iface)
-      key = @handler_opts[:key]
-      warn "@handler_opts[:key] doesn't exist" if key.nil?
-      iface.user_info_normalized[key]
+    def read_audio_property(taglib, key)
+      taglib.audio_properties.send(key)
     end
   end
 end
+

data/lib/easytag/attributes/flac.rb

@@ -0,0 +1,25 @@
+require_relative 'vorbis'
+
+module EasyTag
+  module FLACAttributeAccessors
+    def field_reader(attr_name, fields = nil, **opts)
+      fields = attr_name.to_s.upcase if fields.nil?
+      define_method(attr_name) do
+        v = self.class.read_fields(taglib.xiph_comment, fields, **opts)
+        self.class.post_process(v, **opts)
+      end
+    end
+
+    def album_art_reader(attr_name, **opts)
+      define_method(attr_name) do
+        taglib.picture_list.collect do |pic|
+          EasyTag::Image.new(pic.data).tap do |img|
+            img.mime_type = pic.mime_type
+            img.type      = pic.type
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/easytag/attributes/mp3.rb

@@ -4,605 +4,142 @@ require 'easytag/image'
 require 'easytag/util'
 require 'easytag/attributes/base'
 
-module EasyTag::Attributes
-  class MP3Attribute < BaseAttribute
-    attr_reader :name, :ivar
-    
-    def initialize(args)
-      super(args)
-      @id3v2_frames = args[:id3v2_frames] || []
-      @id3v1_tag    = args[:id3v1_tag] || nil
-
-      # fill default options
-    
-      # ID3 stores boolean values as numeric strings
-      #   set to true to enable type casting  (post process)
-      @options[:is_flag]    ||= false
-      # return entire field list instead of first item in field list
-      @options[:field_list] ||= false
+module EasyTag
+  module MP3AttributeAccessors
+    include BaseAttributeAccessors
+
+    def single_tag_reader(attr_name, id3v2_frames = nil, id3v1_tag = nil, **opts)
+      id3v2_frames = Array(id3v2_frames)
+      define_method(attr_name) do
+        v = self.class.read_first_tag(taglib, id3v2_frames, id3v1_tag, opts)
+        self.class.post_process(v, opts)
+      end
     end
 
-
-    def frames_for_id(id, iface)
-      iface.info.id3v2_tag.frame_list(id)
+    def all_tags_reader(attr_name, id3v2_frames = nil, id3v1_tag = nil, **opts)
+      id3v2_frames = Array(id3v2_frames)
+      define_method(attr_name) do
+        v = self.class.read_all_tags(taglib, id3v2_frames, id3v1_tag, opts)
+        self.class.post_process(v, opts)
+      end
     end
 
-    def first_frame_for_id(id, iface)
-      frames_for_id(id, iface).first
+    def user_info_reader(attr_name, key = nil, **opts)
+      key = attr_name if key.nil?
+      define_method(attr_name) do
+        @user_info = self.class.read_user_info(taglib, **opts) if @user_info.nil?
+        self.class.post_process(@user_info[key], opts)
+      end
     end
 
-    def data_from_frame(frame)
-      data = nil
-      if frame.is_a?(TagLib::ID3v2::TextIdentificationFrame)
-        field_list = frame.field_list
-        data = @options[:field_list] ? field_list : field_list.first
-      elsif frame.is_a?(TagLib::ID3v2::UnsynchronizedLyricsFrame)
-        data = frame.text
-      elsif frame.is_a?(TagLib::ID3v2::CommentsFrame)
-        data = frame.text
-      elsif frame.is_a?(TagLib::ID3v2::AttachedPictureFrame)
-        data = EasyTag::Image.new(frame.picture)
-        data.desc = frame.description
-        data.type = frame.type
-        data.mime_type = frame.mime_type
-      elsif frame.is_a?(TagLib::ID3v2::UnknownFrame)
-        nil
-      else
-        warn 'no defined frames match the given frame'
+    def ufid_reader(attr_name, owner, **opts)
+      define_method(attr_name) do
+        v = self.class.read_ufid(taglib, owner, opts)
+        self.class.post_process(v, opts)
       end
+    end
 
-      data
+    def date_reader(attr_name, **opts)
+      opts[:returns] = :datetime unless opts.has_key?(:returns)
+      define_method(attr_name) do
+        v = self.class.read_date(taglib, opts)
+        self.class.post_process(v, opts)
+      end
     end
 
-    #
-    # read handlers
-    #
-    
-    # read_all_id3
-    #
-    # gets data from each frame id given
-    # only falls back to the id3v1 tag if none found
-    def read_all_id3(iface)
+    # gets data from each frame id given only falls back
+    # to the id3v1 tag if no id3v2 frames were found
+    def read_all_tags(taglib, id3v2_frames, id3v1_tag = nil, **opts)
       frames = []
-      @id3v2_frames.each do |f| 
-        frames += frames_for_id(f, iface)
-      end
+      id3v2_frames.each { |frame_id| frames += id3v2_frames(taglib, frame_id) }
 
       data = []
       # only check id3v1 if no id3v2 frames found
       if frames.empty?
-        data << iface.info.id3v1_tag.send(@id3v1_tag) unless @id3v1_tag.nil?
+        data << id3v1_tag(taglib, id3v1_tag) unless id3v1_tag.nil?
       else
-        frames.each { |frame| data << data_from_frame(frame) }
+        frames.each { |frame| data << data_from_frame(frame, **opts) }
       end
 
-      data
+      data.compact
     end
 
-    # read_first_id3
-    #
-    # Similar to read_all_id3, but optimized for reading only one frame at max
-    def read_first_id3(iface)
-      frame = nil
-      @id3v2_frames.each do |f|
-        frame = first_frame_for_id(f, iface) if frame.nil?
-      end
+    def read_first_tag(taglib, id3v2_frames, id3v1_tag = nil, **opts)
+      read_all_tags(taglib, id3v2_frames, id3v1_tag, **opts).first
+    end
 
-      if frame.nil?
-        data = iface.info.id3v1_tag.send(@id3v1_tag) unless @id3v1_tag.nil?
+    def id3v1_tag(taglib, tag_name)
+      return nil if taglib.id3v1_tag.empty?
+      v = taglib.id3v1_tag.send(tag_name)
+      # TEMPFIX: nonexistent id3v1 tags return an empty string (taglib-ruby issue #49)
+      case
+      when v.is_a?(Fixnum) && v.zero?
+        nil
+      when v.is_a?(String) && v.empty?
+        nil
       else
-        data = data_from_frame(frame)
+        v
       end
+    end
 
-      data
+    def id3v2_frames(taglib, frame_id)
+      taglib.id3v2_tag.frame_list(frame_id)
     end
 
-    def read_int_pair(iface)
-      int_pair_str = read_first_id3(iface).to_s
-      EasyTag::Utilities.get_int_pair(int_pair_str)
+    def data_from_frame(frame, **opts)
+      case
+      when frame.is_a?(TagLib::ID3v2::TextIdentificationFrame)
+        field_list = frame.field_list
+        opts[:field_list] ? field_list : field_list.first
+      when frame.is_a?(TagLib::ID3v2::UnsynchronizedLyricsFrame)
+        frame.text
+      when frame.is_a?(TagLib::ID3v2::CommentsFrame)
+        frame.text
+      when frame.is_a?(TagLib::ID3v2::AttachedPictureFrame)
+        EasyTag::Image.new(frame.picture).tap do |img|
+          img.desc = frame.description
+          img.type = frame.type
+          img.mime_type = frame.mime_type
+        end
+      else
+        nil
+      end
     end
 
-    def read_field_list_as_key_value(iface)
-      kv_hash = {}
-      frame_data = read_all_id3(iface)
+    def read_user_info(taglib, **opts)
+      user_info = {}
+      frame_data = read_all_tags(taglib, ['TXXX'], nil, {field_list: true})
 
       frame_data.each do |data|
         key = data[0]
         values = data[1..-1]
 
-        key = Utilities.normalize_string(key) if @options[:normalize]
-        key = key.to_sym if @options[:to_sym]
-        kv_hash[key] = values.count > 1 ? values : values.first
+        user_info[key] = values.count > 1 ? values : values.first
       end
 
-      kv_hash
+      user_info
     end
 
-    def read_date(iface)
-      id3v1 = iface.info.id3v1_tag
-
-      v10_year = id3v1.year.to_s if id3v1.year > 0
-      v23_year = data_from_frame(first_frame_for_id('TYER', iface))
-      v23_date = data_from_frame(first_frame_for_id('TDAT', iface))
-      v24_date = data_from_frame(first_frame_for_id('TDRC', iface))
+    # NOTE: id3v2.3 tags (TYER+TDAT) will lose month/day information due to taglib's
+    # internal frame conversion. During the conversion, the TDAT frame is
+    # dropped and only the TYER frame is used in the conversion to TDRC.
+    # (see: https://github.com/taglib/taglib/issues/127)
+    def read_date(taglib, **opts)
+      v10_year = taglib.id3v1_tag.year.to_s if taglib.id3v1_tag.year > 0
+      v24_date = read_first_tag(taglib, ['TDRC'])
 
       # check variables in order of importance
-      date_str = v24_date || v23_year || v10_year
-      # only append v23_date if date_str is currently a year
-      date_str << v23_date unless v23_date.nil? or date_str.length > 4
+      date_str = v24_date || v10_year
       puts "MP3#date: date_str = \"#{date_str}\"" if $DEBUG
 
       date_str
     end
 
-    def read_ufid(iface)
-      frames = iface.info.id3v2_tag.frame_list('UFID')
-      ufid = nil
-
-      frames.each do |frame|
-        if @handler_opts[:owner].eql?(frame.owner)
-          ufid = frame.identifier
-          break
-        end
-      end
-
-      ufid
+    def read_ufid(taglib, owner, opts)
+      frames = taglib.id3v2_tag.frame_list('UFID')
+      frames.each { |frame| return frame.identifier if owner.eql?(frame.owner) }
+      nil
     end
   end
 end
 
-module EasyTag::Attributes
-  MP3_ATTRIB_ARGS = [
-  # title
-  {
-    :name         => :title,
-    :id3v2_frames => ['TIT2'],
-    :id3v1_tag    => :title,
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # title_sort_order
-  #   TSOT - (v2.4 only)
-  #   XSOT - Musicbrainz Picard custom
-  {
-    :name         => :title_sort_order,
-    :id3v2_frames => ['TSOT', 'XSOT'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # subtitle
-  {
-    :name         => :subtitle,
-    :id3v2_frames => ['TIT3'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # artist
-  {
-    :name         => :artist,
-    :id3v2_frames => ['TPE1'],
-    :id3v1_tag    => :artist,
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # artist_sort_order
-  #   TSOP - (v2.4 only)
-  #   XSOP - Musicbrainz Picard custom
-  {
-    :name         => :artist_sort_order,
-    :id3v2_frames => ['TSOP', 'XSOP'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # album_artist
-  {
-    :name         => :album_artist,
-    :id3v2_frames => ['TPE2'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # album_artist_sort_order
-  {
-    :name         => :album_artist_sort_order,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :albumartistsort},
-    :type         => Type::STRING,
-  },
-
-  # album
-  {
-    :name         => :album,
-    :id3v2_frames => ['TALB'],
-    :id3v1_tag    => :album,
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # compilation?
-  {
-    :name         => :compilation?,
-    :id3v2_frames => ['TCMP'],
-    :handler      => :read_first_id3,
-    :type         => Type::BOOLEAN,
-    # TODO: remove is_flag option, determine boolean value implicitly 
-    :options      => {:is_flag => true},
-  },
-
-  # album_sort_order
-  #   TSOA - (v2.4 only)
-  #   XSOA - Musicbrainz Picard custom
-  {
-    :name         => :album_sort_order,
-    :id3v2_frames => ['TSOA', 'XSOA'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-  
-  # genre
-  {
-    :name         => :genre,
-    :id3v2_frames => ['TCON'],
-    :id3v1_tag    => :genre,
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # disc_subtitle
-  {
-    :name         => :disc_subtitle,
-    :id3v2_frames => ['TSST'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # media
-  {
-    :name         => :media,
-    :id3v2_frames => ['TMED'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # label
-  {
-    :name         => :label,
-    :id3v2_frames => ['TPUB'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # encoded_by
-  {
-    :name         => :encoded_by,
-    :id3v2_frames => ['TENC'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # encoder_settings
-  {
-    :name         => :encoder_settings,
-    :id3v2_frames => ['TSSE'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # group
-  {
-    :name         => :group,
-    :id3v2_frames => ['TIT1'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # composer
-  {
-    :name         => :composer,
-    :id3v2_frames => ['TCOM'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # conductor
-  {
-    :name         => :conductor,
-    :id3v2_frames => ['TPE3'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # remixer
-  {
-    :name         => :remixer,
-    :id3v2_frames => ['TPE4'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # lyrics
-  {
-    :name         => :lyrics,
-    :id3v2_frames => ['USLT'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # lyricist
-  {
-    :name         => :lyricist,
-    :id3v2_frames => ['TEXT'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # copyright
-  {
-    :name         => :copyright,
-    :id3v2_frames => ['TCOP'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # bpm
-  {
-    :name         => :bpm,
-    :id3v2_frames => ['TBPM'],
-    :handler      => :read_first_id3,
-    :type         => Type::INT,
-  },
-
-  # mood
-  {
-    :name         => :mood,
-    :id3v2_frames => ['TMOO'],
-    :handler      => :read_first_id3,
-    :type         => Type::STRING,
-  },
-
-  # track_num
-  {
-    :name         => :track_num,
-    :id3v2_frames => ['TRCK'],
-    :id3v1_tag    => :track,
-    :default      => [0, 0],
-    :handler      => :read_int_pair,
-    :type         => Type::INT_LIST, # don't know if this will ever be useful
-  },
-  
-  # disc_num
-  {
-    :name         => :disc_num,
-    :id3v2_frames => ['TPOS'],
-    :default      => [0, 0],
-    :handler      => :read_int_pair,
-    :type         => Type::INT_LIST, # don't know if this will ever be useful
-  },
-
-  # original_date
-  #   TDOR - orig release date (v2.4 only)
-  #   TORY - orig release year (v2.3)
-  {
-    :name         => :original_date,
-    :id3v2_frames => ['TDOR', 'TORY'],
-    :handler      => :read_first_id3,
-    :type         => Type::DATETIME,
-  },
-
-  # comments
-  {
-    :name         => :comments,
-    :id3v2_frames => ['COMM'],
-    :id3v1_tag    => :comment,
-    :handler      => :read_all_id3,
-    :default      => [],
-    :options      => { :compact => true, :delete_empty => true }
-  },
-  
-  # comment
-  {
-    :name         => :comment,
-    :handler      => lambda { |iface| iface.comments.first },
-    :type         => Type::STRING,
-  },
-
-  # album_art
-  {
-    :name         => :album_art,
-    :id3v2_frames => ['APIC'],
-    :handler      => :read_all_id3,
-    :default      => [],
-  },
-
-  # date
-  {
-    :name         => :date,
-    :handler      => :read_date,
-    :type         => Type::DATETIME,
-  },
-
-  # year
-  {
-    :name         => :year,
-    :handler      => lambda { |iface| iface.date.nil? ? 0 : iface.date.year }
-  },
-
-  # apple_id
-  {
-    :name         => :apple_id,
-    :handler      => :read_default,
-    :type         => Type::STRING,
-  },
-
-  # user_info
-  {
-    :name         => :user_info,
-    :id3v2_frames => ['TXXX'],
-    :handler      => :read_field_list_as_key_value,
-    :default      => {},
-    :options     => {:field_list => true},
-  },
-  
-  # user_info_normalized
-  {
-    :name         => :user_info_normalized,
-    :id3v2_frames => ['TXXX'],
-    :handler      => :read_field_list_as_key_value,
-    :default      => {},
-    :options     => {:normalize => true, 
-      :to_sym => true,
-      :field_list => true },
-  },
-
-  # asin
-  {
-    :name         => :asin,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :asin},
-    :type         => Type::STRING,
-  },
-
-  #
-  # MusicBrainz Attributes
-  #
-
-  # musicbrainz_track_id
-  {
-    :name         => :musicbrainz_track_id,
-    :handler      => :read_ufid,
-    :handler_opts => {:owner => 'http://musicbrainz.org'},
-    :type         => Type::STRING,
-  },
-
-  # musicbrainz_album_artist_id
-  {
-    :name         => :musicbrainz_album_artist_id,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_album_artist_id},
-    :type         => Type::STRING,
-  },
-
-  # musicbrainz_artist_id
-  {
-    :name         => :musicbrainz_artist_id,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_artist_id},
-    :type         => Type::LIST,
-  },
-  
-  # musicbrainz_album_id
-  {
-    :name         => :musicbrainz_album_id,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_album_id},
-    :type         => Type::STRING,
-  },
-  
-  # musicbrainz_album_status
-  {
-    :name         => :musicbrainz_album_status,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_album_status},
-    :type         => Type::STRING,
-  },
-  
-  # musicbrainz_album_type
-  {
-    :name         => :musicbrainz_album_type,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_album_type},
-    :type         => Type::LIST,
-  },
-
-  
-  # musicbrainz_release_group_id
-  {
-    :name         => :musicbrainz_release_group_id,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_release_group_id},
-    :type         => Type::STRING,
-  },
-  
-  # musicbrainz_album_release_country
-  {
-    :name         => :musicbrainz_album_release_country,
-    :handler      => :user_info_lookup,
-    :handler_opts => {:key => :musicbrainz_album_release_country},
-    :type         => Type::STRING,
-  },
-
-  #
-  # Audio Properties
-  #
- 
-  # length 
-  {
-    :name         => :length,
-    :aliases      => [:duration],
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :length},
-    :type         => Type::INT,
-  },
-
-  # bitrate
-  {
-    :name         => :bitrate,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :bitrate},
-    :type         => Type::INT,
-  },
-
-  # sample_rate
-  {
-    :name         => :sample_rate,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :sample_rate},
-    :type         => Type::INT,
-  },
-
-  # channels
-  {
-    :name         => :channels,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :channels},
-    :type         => Type::INT,
-  },
-
-  # copyrighted?
-  {
-    :name         => :copyrighted?,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :copyrighted?},
-    :type         => Type::BOOLEAN,
-  },
-
-  # layer
-  {
-    :name         => :layer,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :layer},
-    :type         => Type::INT,
-  },
-
-  # original?
-  {
-    :name         => :original?,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :original?},
-    :type         => Type::BOOLEAN,
-  },
-
-  # protection_enabled?
-  {
-    :name         => :protection_enabled?,
-    :handler      => :read_audio_property,
-    :handler_opts => {:key => :protection_enabled},
-    :type         => Type::BOOLEAN,
-  },
-  ]
-end