taglib-simple 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7c5ebc2ff008b990165196e316fc0a3bd0e1fe711f278940791fdb77a1e3c6e2
+  data.tar.gz: ebbc6897744115c86a4694a002f5ef2bc5dc5052f41d2ac95fc1f8da94923b81
+SHA512:
+  metadata.gz: ab019926e5767fc176e6c13cc4502e2b0fbca1be9cd2383b427f288a94c066b0b0b8fc2e3bea485b1b8aebf5ea23b97c26ac9d7fcc51458c188f6fb8e3e76182
+  data.tar.gz: 7b2ae8ab99a77d45a9b6190b1112f8ef52d92e242f3e37a2dc5df293db8e5e6b73f0dfacf90d48ca933757f3acd0616d6db878a8d78a50aa53b29ab11a6f8372

data/.yardopts

@@ -0,0 +1,8 @@
+--markup "markdown"
+--plugin "yard_rice"
+ext/**/*.hpp
+lib/**/*.rb
+-
+README.md
+INTERNALS.md
+

data/INTERNALS.md

@@ -0,0 +1,40 @@
+## How it works under the covers
+
+Uses the [Rice] header only library to create a Ruby c++ extension
+
+### Classes
+
+#### C++ class {TagLib::Simple::FileRef}
+- Ruby extension class wrapping [Taglib::FileRef]
+- The initial filename (or IO object) is the only Ruby object held in a C++ reference
+- When a {TagLib::Simple::FileRef} is closed, the native [TagLib::FileRef] is released, which releases memory and file handles.
+- Simple Ruby objects are used for all output.
+    - Memory content is copied, not shared
+    - No native TagLib objects are exposed to Ruby
+    - Immutable `Data` objects are used to represent [TagLib::Tag] and [TagLib::AudioProperties]
+    - Everything else is converted to String(UTF8 or binary), Integer, Array or Hash.
+- Mutating interfaces all take Hash input to avoid exposing the complexity of the underlying TagLib structures.
+- Can be used directly if preferred over {TagLib::MediaFile}.
+
+#### C++ class TagLib::Simple::IOStream (private)
+- Implements the abstract [TagLib::IOStream] interface over anything
+  that quacks like a ruby IO and that is provided to {TagLib::Simple::FileRef} constructor instead of a plain string
+  file name.
+
+#### Ruby class {TagLib::MediaFile}
+- Wraps {TagLib::Simple::FileRef} with a more idiomatic Ruby interface.
+- Quacks like a Hash where:
+    - Symbol keys represent entries from Tag and AudioProperties
+    - String keys represent keys into [TagLib::PropertyMap] or complex properties, e.g., 'TITLE', 'ARTIST'.
+    - Values are Array of String when retrieved from the underlying [TagLib::PropertyMap] structure.
+    - Values are Array of Hash, when retrieved as 'complex properties', eg 'PICTURE'.
+- Quacks like the underlying [TagLib::Tag] with attribute getters/setters the well known tags.
+- Provides attribute like getters/setters for arbitrary tags via `#method_missing`
+- Holds all the pending tag updates in a Hash instance variable and only passing them back to C++ on save. 
+
+[Rice]: https://ruby-rice.github.io/
+[Taglib::FileRef]: https://taglib.org/api/classTagLib_1_1FileRef.html
+[TagLib::Tag]: https://taglib.org/api/classTagLib_1_1Tag.html
+[TagLib::AudioProperties]: https://taglib.org/api/classTagLib_1_1AudioProperties.html
+[TagLib::PropertyMap]: https://taglib.org/api/classTagLib_1_1PropertyMap.html
+[TagLib::IOStream]: https://taglib.org/api/classTagLib_1_1IOStream.html

data/LICENSE.txt

@@ -0,0 +1,20 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,167 @@
+# taglib-simple
+
+{TagLib::MediaFile} provides an idiomatic Ruby interface over [TagLib]'s simple, abstract APIs for audio file tags.
+
+## Install
+
+```gem install taglib-simple``` 
+
+or include in your Gemfile
+```gem 'taglib-simple'```
+
+## Usage - taglib.rb
+
+Ruby script that prints tag information for a file or directory
+
+```bash
+$ taglib.rb test.mp3
+```
+```ruby
+{:title=>"Test Title",
+ :artist=>"Artist",
+ :album=>"Album",
+ :genre=>"Heavy Metal",
+ :year=>2011,
+ :track=>1,
+ :comment=>"Comments",
+ "ALBUM"=>["Album"],
+ "ALBUMARTIST"=>["Album Artist"],
+ "ALBUMARTISTSORT"=>["Sort Album Artist"],
+ "ALBUMSORT"=>["Sort Album"],
+ "ARTIST"=>["Artist"],
+ "ARTISTSORT"=>["Sort Artist"],
+ "COMMENT"=>["Comments"],
+ "COMPILATION"=>["1"],
+ "DATE"=>["2011"],
+ "DISCNUMBER"=>["1/2"],
+ "GENRE"=>["Heavy Metal"],
+ "LYRICS"=>["Lyrics"],
+ "SUBTITLE"=>["Description"],
+ "TITLE"=>["Test Title"],
+ "TRACKNUMBER"=>["1/10"],
+ :path=>"test.mp3"}
+```
+
+## Usage - in ruby code
+
+### General Read/Write
+
+```ruby
+require 'taglib_simple'
+
+TagLib::MediaFile.open(filename) do |media_file|
+  # TagLib::Tag - specific well known tags
+  media_file.tag # => <AudioTag> { title: 'The title', artist: 'An Artist', album: nil, ...}
+  
+  # Attribute like interface
+  media_file.title  # => 'The title'
+  media_file.year   # => 2024
+  media_file.title = 'New Title' # => 'New Title' (writer)
+  
+  # Hash interface (Symbol keys)
+  media_file[:title] # => 'The title'
+  
+  # TagLib::PropertyMap - arbitrary tags with normalised structure across formats
+  media_file.properties # { 'TITLE'  => ['The title'], 'ARTIST' => ['An Artist']}
+  
+  # Hash interface (String keys)
+  media_file['LANGUAGE']                       # => 'English'
+  media_file['MUSICBRAINZ_ALBUMID']            # => 'ID1234567890'
+  media_file['TITLE'] = 'A new title'          # => ['A new title']          (writer)
+  media_file['ARTISTS'] = 'Artist1', 'Artist2' # => [ 'Artist1', 'Artist2' ] (writer)
+  media_file.delete('ARTISTS')                 # => [ 'Artist1', 'Artist2' ] (delete a property, return previous value)
+  media_file['ARTISTS', all: true]             # => [ 'Artist1', 'Artist2' ] (multi-value reader)
+  media_file.fetch_all('ARTISTS', [])          # => [ 'Artist1', 'Artist2' ] or [] if not property for 'ARTISTS'
+  
+  # including 'complex' properties like cover art
+  media_file['PICTURE']                        # => { 'data' => "<binary data", 'mimeType' => "image/png" }
+  
+  # Arbitrary method like interface over the properties hash
+  media_file.language                       # => 'English'
+  media_file.musicbrainz__album_id          # => 'ID1234567890'
+  media_file.all_artists                    # => ['Artist1', 'Artist2']
+  media_file.artists = 'Artist1', 'Artist2' # => ['Artist1', 'Artist2'] (writer)
+end
+```
+Note that {TagLib::MediaFile#save! #save!} is called automatically if the media_file is 
+{TagLib::MediaFile#modified? #modified?} within the block, and {TagLib::MediaFile#close #close} is ensured as
+the block exits.
+
+
+### Read only usage
+
+For read-only operations, {TagLib::MediaFile.read} ensures the file is closed, and memory held
+within the underlying TagLib library is released, before the requested information is returned.
+
+**Default retrieves Tag and PropertyMap from Taglib, closes the file and returns the MediaFile in read-only mode**
+```ruby
+mf = TagLib::MediaFile.read(filename)
+mf.tag                   # => <AudioTag> { title: 'title' ...}
+mf.title                 # => 'title'
+mf.properties            # => { 'TITLE' => 'title', 'LYRICS' => 'la la la'}
+mf.lyrics                # => 'la la la'
+mf.complex_properties    # => {} (not retrieved from taglib)
+mf.audio_properties      # => nil (not retrieved from taglib)
+mf.closed?               # => true
+mf.writable?             # => false
+mf.title = 'New Title'   # Error! not writable.
+```
+
+**Read including cover art as a complex property**
+```ruby
+mf = TagLib::MediaFile.read(filename, complex_property_keys: ['PICTURE'])
+mf.title                 # => 'A title'
+mf.picture               # => { 'data' => "<binary data", 'mimeType' => "image/png" }
+```
+
+**Read everything taglib has about a file**
+```ruby
+mf = TagLib::MediaFile.read(filename, all: true)
+mf.tag                   # => <AudioTag>
+mf.properties            # => { 'TITLE' => 'title' ...}
+mf.complex_properties    # => { 'PICTURE' => { 'data' => "<binary data", 'mimeType' => "image/png" } ...}
+mf.audio_properties      # => <AudioProperties>
+mf.sample_rate           # 44100
+```
+
+**Read using just the Tag API**
+```ruby
+tag = TagLib::AudioTag.read(filename) # => <AudioTag>
+tag.title                             # => 'A Title'
+tag.year                              # => 1983
+```
+
+### Advanced: Working with IO Objects
+
+In addition to String based file names {TagLib::MediaFile} also supports general File and IO objects.
+
+**Read tags from standard input**
+```ruby
+$stdin.binmode
+JSON.pretty_generate(TagLib::MediaFile.read($stdin).to_h)
+```
+
+## Why? (OR: why not [taglib-ruby])
+
+The existing [taglib-ruby] gem provides a more or less direct wrapping of the full [TagLib] C++ library via [SWIG] but 
+[does not yet support the PropertyMap interface](https://github.com/robinst/taglib-ruby/issues/148).
+
+### Benefits:
+* Simple, idiomatic ruby interface.
+* Uses TagLib's builtin auto-detection capabilities to work with any audio format TagLib supports  
+* Supports complex properties - album covers embedded in tags
+* Supports Ruby IO objects in addition to plain files
+* Simplified memory management - no native [TagLib] objects are exposed to Ruby
+
+### Limitations:
+
+No access to [TagLib]'s "format specific APIs for advanced API users", ie no understanding of the underlying type
+  or structure of a file or its tags, and no access to manipulate other stream data.
+
+[TagLib]: http://taglib.github.io/
+[taglib-ruby]: https://robinst.github.io/taglib-ruby/
+[SWIG]: http://swig.org
+
+
+
+

data/bin/taglib.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Generated by Amazon Q
+
+require 'json'
+require 'yaml'
+require 'taglib_simple'
+require 'optparse'
+require 'pathname'
+require 'base64'
+
+def encode_complex_property(prop)
+  return prop.map { |item| encode_complex_property(item) } if prop.is_a?(Array)
+  return prop.transform_values { |value| encode_complex_property(value) } if prop.is_a?(Hash)
+  return Base64.strict_encode64(prop) if prop.is_a?(String) && prop.encoding == Encoding::ASCII_8BIT
+
+  prop
+end
+
+def process_file(file_path, retrieve:, path: file_path)
+  mf = TagLib::MediaFile.read(file_path, **retrieve)
+  output = mf
+           .to_h
+           # Show as single value unless entry actually has multiple values
+           .transform_values { |value| value.is_a?(Array) && value.size == 1 ? value.first : value }
+           # Base64 encode complex properties
+           .transform_values { |value| value.is_a?(Hash) ? encode_complex_property(value) : value }
+
+  output[:path] = path unless path.is_a?(IO)
+  yield output
+end
+
+def process_directory(directory, patterns:, retrieve:, &output)
+  count = 0
+  now = Time.now
+  dir_path = Pathname.new(directory).expand_path
+
+  dir_path.glob(patterns) do |file_path|
+    count += 1
+    # Use relative path as key
+    relative_path = Pathname.new(file_path).relative_path_from(dir_path).to_s
+
+    process_file(file_path, path: relative_path, retrieve: retrieve, &output)
+  end
+
+  warn "Processed #{count} files in #{Time.now - now}s"
+end
+
+def parse_options
+  options = {
+    patterns: %w[**/*.mp3 **/*.m4a **/*.flac **/*.ogg **/*.wma],
+    output: ->(h) { pp(h) }
+  }
+
+  retrieve = {}
+
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: #{$PROGRAM_NAME} [options] [DIRECTORY|FILE|-]"
+
+    opts.on('--patterns PATTERNS', Array, 'Comma-separated list of glob patterns to treat as audio files') do |patterns|
+      options[:patterns] = patterns
+    end
+
+    opts.on('-t', '--[no-]tag', 'Include tag information (default: true)') do |v|
+      retrieve[:tag] = v
+    end
+
+    opts.on('-p', '--[no-]properties', 'Include properties (default: true)') do |v|
+      retrieve[:properties] = v
+    end
+
+    opts.on('-a', '--audio-properties [ACCURACY]', %i[fast average accurate],
+            'Include audio properties (fast, average, accurate; default: none)') do |v|
+      retrieve[:audio_properties] = v || :average
+    end
+
+    opts.on('-c', '--complex [PROPERTIES]', Array, 'Comma-separated list of complex properties to retrieve') do |props|
+      retrieve[:complex_property_keys] = (props || []).empty? ? :all : props
+    end
+
+    opts.on('--[no-]all', 'Include all properties (equivalent to -t -p -a -c)') do |v|
+      retrieve[:all] = v
+      %i[tag properties].each { |r| retrieve[r] = false if retrieve[r].nil? } unless v
+    end
+
+    opts.on('-f', '--format FORMAT', %i[json pretty yaml pp],
+            'Output format (json, pretty, yaml, pp; default: pp)') do |format|
+      options[:output] =
+        case format
+        when :pretty
+          ->(h) { puts JSON.pretty_generate(h) }
+        when :json
+          ->(h) { puts JSON.generate(h) }
+        when :yaml
+          ->(h) { puts YAML.dump(h) }
+        else
+          ->(h) { pp(h) }
+        end
+    end
+
+    opts.on('-v', '--version', 'Show version information') do
+      puts "taglib-simple gem: #{TagLib::Simple::VERSION}"
+      puts "taglib library   : #{TagLib::LIBRARY_VERSION}"
+      exit
+    end
+
+    opts.on('-h', '--help', 'Show this help message') do
+      puts opts
+      exit
+    end
+  end
+
+  parser.parse!
+
+  if ARGV.length > 1
+    warn parser
+    exit 1
+  end
+
+  options[:retrieve] = retrieve
+  options[:source] =
+    if ARGV.empty?
+      if !$stdin.tty? && !$stdin.eof?
+        '-'
+      else
+        warn parser
+        exit 1
+      end
+    else
+      ARGV[0]
+    end
+  options
+end
+
+if File.basename(__FILE__) == File.basename($PROGRAM_NAME)
+  options = parse_options
+  if File.directory?(options[:source])
+    process_directory(options[:source], patterns: options[:patterns], retrieve: options[:retrieve], &options[:output])
+  elsif options[:source] == '-'
+    $stdin.binmode
+    process_file($stdin, retrieve: options[:retrieve], &options[:output])
+  else
+    process_file(options[:source], retrieve: options[:retrieve], &options[:output])
+  end
+end

data/ext/taglib_simple_fileref/FileRef.cpp

@@ -0,0 +1,270 @@
+//
+// Created by ggardner on 17/11/24.
+//
+
+#include "FileRef.hpp"
+#include "IOStream.hpp"
+#include <rice/rice.hpp>
+#include "conversions.h"
+#include <taglib/tpropertymap.h>
+#include <taglib/tstring.h>
+
+using namespace Rice;
+
+namespace TagLib {
+    namespace Simple {
+        FileRef::FileRef(const Object fileOrStream, const Object readAudioProperties) : fileRef(nullptr), stream(nullptr) {
+            TagLib::AudioProperties::ReadStyle style = rubyObjectToTagLibAudioPropertiesReadStyle(readAudioProperties);
+
+            if (IOStream::isIO(fileOrStream)) {
+                // Handle IO object inputObject
+                stream = std::make_unique<IOStream>(fileOrStream);
+                fileRef = std::make_unique<TagLib::FileRef>(stream.get(), readAudioProperties.test(), style);
+                if (fileRef->isNull())
+                    // unable to read the stream.
+                        stream.reset();
+            } else {
+                Rice::String pathStr;
+                // PathName
+                if (fileOrStream.respond_to("to_path")) {
+                    pathStr = Rice::String(fileOrStream.call("to_path"));
+                } else if (fileOrStream.is_a(rb_cString)) {
+                    pathStr = Rice::String(fileOrStream);
+                } else {
+                    throw Exception(rb_eTypeError, "expects String, Pathname or IO, got %s", fileOrStream.class_name().c_str());
+                }
+                if (pathStr.length() > 0) {
+                    TagLib::FileName fn(pathStr.c_str());
+                    fileRef = std::make_unique<TagLib::FileRef>(fn, readAudioProperties.test(), style);
+                } else {
+                    fileRef = std::make_unique<TagLib::FileRef>();
+                }
+            }
+        }
+
+        void FileRef::close()
+        {
+            if (!fileRef->isNull()) {
+                // delete the TagLib::FileRef, closing streams and release file descriptors held in TagLib C++
+                fileRef = std::make_unique<TagLib::FileRef>();
+                // note we do NOT close the IO object since we did not open it!
+                stream.reset();
+            }
+        }
+
+        bool FileRef::isValid() const {
+            // isNull checks file isValid too
+           return !fileRef->isNull();
+        }
+
+        bool FileRef::isReadOnly() const {
+            raiseInvalid();
+            return fileRef->file()->readOnly();
+        }
+
+        Object FileRef::audioProperties() const {
+            raiseInvalid();
+
+            const TagLib::AudioProperties* props = fileRef->audioProperties();
+            if (!props) {
+                return {Qnil};
+            }
+
+            // Get the Ruby AudioProperties Data class from TagLib module
+            static Object rb_cAudioProperties = Module("TagLib").const_get("AudioProperties");
+
+            // Create new AudioProperties Data instance
+            return rb_cAudioProperties.call("new", props->lengthInMilliseconds(), props->bitrate(), props->sampleRate(), props->channels() );
+        }
+
+        Object FileRef::tag() const {
+            raiseInvalid();
+
+            const TagLib::Tag* tag = fileRef->tag();
+            if (!tag) {
+                //this never seems to happen but protect anyway
+                return {Qnil};
+            }
+
+            // Get the Ruby AudioTag Data class from TagLib module
+            static Object rb_cAudioTag = Module("TagLib").const_get("AudioTag");
+
+            //  define :title, :artist, :album, :genre, :year, :track, :comment
+            return rb_cAudioTag.call("new",
+                tagLibStringToNonEmptyRubyUTF8String(tag->title()),
+                tagLibStringToNonEmptyRubyUTF8String(tag-> artist()),
+                tagLibStringToNonEmptyRubyUTF8String(tag->album()),
+                tagLibStringToNonEmptyRubyUTF8String(tag->genre()),
+                uintToNonZeroRubyInteger(tag->year()),
+                uintToNonZeroRubyInteger(tag->track()),
+                tagLibStringToNonEmptyRubyUTF8String(tag->comment())
+            );
+
+        }
+
+        void FileRef::mergeTagProperties(Object in_obj) const {
+            raiseInvalid();
+
+            Hash in = in_obj.call("to_h");
+            for (Hash::const_iterator it = in.begin(); it != in.end(); ++it) {
+                auto key = Symbol(it->key).str();
+                const Object value(it->value);
+                if (key == "title") {
+                    fileRef->tag()->setTitle(rubyStringOrNilToTagLibString(value));
+                }
+                else if (key == "artist") {
+                    fileRef->tag()->setArtist(rubyStringOrNilToTagLibString(value));
+                }
+                else if (key == "album") {
+                    fileRef->tag()->setAlbum(rubyStringOrNilToTagLibString(value));
+                }
+                else if (key == "comment") {
+                    fileRef->tag()->setComment(rubyStringOrNilToTagLibString(value));
+                }
+                else if (key == "genre") {
+                    fileRef->tag()->setGenre(rubyStringOrNilToTagLibString(value));
+                }
+                else if (key == "year") {
+                    fileRef->tag()->setYear(rubyIntegerOrNilToUInt(value));
+                }
+                else if (key == "track") {
+                    fileRef->tag()->setTrack(rubyIntegerOrNilToUInt(value));
+                } else {
+                    throw Exception(rb_eKeyError, "Unknown tag property: ", key);
+                }
+
+            }
+        }
+
+
+        Hash FileRef::properties() const {
+            raiseInvalid();
+            return tagLibPropertyMapToRubyHash(fileRef->file()->properties());
+        }
+
+        void FileRef::mergeProperties(Hash in, const bool replace_all) const {
+            raiseInvalid();
+
+            TagLib::PropertyMap properties;
+            if (!replace_all) {
+                properties = fileRef->file()->properties();
+            }
+
+            for (const auto& pair : in) {
+                properties.replace(
+                    rubyStringToTagLibString(pair.key),
+                    rubyObjectToTagLibStringList(pair.value)
+                    );
+            }
+            properties.removeEmpty();
+
+            // Set the modified properties back to the file
+            fileRef->file()->setProperties(properties);
+        }
+
+       Rice::String FileRef::toString() const {
+            std::string result = "TagLib::Simple::FileRef [";
+
+            if (this->isValid()) {
+                result += "io=" + std::string(fileRef->file()->name());
+            } else {
+                result += "valid=false";
+            }
+
+            result += "]";
+            return {result};
+        }
+
+        Rice::String FileRef::inspect() const {
+            std::string result = "TagLib::Simple::FileRef [";
+
+            if (this->isValid()) {
+                result += "io='" + std::string(fileRef->file()->name()) + "'";
+                result += ", file_type=" + std::string(typeid(*fileRef->file()).name());
+                result += ", tag_type=" + std::string(typeid(*fileRef->tag()).name());
+            } else {
+                result += "valid=false";
+            }
+            result += "]";
+            return {result};
+        }
+
+        void FileRef::save() const {
+            raiseInvalid();
+            fileRef->save();
+        }
+
+        void FileRef::raiseInvalid() const {
+            if (isValid()) { return; }
+            static Object rb_eTagLibError = Module("TagLib").const_get("Error");
+            throw Exception(rb_eTagLibError, "Taglib::FileRef is closed or invalid");
+        }
+
+        // Complex properties interface
+
+
+        Array FileRef::complexPropertyKeys() const {
+            raiseInvalid();
+#if (TAGLIB_MAJOR_VERSION < 2)
+            return {};
+#else
+            return tagLibStringListToRuby(fileRef->complexPropertyKeys());
+#endif
+        }
+
+        Array FileRef::complexProperty(Rice::String key) const {
+            raiseInvalid();
+#if (TAGLIB_MAJOR_VERSION < 2)
+            throw Rice::Exception(rb_eNotImpError, "Complex properties not available in TagLib %d", TAGLIB_MAJOR_VERSION);
+#else
+            return tagLibComplexPropertyToRuby(fileRef->complexProperties(rubyStringToTagLibString(key)));
+#endif
+        }
+
+        void FileRef::mergeComplexProperties(Hash in, const bool replace_all) const {
+            raiseInvalid();
+#if (TAGLIB_MAJOR_VERSION < 2)
+            if (in.size() > 0 ) {
+                throw Rice::Exception(rb_eNotImpError, "Complex properties not available in TagLib %d", TAGLIB_MAJOR_VERSION);
+            }
+#else
+            if (replace_all) {;
+                for (const auto& item : fileRef->file()->complexPropertyKeys()) {
+                   fileRef->file()->setComplexProperties(item,{});
+                }
+            }
+
+            for (const auto& pair : in) {
+                fileRef->file()->setComplexProperties(
+                    rubyStringToTagLibString(pair.key),
+                    rubyObjectToTagLibComplexProperty(pair.value)
+                );
+            }
+#endif
+        }
+
+
+    }
+}
+
+void define_taglib_simple_fileref(const Module& rb_mParent) {
+
+    Data_Type<TagLib::Simple::FileRef> rb_cFileRef = define_class_under<TagLib::Simple::FileRef>( { rb_mParent }, "FileRef")
+            .define_constructor(Constructor<TagLib::Simple::FileRef, TagLib::FileRef, Object, Object>(), Arg("file").keepAlive(), Arg("style") = Qnil)
+            .define_method("valid?", &TagLib::Simple::FileRef::isValid)
+            .define_method("read_only?", &TagLib::Simple::FileRef::isReadOnly)
+            .define_method("close", &TagLib::Simple::FileRef::close)
+            .define_method("audio_properties", &TagLib::Simple::FileRef::audioProperties)
+            .define_method("properties", &TagLib::Simple::FileRef::properties)
+            .define_method("tag", &TagLib::Simple::FileRef::tag)
+            .define_method("merge_properties", &TagLib::Simple::FileRef::mergeProperties,Arg("h"),Arg("r") = false)
+            .define_method("merge_tag_properties", &TagLib::Simple::FileRef::mergeTagProperties, Arg("h"))
+            .define_method("save", &TagLib::Simple::FileRef::save)
+            .define_method("to_s", &TagLib::Simple::FileRef::toString)
+            .define_method("inspect", &TagLib::Simple::FileRef::inspect)
+            .define_method("complex_property", &TagLib::Simple::FileRef::complexProperty, Arg("key"))
+            .define_method("complex_property_keys", &TagLib::Simple::FileRef::complexPropertyKeys)
+            .define_method("merge_complex_properties", &TagLib::Simple::FileRef::mergeComplexProperties, Arg("h"), Arg("r") = false)
+    ;
+
+}