easytag 0.2.0 → 0.3.0

data/lib/easytag/attributes/mp4.rb

@@ -0,0 +1,309 @@
+# encoding: UTF-8
+require 'easytag/attributes/base'
+
+module EasyTag::Attributes
+  # type of TagLib::MP4::Item
+  module ItemType
+    STRING         = 0 # not part of TagLib::MP4::Item, just for convenience
+    STRING_LIST    = 1
+    BOOL           = 2
+    INT            = 3
+    INT_PAIR       = 4
+    COVER_ART_LIST = 5
+  end
+
+  class MP4Attribute < BaseAttribute
+    attr_reader :name, :ivar
+
+    def initialize(args)
+      super(args)
+
+      @item_ids = args[:item_ids]
+      @item_type = args[:item_type] || ItemType::STRING
+    end
+
+    private
+
+    def item_for_id(id, iface)
+      iface.info.tag.item_list_map.fetch(id)
+    end
+
+    def data_from_item(item)
+      case @item_type
+      when ItemType::STRING
+        item.to_string_list[0]
+      when ItemType::STRING_LIST
+        item.to_string_list
+      when ItemType::BOOL
+        item.to_bool
+      when ItemType::INT
+        item.to_int
+      when ItemType::INT_PAIR
+        item.to_int_pair
+      when ItemType::COVER_ART_LIST
+        artwork = []
+        item.to_cover_art_list.each do |img| 
+          artwork << EasyTag::Image.new(img.data)
+        end
+        artwork
+      else
+        nil
+      end
+    end
+
+    # read handlers
+    
+    def read_first_item(iface)
+      item = nil
+      @item_ids.each do |id|
+        item = item_for_id(id, iface) if item.nil?
+      end
+      
+      data_from_item(item) unless item.nil?
+    end
+
+    def read_user_info(iface)
+      kv_hash = {}
+      iface.info.tag.item_list_map.to_a.each do |key, value|
+        match_data = key.match(/\:com.apple.iTunes\:(.*)/)
+        if match_data
+          key = match_data[1]
+          key = Utilities.normalize_string(key) if @options[:normalize]
+          key = key.to_sym if @options[:to_sym]
+          kv_hash[key] = value.to_string_list[0]
+        end
+      end
+
+      kv_hash
+    end
+
+  end
+end
+
+module EasyTag::Attributes
+  MP4_ATTRIB_ARGS = [
+  # title
+  {
+    :name       => :title,
+    :item_ids   => ['©nam'],
+    :handler    => :read_first_item,
+  },
+
+  # title_sort_order
+  {
+    :name       => :title_sort_order,
+    :item_ids   => ['sonm'],
+    :handler    => :read_first_item,
+  },
+
+  # artist
+  {
+    :name       => :artist,
+    :item_ids   => ['©ART'],
+    :handler    => :read_first_item,
+  },
+
+  # artist_sort_order
+  {
+    :name       => :artist_sort_order,
+    :item_ids   => ['soar'],
+    :handler    => :read_first_item,
+  },
+
+  # album_artist
+  {
+    :name       => :album_artist,
+    :item_ids   => ['aART'],
+    :handler    => :read_first_item,
+  },
+
+  # album_artist_sort_order
+  {
+    :name       => :album_artist_sort_order,
+    :item_ids   => ['soaa'],
+    :handler    => :read_first_item,
+  },
+
+  # album
+  {
+    :name       => :album,
+    :item_ids   => ['©alb'],
+    :handler    => :read_first_item,
+  },
+
+  # album_sort_order
+  {
+    :name       => :album_sort_order,
+    :item_ids   => ['soal'],
+    :handler    => :read_first_item,
+  },
+
+  # genre
+  {
+    :name       => :genre,
+    :item_ids   => ['©gen'],
+    :handler    => :read_first_item,
+  },
+
+  # comments
+  {
+    :name       => :comments,
+    :item_ids   => ['©cmt'],
+    :handler    => :read_first_item,
+    :item_type  => ItemType::STRING_LIST,
+    :default    => [],
+  },
+
+  # comment
+  {
+    :name       => :comment,
+    :handler    => lambda { |iface| iface.comments.first }
+  },
+
+  # lyrics
+  {
+    :name       => :lyrics,
+    :item_ids   => ['©lyr'],
+    :handler    => :read_first_item,
+  },
+
+  # date
+  {
+    :name       => :date,
+    :item_ids   => ['©day'],
+    :handler    => :read_first_item,
+    :type       => Type::DATETIME,
+  },
+
+  # year
+  {
+    :name         => :year,
+    :handler      => lambda { |iface| iface.date.nil? ? 0 : iface.date.year }
+  },
+
+  # apple_id
+  {
+    :name       => :apple_id,
+    :item_ids   => ['apid'],
+    :handler    => :read_first_item,
+  },
+
+  # encoded_by
+  {
+    :name       => :encoded_by,
+    :item_ids   => ['©enc'],
+    :handler    => :read_first_item,
+  },
+
+  # encoder_settings
+  {
+    :name       => :encoder_settings,
+    :item_ids   => ['©too'],
+    :handler    => :read_first_item,
+  },
+
+  # group
+  {
+    :name       => :group,
+    :item_ids   => ['©grp'],
+    :handler    => :read_first_item,
+  },
+
+  # compilation?
+  {
+    :name       => :compilation?,
+    :item_ids   => ['cpil'],
+    :handler    => :read_first_item,
+    :item_type  => ItemType::BOOL,
+    :default    => false,
+  },
+
+  # bpm
+  {
+    :name       => :bpm,
+    :item_ids   => ['tmpo'],
+    :handler    => :read_first_item,
+    :item_type  => ItemType::INT,
+    :default    => 0,
+  },
+
+  # copyright
+  {
+    :name       => :copyright,
+    :item_ids   => ['cprt'],
+    :handler    => :read_first_item,
+  },
+
+  # track_num
+  {
+    :name       => :track_num,
+    :item_ids   => ['trkn'],
+    :handler    => :read_first_item,
+    :item_type  => ItemType::INT_PAIR,
+    :default    => [0, 0],
+  },
+
+  # disc_num
+  {
+    :name       => :disc_num,
+    :item_ids   => ['disk'],
+    :handler    => :read_first_item,
+    :item_type  => ItemType::INT_PAIR,
+    :default    => [0, 0],
+  },
+
+  # album_art
+  {
+    :name       => :album_art,
+    :item_ids   => ['covr'],
+    :handler    => :read_first_item,
+    :item_type  => ItemType::COVER_ART_LIST,
+    :default    => [],
+  },
+
+  # user_info
+  {
+    :name       => :user_info,
+    :handler    => :read_user_info,
+    :default    => {},
+    :options    => {:normalize => true, :to_sym => true},
+  },
+
+  # subtitle
+  {
+    :name       => :subtitle,
+    :handler    => lambda { |iface| iface.user_info[:subtitle] }
+  },
+
+  # disc_subtitle
+  {
+    :name       => :disc_subtitle,
+    :handler    => lambda { |iface| iface.user_info[:discsubtitle] }
+  },
+
+  # media
+  {
+    :name       => :media,
+    :handler    => lambda { |iface| iface.user_info[:media] }
+  },
+
+  # label
+  {
+    :name       => :label,
+    :handler    => lambda { |iface| iface.user_info[:label] }
+  },
+
+  # composer
+  {
+    :name       => :composer,
+    :handler    => lambda { |iface| iface.user_info[:composer] }
+  },
+
+  # lyricist
+  {
+    :name       => :lyricist,
+    :handler    => lambda { |iface| iface.user_info[:lyricist] }
+  },
+
+  ]
+end

data/lib/easytag/interfaces/mp3.rb

@@ -1,186 +1,53 @@
 require 'mp3info'
+require 'yaml'
 
-require 'easytag'
+require 'easytag/attributes/mp3'
 
 module EasyTag::Interfaces
 
   class MP3 < Base
     def initialize(file)
       @info = TagLib::MPEG::File.new(file)
-      @id3v1 = @info.id3v1_tag
-      @id3v2 = @info.id3v2_tag
 
-      # this is required because taglib hash issues with the TDAT/TYER
+      add_tdat_to_taglib(file)
+    end
+
+    private
+
+    def add_tdat_to_taglib(file)
+      # this is required because taglib hash issues with the TDAT+TYER
       # frame (https://github.com/taglib/taglib/issues/127)
-      @id3v2_hash = ID3v2.new
+      id3v2_hash = ID3v2.new
 
       File.open(file) do |fp|
         fp.read(3) # read past ID3 identifier
         begin
-          @id3v2_hash.from_io(fp)
+          id3v2_hash.from_io(fp)
         rescue ID3v2Error => e
           warn 'no id3v2 tags found'
         end
       end
 
-    end
-
-    def title
-      obj_for_frame_id('TIT2') or Base.obj_or_nil(@id3v1.title)
-    end
-
-    def title_sort_order
-      # TSOT - (v2.4 only)
-      # XSOT - Musicbrainz Picard custom
-      obj_for_frame_id('TSOT') || obj_for_frame_id('XSOT')
-    end
-
-    def artist
-      obj_for_frame_id('TPE1') or Base.obj_or_nil(@id3v1.artist)
-    end
-
-    def artist_sort_order
-      # TSOP - (v2.4 only)
-      # XSOP - Musicbrainz Picard custom
-      obj_for_frame_id('TSOP') || obj_for_frame_id('XSOP')
-    end
-
-    def album_artist
-      obj_for_frame_id('TPE2')
-    end
-
-    def album_artist_sort_order
-      user_info[:albumartistsort]
-    end
-
-    def album
-      obj_for_frame_id('TALB') or Base.obj_or_nil(@id3v1.album)
-    end
-
-    def album_sort_order
-      # TSOA - (v2.4 only)
-      # XSOA - Musicbrainz Picard custom
-      obj_for_frame_id('TSOA') || obj_for_frame_id('XSOA')
-    end
-
-    # REVIEW: TCON supports genre refining, which we currently don't utilize
-    def genre
-      obj_for_frame_id('TCON') or Base.obj_or_nil(@id3v1.genre)
-    end
-
-    def comments
-      return @comments unless @comments.nil?
-
-      comm_frame = lookup_frames('COMM').first
-      comm_str = comm_frame ? comm_frame.text : @id3v1.comment
-
-      @comments = Base.obj_or_nil(comm_str)
-    end
-
-    def year
-      date.nil? ? 0 : date.year
-    end
-
-    def date
-      return @date unless @date.nil?
-
-      v10_year = @id3v1.year.to_s if @id3v1.year > 0
-      v23_year = obj_for_frame_id('TYER')
-      v23_date = Base.obj_or_nil(@id3v2_hash['TDAT'])
-      v24_date = obj_for_frame_id('TDRC')
+      # delete all TDAT frames (taglib-ruby segfaults when trying to read)
+      frames = @info.id3v2_tag.frame_list('TDAT')
+      frames.each { |frame| @info.id3v2_tag.remove_frame(frame) } 
 
-      # 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
-      puts "MP3#date: date_str = \"#{date_str}\"" if $DEBUG
+      if id3v2_hash['TDAT']
+        frame = TagLib::ID3v2::TextIdentificationFrame
+          .new('TDAT', TagLib::String::UTF8) 
 
-      @date = EasyTag::Utilities.get_datetime(date_str)
-    end
-
-    def original_date
-      return @original_date unless @original_date.nil?
-
-      # TDOR - orig release date (v2.4 only)
-      # TORY - orig release year (v2.3)
-      date_str = obj_for_frame_id('TDOR') ||  obj_for_frame_id('TORY')
-      @original_date ||= EasyTag::Utilities.get_datetime(date_str)
-    end
-
-    def album_art
-      return @album_art unless @album_art.nil?
-
-      @album_art = []
-      @id3v2.frame_list('APIC').each do |apic|
-        img           = EasyTag::Image.new(apic.picture)
-        img.desc      = apic.description
-        img.type      = apic.type
-        img.mime_type = apic.mime_type
-
-        @album_art << img
+        frame.text = id3v2_hash['TDAT']
+        @info.id3v2_tag.add_frame(frame)
       end
-
-      @album_art
     end
 
-    def track_num
-      return @track_num unless @track_num.nil?
-
-      pair = int_pair_for_frame_id('TRCK')
-      @track_num = (pair == [0, 0]) ? [@id3v1.track, 0] : pair
-    end
-
-    def disc_num
-      int_pair_for_frame_id('TPOS')
-    end
-
-    def user_info
-      return @user_info unless @user_info.nil?
-
-      @user_info = {}
-      lookup_frames('TXXX').each do |frame|
-        key, value = frame.field_list
-        key = EasyTag::Utilities.normalize_string(key)
-        @user_info[key.to_sym] = value
+    EasyTag::Attributes::MP3_ATTRIB_ARGS.each do |attrib_args|
+      attrib = EasyTag::Attributes::MP3Attribute.new(attrib_args)
+      define_method(attrib.name) do
+        instance_variable_get(attrib.ivar) || 
+          instance_variable_set(attrib.ivar, attrib.call(self))
       end
-
-      @user_info
     end
 
-    def disc_subtitle
-      obj_for_frame_id('TSST')
-    end
-
-    def media
-      obj_for_frame_id('TMED')
-    end
-
-    def label
-      obj_for_frame_id('TPUB')
-    end
-
-    private
-
-    # for TPOS and TRCK
-    def int_pair_for_frame_id(frame_id)
-      str = obj_for_frame_id(frame_id)
-      EasyTag::Utilities.get_int_pair(str)
-    end
-
-    def obj_for_frame_id(frame_id)
-      Base.obj_or_nil(lookup_first_field(frame_id))
-    end
-
-    def lookup_frames(frame_id)
-      frames = @id3v2.frame_list(frame_id)
-    end
-
-    # get the first field in the first frame
-    def lookup_first_field(frame_id)
-      frame = lookup_frames(frame_id).first
-      warn "frame '#{frame_id}' is not present" if frame.nil?
-      frame.field_list.first unless frame.nil?
-    end
   end
 end
-