id3taginator 0.8

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class ArtistsFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TP1, :TPE1, :TPE1
+
+        attr_accessor :artists
+
+        # builds the artists frame
+        #
+        # @param artists [Array<String>, String] the artist(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(artists, options = nil, id3_version: 3)
+          supported?('TPE1', id3_version, options)
+
+          argument_not_empty(artists, 'artists')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.artists = artists.is_a?(Array) ? artists : [artists]
+          frame
+        end
+
+        def process_content(content)
+          artists_str = decode_using_encoding_byte(content)
+          @artists = artists_str.split('/').map(&:strip)
+        end
+
+        def content_to_bytes
+          @artists ||= ['[unset]']
+          content = @artists.join('/')
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class AlbumArtistFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TP2, :TPE2, :TPE2
+
+        attr_accessor :album_artist
+
+        # builds the album artist frame
+        #
+        # @param album_artist [String] the album artist
+        # @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_artist, options = nil, id3_version: 3)
+          supported?('TPE2', id3_version, options)
+
+          argument_not_nil(album_artist, 'album_artist')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.album_artist = album_artist
+          frame
+        end
+
+        def process_content(content)
+          @album_artist = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@album_artist)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class ConductorFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TP3, :TPE3, :TPE3
+
+        attr_accessor :conductor
+
+        # builds the conductor frame
+        #
+        # @param conductor [String] the conductor
+        # @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(conductor, options = nil, id3_version: 3)
+          supported?('TPE3', id3_version, options)
+
+          argument_not_nil(conductor, 'conductor')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.conductor = conductor
+          frame
+        end
+
+        def process_content(content)
+          @conductor = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@conductor)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class ModifiedByFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TP4, :TPE4, :TPE4
+
+        attr_accessor :modified_by
+
+        # builds the modified by frame
+        #
+        # @param modified_by [String] the modified 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(modified_by, options = nil, id3_version: 3)
+          supported?('TPE4', id3_version, options)
+
+          argument_not_nil(modified_by, 'modified_by')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.modified_by = modified_by
+          frame
+        end
+
+        def process_content(content)
+          @modified_by = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@modified_by)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class PartOfSetFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TPA, :TPOS, :TPOS
+
+        attr_accessor :part, :total
+
+        # builds the part of set frame
+        #
+        # @param part [String, Integer] part of the set
+        # @param total [String, Integer, nil] total number of parts
+        # @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(part, total, options = nil, id3_version: 3)
+          supported?('TPOS', id3_version, options)
+
+          argument_not_nil(part, 'part')
+
+          part = part.to_s
+          total = total.to_s unless total.nil?
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.part = part
+          frame.total = total
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          tmp = content.split('/')
+          @part = tmp[0]
+          @total = tmp[1]
+        end
+
+        def content_to_bytes
+          return encode_and_add_encoding_byte(@part) if @total.nil?
+
+          encode_and_add_encoding_byte("#{@part}/#{@total}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class PublisherFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TPB, :TPUB, :TPUB
+
+        attr_accessor :publisher
+
+        # builds the publisher frame
+        #
+        # @param publisher [String] the publisher
+        # @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(publisher, options = nil, id3_version: 3)
+          supported?('TPUB', id3_version, options)
+
+          argument_not_empty(publisher, 'publisher')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.publisher = publisher
+          frame
+        end
+
+        def process_content(content)
+          @publisher = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@publisher)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class TrackNumberFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TRK, :TRCK, :TRCK
+
+        attr_accessor :track_number, :total
+
+        # builds the track number frame
+        #
+        # @param track_number [String, Integer] the track number
+        # @param total [String, Integer, nil] the total number of tracks
+        # @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(track_number, total, options = nil, id3_version: 3)
+          supported?('TRCK', id3_version, options)
+
+          argument_not_empty(track_number, 'track_number')
+
+          track_number = track_number.to_s
+          total = total.to_s unless total.nil?
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.track_number = track_number
+          frame.total = total
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          tmp = content.split('/')
+          @track_number = tmp[0]
+          @total = tmp[1]
+        end
+
+        def content_to_bytes
+          return encode_and_add_encoding_byte(@track_number) if @total.nil?
+
+          encode_and_add_encoding_byte("#{@track_number}/#{@total}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class RecordingDatesFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TRD, :TRDA, :TRDA
+
+        attr_accessor :recording_dates
+
+        # builds the recording dates frame
+        #
+        # @param recording_dates [Array<String>, String] the recording date(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(recording_dates, options = nil, id3_version: 3)
+          supported?('TRDA', id3_version, options)
+
+          argument_not_empty(recording_dates, 'recording_dates')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.recording_dates = recording_dates.is_a?(Array) ? recording_dates : [recording_dates]
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          @recording_dates = content.split(',').map(&:strip)
+        end
+
+        def content_to_bytes
+          content = @recording_dates.join(', ')
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class InternetRadioStationFrame < Id3v2Frame
+        include HasId
+
+        frame_info nil, :TRSN, :TRSN
+
+        attr_accessor :station_name
+
+        # builds the radio station frame
+        #
+        # @param station_name [String] the recording date(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(station_name, options = nil, id3_version: 3)
+          supported?('TRSN', id3_version, options)
+
+          argument_not_nil(station_name, 'station_name')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.station_name = station_name
+          frame
+        end
+
+        def process_content(content)
+          @station_name = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@station_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class SizeFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TSI, :TSIZ, nil
+
+        attr_accessor :size
+
+        # builds the size frame
+        #
+        # @param size [String, Integer] the size in bytes
+        # @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(size, options = nil, id3_version: 3)
+          supported?('TSIZ', id3_version, options)
+
+          argument_not_nil(size, 'size')
+          size = size.to_s
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.size = size
+          frame
+        end
+
+        def process_content(content)
+          @size = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@size)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class AlbumSortOrderFrame < Id3v2Frame
+        include HasId
+
+        frame_info nil, nil, :TSOA
+
+        attr_accessor :album
+
+        # builds the album sort order frame
+        #
+        # @param album [String] the album name to use for sorting
+        # @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?('TSOA', 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/tsop_performer_sort_order_frame.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class PerformerSortOrderFrame < Id3v2Frame
+        include HasId
+
+        frame_info nil, nil, :TSOP
+
+        attr_accessor :performer
+
+        # builds the performer sort order frame
+        #
+        # @param performer [String] the performer to use for sorting
+        # @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(performer, options = nil, id3_version: 3)
+          supported?('TSOP', id3_version, options)
+
+          argument_not_nil(performer, 'performer')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.performer = performer
+          frame
+        end
+
+        def process_content(content)
+          @performer = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@performer)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class TitleSortOrderFrame < Id3v2Frame
+        include HasId
+
+        frame_info nil, nil, :TSOT
+
+        attr_accessor :title
+
+        # builds the title sort order frame
+        #
+        # @param title [String] the title to use for sorting
+        # @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(title, options = nil, id3_version: 3)
+          supported?('TSOT', id3_version, options)
+
+          argument_not_nil(title, 'title')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.title = title
+          frame
+        end
+
+        def process_content(content)
+          @title = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@title)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class ISRCFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TRC, :TSRC, :TSRC
+
+        attr_accessor :isrc
+
+        # builds the ISRC frame
+        #
+        # @param isrc [String] the ISRC number, 12 characters long
+        # @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(isrc, options = nil, id3_version: 3)
+          supported?('TSRC', id3_version, options)
+
+          argument_exactly_chars(isrc, 'isrc', 12)
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.isrc = isrc
+          frame
+        end
+
+        def process_content(content)
+          @isrc = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@isrc)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class EncoderFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TSS, :TSSE, :TSSE
+
+        attr_accessor :encoder
+
+        # builds the encoder frame
+        #
+        # @param encoder [String] the ISRC number, 12 characters long
+        # @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(encoder, options = nil, id3_version: 3)
+          supported?('TSSE', id3_version, options)
+
+          argument_not_nil(encoder, 'encoder')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.encoder = encoder
+          frame
+        end
+
+        def process_content(content)
+          @encoder = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@encoder)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class UserTextInfoFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TXX, :TXXX, :TXXX
+
+        attr_accessor :description, :content
+
+        # builds the user text info frame
+        #
+        # @param description [String] the description
+        # @param content [String] the content
+        # @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(description, content, options = nil, id3_version: 3)
+          supported?('TXXX', id3_version, options)
+
+          argument_not_nil(description, 'description')
+          argument_not_nil(content, 'content')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.description = description
+          frame.content = content
+          frame
+        end
+
+        def process_content(content)
+          content_io = StringIO.new(content)
+          encoding = find_encoding(content_io.getbyte)
+
+          encoded_description = read_stream_until(content_io, zero_byte(encoding))
+          encoded_content = content_io.read
+          @description = decode(encoded_description, encoding)
+          @content = decode(encoded_content, encoding)
+        end
+
+        def content_to_bytes
+          encoded_description = encode(@description, null_terminated: true)
+          encoded_content = encode(@content)
+          merge(default_encoding_destination_byte, encoded_description, encoded_content)
+        end
+      end
+    end
+  end
+end