id3taginator 0.8

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class FileTypeFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TFT, :TFLT, :TFLT
+
+        attr_accessor :file_type
+
+        # builds the writers frame
+        #
+        # @param file_type [Symbol, String] the file type, all FileTypes are in Text::FileTypes
+        # @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(file_type = :MPEG_1_2_LAYER_III, options = nil, id3_version: 3)
+          supported?('TFLT', id3_version, options)
+
+          argument_not_nil(file_type, 'file_type')
+
+          raise ArgumentError, "File_type isn't valid: #{file_type}" unless FileTypes.valid?(file_type)
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.file_type = file_type
+          frame
+        end
+
+        def process_content(content)
+          @file_type = FileTypes.type_by_value(decode_using_encoding_byte(content))
+        end
+
+        def content_to_bytes
+          content = FileTypes.type(@file_type)
+          encode_and_add_encoding_byte(content)
+        end
+      end
+
+      module FileTypes
+        MPEG_AUDIO = 'MPG'
+        MPEG_1_2_LAYER_I = '/1'
+        MPEG_1_2_LAYER_II = '/2'
+        MPEG_1_2_LAYER_III = '/3'
+        MPEG_2_5 = '/2.5'
+        AAC = '/AAC'
+        VQF = 'VQF'
+        PCM = 'PCM'
+
+        def self.type(type)
+          return MPEG_1_2_LAYER_III unless valid?(type)
+
+          const_get(type)
+        end
+
+        def self.type_by_value(value)
+          res = constants.find { |c| const_get(c) == value }
+          res.nil? ? :MPEG_1_2_LAYER_III : res
+        end
+
+        def self.valid?(type)
+          const_get(type)
+        rescue NameError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class TimeFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TIM, :TIME, :TIME
+
+        attr_accessor :hours, :minutes
+
+        # builds the time frame
+        #
+        # @param hours [String, Integer] the hours
+        # @param minutes [String, Integer] the minutes
+        # @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(hours, minutes, options = nil, id3_version: 3)
+          supported?('TIME', id3_version, options)
+
+          argument_not_nil(hours, 'hours')
+          argument_not_nil(minutes, 'minutes')
+          hours = pad_right(hours.to_s, 2)
+          minutes = pad_right(minutes.to_s, 2)
+          argument_less_than_chars(hours, 'hours', 2)
+          argument_less_than_chars(minutes, 'minutes', 2)
+
+          hours = pad_right(hours, 2, '0')
+          minutes = pad_right(minutes, 2, '0')
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.hours = hours
+          frame.minutes = minutes
+          frame
+        end
+
+        def process_content(content)
+          content = decode_using_encoding_byte(content)
+          if content.length != 4
+            @hours = '0'
+            @minutes = '0'
+          else
+            @hours = content[0..1]
+            @minutes = content[2..3]
+          end
+        end
+
+        def content_to_bytes
+          @hours ||= '0'
+          @minutes ||= '0'
+          content = "#{pad_right(@hours.to_s, 2, '0')}#{pad_right(@minutes.to_s, 2, '0')}"
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class TitleFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TT2, :TIT2, :TIT2
+
+        attr_accessor :title
+
+        # builds the title frame
+        #
+        # @param title [String] the title
+        # @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?('TIT2', 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/tit3_subtitle_frame.rb

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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class InitialKeyFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TKE, :TKEY, :TKEY
+
+        attr_accessor :initial_key
+
+        # builds the initial key frame
+        #
+        # @param initial_key [String] the initial key, can have up to 3 characters
+        # @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(initial_key, options = nil, id3_version: 3)
+          supported?('TKEY', id3_version, options)
+
+          argument_less_than_chars(initial_key, 'initial_key', 3)
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.initial_key = initial_key
+          frame
+        end
+
+        def process_content(content)
+          @initial_key = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@initial_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class LanguageFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TLA, :TLAN, :TLAN
+
+        attr_accessor :languages
+
+        # builds the language frame
+        #
+        # @param languages [Array<String>, String] the 3 character language(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(languages, options = nil, id3_version: 3)
+          supported?('TLAN', id3_version, options)
+
+          argument_not_empty(languages, 'languages')
+
+          langs = languages.is_a?(Array) ? languages : [languages]
+
+          raise ArgumentError, 'Languages should be 3 characters, ISO-639-2.' if langs.any? { |l| l.length != 3 }
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.languages = langs
+          frame
+        end
+
+        def process_content(content)
+          languages_str = decode_using_encoding_byte(content)
+          @languages = languages_str.split("\x00").map(&:strip)
+        end
+
+        def content_to_bytes
+          @languages ||= ['und']
+          content = @languages.join("\x00")
+          content += "\x00" if @languages.length > 1
+          encode_and_add_encoding_byte(content)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Id3Taginator
+  module Frames
+    module Text
+      class OriginalReleaseYearFrame < Id3v2Frame
+        include HasId
+
+        frame_info :TOR, :TORY, :TORY
+
+        attr_accessor :original_release_year
+
+        # builds the original release year frame
+        #
+        # @param original_release_year [String, Integer] the original release year as a 4 character string, e.g. 2020
+        # @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(original_release_year, options = nil, id3_version: 3)
+          supported?('TORY', id3_version, options)
+
+          argument_not_nil(original_release_year, 'original_release_year')
+          original_release_year = original_release_year.to_s
+          argument_exactly_chars(original_release_year, 'original_release_year', 4)
+
+          frame = new(frame_id(id3_version, options), 0, build_id3_flags(id3_version), '')
+          frame.original_release_year = original_release_year
+          frame
+        end
+
+        def process_content(content)
+          @original_release_year = decode_using_encoding_byte(content)
+        end
+
+        def content_to_bytes
+          encode_and_add_encoding_byte(@original_release_year)
+        end
+      end
+    end
+  end
+end

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

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