taglib-simple 0.1.1

data/ext/taglib_simple_fileref/convert_taglib_to_ruby.cpp

@@ -0,0 +1,133 @@
+#include "conversions.h"
+#include <ruby/encoding.h>
+
+using namespace Rice;
+
+namespace TagLib {
+    namespace Simple {
+
+    Object tagLibStringToNonEmptyRubyUTF8String(TagLib::String string) {
+        if (string.length() == 0) {
+            return {Qnil};
+        }
+        return { tagLibStringToRubyUTF8String(string) };
+    }
+
+    Object uintToNonZeroRubyInteger(unsigned integer) {
+        if (integer == 0) {
+            return {Qnil};
+        }
+        return { UINT2NUM(integer) };
+    }
+
+    Rice::String tagLibStringToRubyUTF8String(const TagLib::String& str) {
+        Rice::String rb_str(str.to8Bit(true));  // true ensures UTF-8
+        rb_enc_associate(rb_str.value(), rb_utf8_encoding());
+        return rb_str;
+    }
+
+    Array tagLibStringListToRuby(const TagLib::StringList& list) {
+        Array result;
+        for (const auto& str : list) {
+            result.push(tagLibStringToRubyUTF8String(str));
+        }
+        return result;
+    }
+
+    Rice::String tagLibByteVectorToRuby(const TagLib::ByteVector& byteVector) {
+        // Convert ByteVector to Ruby String with binary encoding
+        Rice::String rb_str(std::string(byteVector.data(), byteVector.size()));
+        rb_enc_associate(rb_str.value(), rb_ascii8bit_encoding());
+        return rb_str;
+    }
+
+    Array tagLibByteVectorListToRuby(const TagLib::ByteVectorList& list) {
+        Array result;
+        for (const auto& byteVector : list) {
+            result.push(tagLibByteVectorToRuby((byteVector)));
+        }
+        return result;
+    }
+
+    Hash tagLibPropertyMapToRubyHash(const TagLib::PropertyMap& properties) {
+         Hash result;
+         // Iterate through the PropertyMap
+         for(auto & property : properties) {
+
+             Rice::String key = tagLibStringToRubyUTF8String(property.first);
+
+             // Convert the StringList to Ruby Array
+             Array values;
+             for(const auto& item : property.second) {
+               values.push(tagLibStringToRubyUTF8String(item));
+             }
+             // Add to result hash
+             values.freeze();
+             result[key] = values;
+         }
+
+         result.freeze();
+         return result;
+     }
+#if (TAGLIB_MAJOR_VERSION >= 2)
+    Object taglibVariantToRuby(const TagLib::Variant &value);
+
+    Hash taglibVariantMapToRuby(const TagLib::Map<TagLib::String, TagLib::Variant> & map) {
+        Hash result;
+        for (const auto& pair : map) {
+            Rice::String key(pair.first.toCString());
+            const TagLib::Variant& value = pair.second;
+            result[key] = taglibVariantToRuby(value);
+        }
+        return result;
+    }
+
+    Array taglibVariantListToRuby(const TagLib::List<TagLib::Variant> & list) {
+        Array result;
+        for (const auto& item : list) {
+            result.push(taglibVariantToRuby(item));
+        }
+        return result;
+    }
+
+    Object taglibVariantToRuby(const TagLib::Variant &value) {
+        switch (value.type()) {
+            case TagLib::Variant::Bool:
+                return value.toBool() ? Qtrue : Qfalse;
+            case TagLib::Variant::Int:
+                return INT2NUM(value.toInt());
+            case TagLib::Variant::UInt:
+                return UINT2NUM(value.toUInt());
+            case TagLib::Variant::LongLong:
+                return LL2NUM(value.toLongLong());
+            case TagLib::Variant::ULongLong:
+                return ULL2NUM(value.toULongLong());
+            case TagLib::Variant::String:
+                return { tagLibStringToRubyUTF8String(value.toString()) };
+            case TagLib::Variant::StringList:
+                return { tagLibStringListToRuby(value.toStringList()) };
+            case TagLib::Variant::ByteVector:
+                return { tagLibByteVectorToRuby(value.toByteVector()) };
+            case TagLib::Variant::ByteVectorList:
+                return { tagLibByteVectorListToRuby(value.toByteVectorList()) };
+            case TagLib::Variant::VariantList:
+                return { taglibVariantListToRuby(value.toList()) };
+            case TagLib::Variant::VariantMap:
+                return { taglibVariantMapToRuby(value.toMap()) };
+            default:
+               return Qnil;
+        }
+    }
+
+    Array tagLibComplexPropertyToRuby(const TagLib::List<TagLib::VariantMap>& list) {
+        Array result;
+
+        for (const auto& variantMap : list) {
+            result.push(taglibVariantMapToRuby(variantMap));
+        }
+
+        return result;
+    }
+#endif
+    }
+}

data/ext/taglib_simple_fileref/extconf.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'mkmf-rice'
+
+# --with-taglib-dir - the install dir that a custom build of taglib has been deployed to.
+dir = with_config('taglib-dir')
+if dir && !dir.empty?
+  dir = Pathname.new(dir)
+  dir = dir.expand_path if dir.to_s.start_with?('~') # ~/.local
+  # treat relative paths as relative to the project root
+  dir = Pathname.new(__FILE__).dirname.parent.parent.expand_path / dir if dir.relative?
+  raise "TAGLIB_DIR does not exist: #{dir}" unless dir.directory?
+
+  dir_config('tag', dir.to_path)
+end
+
+have_library('tag') || abort('TagLib is required')
+
+append_cppflags('-g,-DDEBUG') if enable_config('debug')
+
+# Add to existing flags
+append_ldflags('-Wl,--no-undefined')
+create_makefile('taglib_simple_fileref')

data/ext/taglib_simple_fileref/taglib_simple_fileref.cpp

@@ -0,0 +1,57 @@
+
+#include "FileRef.hpp"
+#if TAGLIB_MAJOR_VERSION > 1
+#include <taglib/tversionnumber.h>
+#endif
+
+extern "C"
+void Init_taglib_simple_fileref() {
+    Module rb_mTagLib = define_module("TagLib");
+    Module rb_mTagLibExt = define_module_under({rb_mTagLib},"Simple");
+
+    define_taglib_simple_fileref(rb_mTagLibExt);
+
+    uint major;
+    uint minor;
+    uint patch;
+    Rice::String version;
+
+#if TAGLIB_MAJOR_VERSION == 1
+    // Taglib 1 does not have runtime version information
+    major = TAGLIB_MAJOR_VERSION;
+    minor = TAGLIB_MINOR_VERSION;
+    patch = TAGLIB_PATCH_VERSION;
+
+    version = Rice::String::format("%d.%d.%d", TAGLIB_MAJOR_VERSION, TAGLIB_MINOR_VERSION, TAGLIB_PATCH_VERSION);
+#else
+
+    TagLib::VersionNumber runtime_version = TagLib::runtimeVersion();
+
+    major = runtime_version.majorVersion();
+    minor = runtime_version.minorVersion();
+    patch = runtime_version.patchVersion();
+    version = runtime_version.toString().toCString();
+
+    // Fatal error on major version mismatch
+    if (TAGLIB_MAJOR_VERSION != runtime_version.majorVersion()) {
+        rb_raise(rb_eLoadError,
+        "Incompatible TagLib version. Compiled with %d.%d.%d but loaded %s",
+            TAGLIB_MAJOR_VERSION, TAGLIB_MINOR_VERSION, TAGLIB_PATCH_VERSION, version.c_str());
+
+    }
+
+    // Warning if compiled against a minor version that is newer than the runtime library
+    if (TAGLIB_MINOR_VERSION > runtime_version.minorVersion()) {
+        rb_warn(
+            "TagLib runtime version %s is older than compile-time version %d.%d.%d",
+            version.c_str(), TAGLIB_MAJOR_VERSION, TAGLIB_MINOR_VERSION, TAGLIB_PATCH_VERSION
+            );
+    }
+#endif
+
+    rb_mTagLib.const_set("MAJOR_VERSION", UINT2NUM(major));
+    rb_mTagLib.const_set("MINOR_VERSION", UINT2NUM(minor));
+    rb_mTagLib.const_set("PATCH_VERSION", UINT2NUM(patch));
+    rb_mTagLib.const_set("LIBRARY_VERSION", {version});
+
+}

data/ext/taglib_simple_fileref/taglib_wrap.h

@@ -0,0 +1,5 @@
+
+#pragma once
+
+// this is just a placeholder in case we need to define things before including taglib
+

data/lib/taglib_simple/audio_properties.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module TagLib
+  AudioProperties = Data.define(:audio_length, :bitrate, :sample_rate, :channels)
+
+  # Represents the audio properties of a media file
+  # @see https://taglib.org/api/classTagLib_1_1AudioProperties.html`
+  class AudioProperties < Data
+    # @!attribute [r] audio_length
+    #   @return [Integer] The length of the audio in milliseconds
+
+    # @!attribute [r] bitrate
+    #   @return [Integer] The bitrate of the audio in kb/s
+
+    # @!attribute [r] sample_rate
+    #   @return [Integer] The sample rate in Hz
+
+    # @!attribute [r] channels
+    #   @return [Integer] The number of audio channels
+
+    class << self
+      # @param [String|:to_path|IO] filename
+      # @param [Symbol<:average, :fast, :accurate>] audio_properties read style
+      # @return [AudioProperties]
+      def read(filename, audio_properties: true)
+        raise ArgumentError, 'audio_properties must be one of :average, :fast, :accurate' unless audio_properties
+
+        Taglib::MediaFile.open(filename, audio_properties:, &:audio_properties)
+      end
+    end
+  end
+end

data/lib/taglib_simple/audio_tag.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module TagLib
+  AudioTag = Data.define :title, :artist, :album, :genre, :year, :track, :comment
+
+  # Represents a normalised subset of tags
+  # @see https://taglib.org/api/classTagLib_1_1Tag.html
+  class AudioTag < Data
+    # @!attribute [r] title
+    # @return [String] The title of the track
+
+    # @!attribute [r] artist
+    #  @return [String] The artist name
+
+    # @!attribute [r] album
+    #   @return [String] The album name
+
+    # @!attribute [r] genre
+    #   @return [String] The genre of the track
+
+    # @!attribute [r] year
+    #   @return [Integer] The release year
+
+    # @!attribute [r] track
+    #   @return [Integer] The track number
+
+    # @!attribute [r] comment
+    #   @return [String] Additional comments about the track
+
+    class << self
+      # @param [String|:to_path|IO] filename
+      # @return [AudioTag]
+      def read(filename)
+        MediaFile.open(filename, all: false, tag: true, &:tag)
+      end
+
+      # @!visibility private
+      def check_value(member, value)
+        return value if value.nil?
+
+        return check_int_value(member, value) if %i[year track].include?(member)
+
+        check_string_value(member, value)
+      end
+
+      # @!visibility private
+      def check_int_value(member, value)
+        raise TypeError, "#{member} must be a +ve integer" unless value.is_a?(Integer) && value >= 0
+
+        value.zero? ? nil : value
+      end
+
+      # @!visibility private
+      def check_string_value(member, value)
+        raise TypeError, "#{member} must be a string" unless value.is_a?(String)
+
+        value.empty? ? nil : value
+      end
+    end
+
+    # @return [Hash<Symbol, <String,Integer>>] the tag values as a hash, excluding entries with nil values
+    def to_h
+      # do not expose nil entries
+      super.compact
+    end
+  end
+end

data/lib/taglib_simple/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TagLib
+  class Error < StandardError; end
+end