id3taginator 0.8

data/lib/id3taginator/frames/private_frames.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module PrivateFrames
+      include Frames::Frameable
+
+      # extracts the private frames (PRIV)
+      #
+      # @return [Array<Frames::Private::Entities::PrivateFrame>] returns the Private Frames
+      def private_frames
+        frame = find_frames(Private::PrivateFrame.frame_id(@major_version, @options))
+        return [] if frame.nil? || frame.empty?
+
+        frame.map { |f| Private::Entities::PrivateFrame.new(f.owner_id, f.private_data) }
+      end
+
+      # adds a private frame (PRIV)
+      # Multiple ones can be added, as long as they have a different owner_id
+      #
+      # @param priv [Frames::Private::Entities::PrivateFrame] the private frame to add
+      def private_frames=(priv)
+        set_frame_fields_by_selector(Private::PrivateFrame, %i[@owner_id @private_data],
+                                     ->(f) { f.owner_id == priv.owner_id },
+                                     priv.owner_id, priv.private_data)
+      end
+
+      alias add_private_frame private_frames=
+
+      # removes a pictures for the specific owner_id
+      #
+      # @param owner_id [String] the owner_id
+      def remove_private_frame(owner_id)
+        @frames.delete_if do |f|
+          f.frame_id == Private::PrivateFrame.frame_id(@major_version, @options) && f.owner_id == owner_id
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/entities/copyright.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      module Entities
+        class Copyright
+          include Extensions::Comparable
+
+          attr_accessor :year, :holder
+
+          # constructor
+          #
+          # @param year [String] the 4 character year e.g. 2020
+          # @param holder [String] the copyright holder
+          def initialize(year, holder)
+            @year = year
+            @holder = holder
+          end
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/entities/date.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      module Entities
+        class Date
+          include Extensions::Comparable
+
+          attr_accessor :month, :day
+
+          # constructor
+          #
+          # @param day [String, Integer] the day
+          # @param month [String, Integer] the month
+          def initialize(month, day)
+            @month = month
+            @day = day
+          end
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/entities/part_of_set.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      module Entities
+        class PartOfSet
+          include Extensions::Comparable
+
+          attr_accessor :part, :total
+
+          # constructor
+          #
+          # @param part [String, Integer] part of the set
+          # @param total [String, Integer, nil] total number of parts
+          def initialize(part, total)
+            @part = part
+            @total = total
+          end
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/entities/time.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      module Entities
+        class Time
+          include Extensions::Comparable
+
+          attr_accessor :hours, :minutes
+
+          # constructor
+          #
+          # @param hours [String, Integer] the hours
+          # @param minutes [String, Integer] the minutes
+          def initialize(hours, minutes)
+            @hours = hours
+            @minutes = minutes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/entities/track_number.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      module Entities
+        class TrackNumber
+          include Extensions::Comparable
+
+          attr_accessor :track_number, :total
+
+          # constructor
+          #
+          # @param track_number [String, Integer] the track number
+          # @param total [String, Integer, nil] the total number of tracks
+          def initialize(track_number, total)
+            @track_number = track_number
+            @total = total
+          end
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/entities/user_info.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      module Entities
+        class UserInfo
+          include Extensions::Comparable
+
+          attr_accessor :description, :content
+
+          # constructor
+          #
+          # @param description [String] the description
+          # @param content [String] the content
+          def initialize(description, content)
+            @description = description
+            @content = content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/talb_album_frame.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class AlbumFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TAL, :TALB, :TALB
+
+        attr_accessor :album
+
+        # builds the album frame
+        #
+        # @param album [String] the album name
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(album, options = nil, id3_version: 3)
+          supported?('TALB', id3_version, options)
+
+          argument_not_nil(album, 'album')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.album = album
+          frame
+        end
+
+        def process_content(content)
+          @album = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@album)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tbpm_bpm_frame.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class BPMFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TBP, :TBPM, :TBPM
+
+        attr_accessor :bpm
+
+        # builds the bpm frame
+        #
+        # @param album [String, Integer] the bpm
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(bpm, options = nil, id3_version: 3)
+          supported?('TBPM', id3_version, options)
+
+          argument_not_nil(bpm, 'bpm')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.bpm = bpm.to_s
+          frame
+        end
+
+        def process_content(content)
+          @bpm = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@bpm)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tcom_composer_frame.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class ComposerFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TCM, :TCOM, :TCOM
+
+        attr_accessor :composers
+
+        # builds the composer frame
+        #
+        # @param composers [Array<String>, String] the composer(s)
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(composers, options = nil, id3_version: 3)
+          supported?('TCOM', id3_version, options)
+
+          argument_not_empty(composers, 'composers')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.composers = composers.is_a?(Array) ? composers : [composers]
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          @composers = content.split('/').map(&:strip)
+        end
+
+        def content_to_bytes
+          content = @composers.join('/')
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tcon_genre_frame.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class GenreFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TCO, :TCON, :TCON
+
+        attr_accessor :genres
+
+        # builds the genre frame
+        #
+        # @param genres [Array<String, Symbol>, Symbol, String] the genre(s)
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(genres, options = nil, id3_version: 3)
+          supported?('TCON', id3_version, options)
+
+          argument_not_empty(genres, 'genres')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.genres = genres.is_a?(Array) ? genres : [genres]
+          frame
+        end
+
+        def process_content(content)
+          genre_str = decode_using_encoding_byte(content)
+          genre_ids = parse_genres(genre_str)
+
+          @genres = []
+          genre_ids.each do |g|
+            next @genres << Genres.genre(g.to_i) if g.match(/^(\d)+$/)
+            next @genres << 'Remix' if g == 'RX'
+            next @genres << 'Cover' if g == 'CR'
+
+            @genres << g
+          end
+        end
+
+        def content_to_bytes
+          raise Errors::Id3TagError, 'Genres can\'t be empty' if @genres.nil? || @genres.empty?
+
+          encode_and_add_encoding_byte(genres_to_string(@genres))
+        end
+
+        def genres_to_string(genres)
+          result = ''
+          genres.each do |genre|
+            g = Genres.genre_by_name(genre)
+            g = g.is_a?(Integer) ? "(#{g})" : "((#{g})"
+            g = '(RX)' if g == '((Remix)'
+            g = '(CR)' if g == '((Cover)'
+
+            result += g
+          end
+
+          result
+        end
+
+        def parse_genres(genres)
+          result = []
+          curr = ''
+          is_started = false
+          if genres[0] == '('
+            is_started = true
+            genres = genres[1..-1]
+          end
+          genres.each_char do |c|
+            # genre has started, but nothing has parsed, so ( is opening for custom genre like ((my genre)
+            next if c == '(' && curr.empty? && is_started
+
+            if c == '(' && !curr.empty? && is_started
+              is_started = false
+              result << curr
+              curr = ''
+              next
+            elsif c == ')' && is_started
+              is_started = false
+              result << curr
+              curr = ''
+              next
+            elsif c == '(' && !is_started
+              is_started = true
+              next
+            else
+              is_started = true
+              curr += c
+            end
+          end
+
+          result << curr unless curr.empty?
+
+          result.reject(&:empty?)
+        end
+
+        private :parse_genres
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tcop_copyright_frame.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class CopyrightFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TCR, :TCOP, :TCOP
+
+        attr_accessor :holder, :year
+
+        # builds the copyright frame
+        #
+        # @param year [String] the 4 character year e.g. 2020
+        # @param holder [String] the copyright holder
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(year, holder, options = nil, id3_version: 3)
+          supported?('TCOP', id3_version, options)
+
+          year = year.to_s unless year.nil?
+
+          argument_exactly_chars(year, 'year', 4)
+          argument_not_nil(holder, 'holder')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.year = year
+          frame.holder = holder
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          if content[4] == ' '
+            @year = content[0..3]
+            content = content[4..-1]
+          else
+            @year = 1970
+          end
+
+          content = content.gsub('Copyright ©', '')
+          @holder = content.strip
+        end
+
+        def content_to_bytes
+          content = "#{@year} #{@holder} Copyright ©"
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tdat_date_frame.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class DateFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TDA, :TDAT, :TDAT
+
+        attr_accessor :day, :month
+
+        # builds the date frame
+        #
+        # @param day [String, Integer] the day
+        # @param month [String, Integer] the month
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(day, month, options = nil, id3_version: 3)
+          supported?('TDAT', id3_version, options)
+
+          argument_not_nil(month, 'month')
+          argument_not_nil(day, 'day')
+          month = pad_right(month.to_s, 2, '0')
+          day = pad_right(day.to_s, 2, '0')
+          argument_more_than_chars(day, 'day', 2)
+          argument_more_than_chars(month, 'month', 2)
+
+          month = pad_right(month, 2, '0')
+          day = pad_right(day, 2, '0')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.day = day
+          frame.month = month
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          if content.length != 4
+            @day = '1'
+            @month = '1'
+          else
+            @day = content[0..1]
+            @month = content[2..3]
+          end
+        end
+
+        def content_to_bytes
+          @day ||= '1'
+          @month ||= '1'
+          content = "#{pad_right(@day.to_s, 2, '0')}#{pad_right(@month.to_s, 2, '0')}"
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tdly_playlist_delay_frame.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class PlaylistDelayFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TDY, :TDLY, :TDLY
+
+        attr_accessor :delay
+
+        # builds the playlist delay frame
+        #
+        # @param delay [String, Integer] the playlist delay in ms
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(delay, options = nil, id3_version: 3)
+          supported?('TDLY', id3_version, options)
+
+          argument_not_nil(delay, 'delay')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.delay = delay.to_s
+          frame
+        end
+
+        def process_content(content)
+          @delay = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@delay)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/tenc_encoded_by_frame.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class EncodedByFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TEN, :TENC, :TENC
+
+        attr_accessor :encoded_by
+
+        # builds the encoded by frame
+        #
+        # @param encoded_by [String] the encoded by
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(encoded_by, options = nil, id3_version: 3)
+          supported?('TENC', id3_version, options)
+
+          argument_not_nil(encoded_by, 'encoded_by')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.encoded_by = encoded_by
+          frame
+        end
+
+        def process_content(content)
+          @encoded_by = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@encoded_by)
+        end
+      end
+    end
+  end
+end

data/lib/id3taginator/frames/text/text_writers_frame.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class WritersFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TXT, :TEXT, :TEXT
+
+        attr_accessor :writers
+
+        # builds the writers frame
+        #
+        # @param encoded_by [Array<String>, String] the writer(s)
+        # @param options [Options::Options] options to use
+        # @param id3_version [Integer] the id3 version to build the frame for
+        #
+        # @return [Id3v2Frame] the resulting id3v2 frame
+        def self.build_frame(writers, options = nil, id3_version: 3)
+          supported?('TEXT', id3_version, options)
+
+          argument_not_empty(writers, 'writers')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.writers = writers.is_a?(Array) ? writers : [writers]
+          frame
+        end
+
+        def process_content(content)
+          writers_str = decode_using_encoding_byte(content)
+          @writers = writers_str.split('/').map(&:strip)
+        end
+
+        def content_to_bytes
+          @writers ||= ['[unset]']
+          content = @writers.join('/')
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end