taglib-simple 0.1.1

data/ext/taglib_simple_fileref/FileRef.hpp

@@ -0,0 +1,164 @@
+#pragma once
+
+#include "taglib_wrap.h"
+#include <taglib/fileref.h>
+#include <rice/rice.hpp>
+
+// Specialised constructor template to avoid the Director constructor that matches Object as first argument.
+// The use of TagLib::FileRef here is arbitrary
+template<typename T, typename... Arg_Ts>
+class Rice::Constructor<T, TagLib::FileRef, Arg_Ts...> {
+public:
+ static void construct(VALUE self, Arg_Ts... args) {
+  T *data = new T(args...);
+  detail::replace<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+ }
+};
+
+using namespace Rice;
+
+// @!yard module TagLib
+namespace TagLib {
+ // @!yard module Simple
+ namespace Simple {
+  /** @!yard
+   * # C++ extension wrapping underlying TagLib::FileRef so we can interact with it using Ruby objects
+   * class FileRef
+   */
+  class FileRef final {
+   std::unique_ptr<TagLib::FileRef> fileRef;
+   std::unique_ptr<IOStream> stream;
+
+  public:
+   /** @!yard
+    # Create a FileRef from a file or stream
+    # @param [String|:to_path|IO] file_or_stream
+    #    A file name or an io like object responding to :read, :seek and :tell
+    # @param [Symbol<:average,:fast, :accurate>|nil] read_audio_properties
+    #   :fast, :accurate, :average indicator for reading audio properties. nil/false to skip
+    def initialize(file_or_stream, read_audio_properties = nil); end
+   */
+   explicit FileRef(Object fileOrStream, Object readAudioProperties = Qnil);
+
+   ~FileRef() = default;
+
+   // Prevent copying
+   FileRef(const FileRef &) = delete;
+
+   FileRef &operator=(const FileRef &) = delete;
+
+   /** @!yard
+    # release file descriptors opened and held by TagLib
+    # @note does not close the input IO object (since we didn't open it)
+    # @return [void]
+    def close(); end
+   */
+   void close();
+
+   /** @!yard
+    # Underlying stream is open for reading
+    # @return [Boolean]
+    def valid?; end
+   */
+   bool isValid() const;
+
+   /** @!yard
+    # Is the underlying stream readonly (ie cannot update tags etc...)
+    # @return [Boolean]
+    def read_only?; end
+   */
+   bool isReadOnly() const;
+
+   /** @!yard
+    # @!group Reading Properties
+
+    # @return [AudioProperties] properties of the audio stream
+    # @return [nil] audio properties were not requested at {#initialize}
+    def audio_properties; end
+   */
+   Object audioProperties() const;
+
+   /** @!yard
+    # @return [AudioTag] normalised subset of well known tags
+    def tag; end
+   */
+   Object tag() const;
+
+   /** @!yard
+    # @return [Hash<String, Array<String>>] arbitrary String properties
+    def properties; end
+   */
+   Hash properties() const;
+
+   /** @!yard
+    # Retrieve a complex property
+    # @param [String] key the complex property to retrieve
+    # @return [Array<Hash<String>>] a list of complex property values for this key
+    #   empty if the property does not exist
+    # @since TagLib 2.x
+    def complex_property(key); end
+   */
+   Array complexProperty(Rice::String key) const;
+
+   /** @!yard
+    # @return [Array<String>] list of complex properties available in this stream
+    # @since TagLib 2.x
+    def complex_property_keys; end
+   */
+   Array complexPropertyKeys() const;
+
+   /** @!yard
+    # @!endgroup
+    # @!group Writing Properties
+
+    # @param [Hash<String,Array<String>>] props input properties to merge
+    # @param [Boolean] replace_all true will clear all existing properties, otherwise the input Hash
+    #   is merged with existing properties
+    # @return [void]
+    def merge_properties(props, replace_all = false); end
+   */
+   void mergeProperties(Hash props, bool replace_all = false) const;
+
+   /** @!yard
+    # @param [Hash<Symbol, String|Integer>|AudioTag] props input tag properties to merge.
+    #   keys must be a subset of {AudioTag} members
+    # @return [void]
+    def merge_tag_properties(props); end
+   */
+   void mergeTagProperties(Object props) const;
+
+   /** @!yard
+    # @!method merge_complex_properties(props, replace_all)
+    # @param [Hash<String,Array<Hash<String,Object>>>] props Map of complex property name to new list of
+    #   complex property values
+    # @param [Boolean] replace_all true will clear all existing complex properties before merging
+    # @since TagLib 2.x
+    # @return [void]
+
+    # @!endgroup
+   */
+   void mergeComplexProperties(Hash in, bool replace_all = false) const;
+
+   Rice::String toString() const;
+
+   Rice::String inspect() const;
+
+   /** @!yard
+    # Save updates back to the underlying file or stream
+    # @return [void]
+    def save; end
+   */
+   void save() const;
+
+  private:
+   void raiseInvalid() const;
+  };
+
+  //@!yard end # FileRef
+ }
+
+ //@!yard end # Simple
+}
+
+//@!yard end # TagLib
+void define_taglib_simple_fileref(const Module &rb_mTagLibRuby);

data/ext/taglib_simple_fileref/IOStream.cpp

@@ -0,0 +1,148 @@
+
+#include "IOStream.hpp"
+#include <rice/rice.hpp>
+#include <utility>
+#include <taglib/tiostream.h>
+#include <taglib/tbytevector.h>
+#include <ruby/io.h>
+
+using namespace Rice;
+namespace TagLib {
+namespace Simple {
+
+    IOStream::IOStream(Object ruby_io) : io(std::move(ruby_io)) {
+        // Only things like File that have a writable? method are considered writable
+        // There are techniques to use write-nonblock etc to do this, but callers using custom streams
+        // will have to work that out themselves
+        openReadOnly = ruby_io.respond_to("writable?") && ruby_io.call("writable?").test();
+    };
+
+    IOStream::~IOStream() = default;
+
+    bool IOStream::isIO(const Object& io) {
+       return io.respond_to("tell") && io.respond_to("seek") && io.respond_to("read");
+    }
+
+    TagLib::FileName IOStream::name() const {
+        return io.to_s().c_str();
+    }
+
+    TagLib::ByteVector IOStream::readBlock(unsigned long length) {
+        // Call read method on Ruby IO object
+        Object result = io.call("read", (long)length);
+
+        if (result.is_nil()) {
+            return {};
+        }
+
+        Rice::String str = Rice::String(result);
+        return {str.c_str(), static_cast<unsigned int>(str.length())};
+    }
+
+
+    void IOStream::writeBlock(const TagLib::ByteVector &data) {
+        // Convert ByteVector to Ruby string and write
+        std::string str(data.data(), data.size());
+        io.call("write", Rice::String(str));
+    }
+
+     void IOStream::insert(const TagLib::ByteVector &data, v1_unsigned_offset_type start, size_type replace) {
+        seek(start, Beginning);
+        // If replacing content, first read the content after the replace section
+        Rice::String remainder;
+        if (replace > 0) {
+            seek(static_cast<offset_type>(replace), Current);
+            remainder = io.call("read");
+        }
+
+        // Seek back and write new data
+        seek(start, Beginning);
+        writeBlock(data);
+
+        // Write remaining content if any
+        if (!remainder.is_nil()) {
+            // Write the Ruby string directly back to the IO
+            (void)io.call("write", remainder);
+        }
+
+        size_type new_length = start + data.size();
+        if (!remainder.is_nil()) {
+            new_length += remainder.length();
+        }
+
+        truncate(static_cast<offset_type>(new_length));
+    }
+
+     void IOStream::removeBlock(const v1_unsigned_offset_type start, const size_type length) {
+        // Read the content after the section to remove
+        seek(static_cast<offset_type>(start + length), Beginning);
+        Rice::String remainder = io.call("read");
+
+        // Seek back to start position
+        seek(start, Beginning);
+
+        // Write the remaining content if any
+        if (!remainder.is_nil()) {
+            (void) io.call("write", remainder);
+        }
+
+        truncate(static_cast<long>(start + remainder.length()));
+    }
+
+    bool IOStream::readOnly() const {
+        return openReadOnly;
+    }
+    bool IOStream::isOpen() const {
+        // Check if the file is open using Ruby's closed? method
+        return !io.call("closed?").test();
+    }
+
+    void IOStream::seek(offset_type offset, Position p) {
+        int whence;
+        switch(p) {
+            case Beginning:
+                whence = SEEK_SET;
+                break;
+            case Current:
+                whence = SEEK_CUR;
+                break;
+            case End:
+                whence = SEEK_END;
+                break;
+            default:
+                whence = SEEK_SET;
+        }
+
+        (void) io.call("seek", offset, whence);
+    }
+
+     offset_type IOStream::tell() const {
+        return NUM2LONG(io.call("tell"));
+    }
+
+     offset_type IOStream::length() {
+        // Store current position
+        const offset_type current = tell();
+
+        // Seek to end to get length
+        seek(0, End);
+        const offset_type file_length = tell();
+
+        // Restore original position
+        seek(current, Beginning);
+
+        return file_length;
+    }
+
+    void IOStream::clear() {
+      //nothing to do on ruby IO
+    }
+
+    // Truncate if necessary
+    // TODO: Truncate is defined on file, but not on IO
+    // but other kinds of streams are not rewritable like this anyway.
+    void IOStream::truncate(offset_type length) {
+       (void) io.call("truncate", length);
+    }
+}
+}

data/ext/taglib_simple_fileref/IOStream.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "taglib_wrap.h"
+#include <taglib/tiostream.h>
+#include <rice/rice.hpp>
+
+using namespace Rice;
+
+namespace TagLib {
+    namespace Simple {
+
+#if (TAGLIB_MAJOR_VERSION >= 2)
+        // V2 looks to have aligned with posix
+        using offset_type = offset_t;
+        using size_type = size_t;
+        // V1 had some unsigned offsets
+        using v1_unsigned_offset_type = offset_t;
+#else
+        using offset_type = long;
+        using size_type = unsigned long;
+        using v1_unsigned_offset_type = unsigned long;
+#endif
+
+
+        // An TagLib::IOStream from Ruby IO
+        class IOStream final : public TagLib::IOStream  {
+            Object io;
+        public:
+            static bool isIO(const Object& io);
+            bool openReadOnly;
+            explicit IOStream(Object ruby_io);
+
+            ~IOStream() override;
+            FileName name() const override;
+            ByteVector readBlock(unsigned long length) override;
+            void writeBlock(const ByteVector &data) override;
+            void insert(const ByteVector &data, v1_unsigned_offset_type start, size_type replace) override;
+            void removeBlock(v1_unsigned_offset_type start, size_type length) override;
+            void seek(offset_type offset, Position p) override;
+            void clear() override;
+            offset_type tell() const override;
+            offset_type length() override;
+            void truncate(offset_type length) override;
+            bool isOpen() const override;
+            bool readOnly() const override;
+        };
+    } // Ruby
+} // TagLib

data/ext/taglib_simple_fileref/conversions.h

@@ -0,0 +1,38 @@
+// Type conversations from ruby to taglib
+#pragma once
+
+#include "taglib_wrap.h"
+#include <rice/rice.hpp>
+#include <ruby/encoding.h>
+#include <taglib/audioproperties.h>
+#include <taglib/tstringlist.h>
+#if (TAGLIB_MAJOR_VERSION >=2)
+#include <taglib/tvariant.h>
+#endif
+
+#include <taglib/tpropertymap.h>
+
+using namespace Rice;
+
+namespace TagLib {
+   namespace Simple {
+      // taglib to ruby
+      Rice::Object tagLibStringToNonEmptyRubyUTF8String(TagLib::String string);
+      Rice::Object uintToNonZeroRubyInteger(unsigned integer);
+      Rice::Hash tagLibPropertyMapToRubyHash(const TagLib::PropertyMap& properties);
+      Array tagLibStringListToRuby(const TagLib::StringList& list);
+      Rice::String tagLibStringToRubyUTF8String(const TagLib::String& str);
+
+      // ruby to taglib
+      TagLib::String rubyStringOrNilToTagLibString(Object value);
+      unsigned int rubyIntegerOrNilToUInt(Object value);
+      TagLib::String rubyStringToTagLibString(const Rice::String& str);
+      TagLib::AudioProperties::ReadStyle rubyObjectToTagLibAudioPropertiesReadStyle(const Rice::Object& readStyle);
+      TagLib::StringList rubyObjectToTagLibStringList(const Rice::Object& obj);
+
+#if (TAGLIB_MAJOR_VERSION >= 2)
+      Rice::Array tagLibComplexPropertyToRuby(const TagLib::List<TagLib::VariantMap>& list);
+      TagLib::List<TagLib::VariantMap> rubyObjectToTagLibComplexProperty(const Rice::Object& obj);
+#endif
+   }
+}

data/ext/taglib_simple_fileref/convert_ruby_to_taglib.cpp

@@ -0,0 +1,205 @@
+#include "conversions.h"
+
+using namespace Rice;
+
+namespace TagLib {
+  namespace Simple {
+
+    TagLib::AudioProperties::ReadStyle rubyObjectToTagLibAudioPropertiesReadStyle(const Object& readStyle) {
+      if (!readStyle.test()) {
+        return TagLib::AudioProperties::Average;
+      }
+      const Symbol readStyleSym = {readStyle};
+      if (readStyleSym.str() == "fast") {
+        return TagLib::AudioProperties::Fast;
+      }
+      if (readStyleSym.str() == "accurate") {
+        return TagLib::AudioProperties::Accurate;
+      }
+      if (readStyleSym.str() == "average") {
+        return TagLib::AudioProperties::Average;
+      }
+        throw Rice::Exception(rb_eArgError, "Invalid read style: %s", readStyleSym.str());
+    }
+
+    String rubyStringOrNilToTagLibString(Object value) {
+        if (value.is_nil()) {
+            return { "", String::UTF8 };
+        }
+        return rubyStringToTagLibString(value);
+    }
+
+    unsigned int rubyIntegerOrNilToUInt(Object value) {
+
+        if (value.is_nil()) {
+            return 0;
+        }
+        return NUM2UINT(value);
+    }
+
+      static const rb_encoding* const UTF16LE_ENCODING = rb_enc_find("UTF-16LE");
+      static const rb_encoding* const UTF16BE_ENCODING = rb_enc_find("UTF-16BE");
+      static const rb_encoding* const UTF16_ENCODING = rb_enc_find("UTF-16");
+      static const rb_encoding* const LATIN1_ENCODING = rb_enc_find("ISO-8859-1");
+
+
+      TagLib::String rubyStringToTagLibString(const Rice::String& str) {
+          rb_encoding* enc = rb_enc_get(str);
+          if (enc == rb_utf8_encoding()) {
+              return { str.c_str(), TagLib::String::UTF8 };
+          } else if (enc == rb_ascii8bit_encoding() || enc == rb_usascii_encoding()) {
+              return { str.c_str(), TagLib::String::UTF8 };
+          } else if (enc == LATIN1_ENCODING) {
+              return { str.c_str(), TagLib::String::Latin1 };
+          } else if (enc == UTF16LE_ENCODING) {
+              return { str.c_str(), TagLib::String::UTF16LE };
+          } else if (enc == UTF16BE_ENCODING) {
+              return { str.c_str(), TagLib::String::UTF16BE };
+          } else {
+              // For any other encoding, convert to UTF-8 first
+              Rice::String utf8_str = rb_str_export_to_enc(str, rb_utf8_encoding());
+              return { utf8_str.c_str(), TagLib::String::UTF8 };
+          }
+      }
+
+    TagLib::StringList rubyObjectToTagLibStringList(const Object& obj) {
+      TagLib::StringList string_list;
+
+      // Handle both String and Array values
+      if (TYPE(obj) == T_ARRAY) {
+        Array val_array(obj);
+        if (val_array.size() > 0) {
+          for (auto it = val_array.begin(); it != val_array.end(); ++it) {
+            Rice::String item(it->value());
+            string_list.append(TagLib::String(item.c_str()));
+          }
+        }
+      } else {
+        string_list.append(Rice::String(obj).c_str());
+      }
+      return string_list;
+    }
+
+    bool isBinaryEncoding(const Rice::String& str) {
+      return rb_enc_get(str) ==  rb_ascii8bit_encoding();
+    }
+
+    TagLib::StringList rubyArrayToTagLibStringList(Array arr) {
+      TagLib::StringList stringList;
+      for (const auto& item : arr) {
+        Rice::String str = {item.value() };
+        stringList.append(TagLib::String(str.c_str(), TagLib::String::UTF8));
+      }
+      return stringList;
+    }
+
+    TagLib::ByteVectorList rubyArrayToTagLibByteVectorList(Array arr) {
+      TagLib::ByteVectorList list;
+      for (const auto& item : arr) {
+        Rice::String str = {item.value() };
+        list.append(TagLib::ByteVector(str.c_str(), str.length()));
+      }
+      return list;
+    }
+
+#if (TAGLIB_MAJOR_VERSION >= 2)
+    TagLib::Variant rubyObjectToTagLibVariant(Object &obj);
+
+    // This can be a StringList, a ByteVectorList or a List<Variant>
+    TagLib::Variant rubyArrayToTagLibVariant(Array arr) {
+        if (arr.size() == 0) {
+            return {};
+        }
+        Object first = arr[0];
+
+        // Check only first element to determine list type
+        if (first.is_a(rb_cString)) {
+            Rice::String first_str = Rice::String(first);
+            if (isBinaryEncoding(first_str)) {
+                return { rubyArrayToTagLibByteVectorList(arr) };
+            }
+            return { rubyArrayToTagLibStringList(arr) };
+        }
+
+        TagLib::List<TagLib::Variant> variantList;
+        for (const auto& item : arr) {
+            Rice::Object obj = { item.value() };
+            variantList.append(rubyObjectToTagLibVariant(obj));
+        }
+        return { variantList };
+    }
+
+
+    TagLib::Variant rubyStringToTaglibVariant(const Rice::String& str) {
+        if (isBinaryEncoding(str)) {
+            // Binary string - convert to ByteVector
+            return { TagLib::ByteVector(str.c_str(), str.length()) };
+        } else {
+            // Assume UTF-8 for all other encodings
+            return { TagLib::String(str.c_str(), TagLib::String::UTF8) };
+        }
+    }
+
+    TagLib::VariantMap rubyHashToTagLibVariantMap(const Hash& hash) {
+        TagLib::VariantMap result;
+
+        for (auto it = hash.begin(); it != hash.end(); ++it) {
+            TagLib::String key(Rice::String(it->first).c_str());
+            Rice::Object obj(it->second);
+            result.insert(key, rubyObjectToTagLibVariant(obj));
+        }
+
+        return result;
+    }
+
+    TagLib::Variant rubyObjectToTagLibVariant(Object &obj) {
+        if (obj.is_nil()) {
+            return {};
+        }
+
+        if (obj.is_a(rb_cInteger)) {
+            return {NUM2LL(obj.value())};
+        }
+
+        if (obj.is_a(rb_cString)) {
+            return rubyStringToTaglibVariant(Rice::String(obj));
+        }
+
+        if (obj.is_a(rb_cArray)) {
+            return rubyArrayToTagLibVariant(Array(obj));
+        }
+
+        if (obj.is_a(rb_cHash)) {
+            return { rubyHashToTagLibVariantMap(Hash(obj)) };
+        }
+
+        if (obj.value() == Qtrue) {
+            return {true};
+        }
+
+        if (obj.value() == Qfalse) {
+            return {false};
+        }
+
+        return {};
+    }
+
+    // This is used to set complex properties where the input must be Array<Hash>
+    TagLib::List<TagLib::VariantMap> rubyObjectToTagLibComplexProperty(const Object& obj) {
+
+        if (!obj.test()) {
+          return {};
+        }
+
+        Array list(obj);
+        TagLib::List<TagLib::VariantMap> result;
+        for (auto it = list.begin(); it != list.end(); ++it) {
+            result.append(rubyHashToTagLibVariantMap(Hash(it->value())));
+        }
+
+        return result;
+    }
+#endif
+
+  }
+}