riffola 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2be335b138c805162b56fb07b14d589a1c90f00fa0a6fed6c1cb9dba482151f4
+  data.tar.gz: c393edd260fc4b43a94feb327449e059a25f46a4189c2b42c1516029619703a8
+SHA512:
+  metadata.gz: fc246a663893068f9c96fcdcbe842112a0c160b63f475b98ad357e8c775613f0f279eb413ad7aad135b9644d44570824c9980493390fc4821c8514a5dd9ffb14
+  data.tar.gz: dd1956dc6c17bffcb1e37e24d33abbb3c79553a600f11a6b26267434f7467bfe283034aad8b63c8f9bf55d3de60d3341500e926febaaf26c171a45fc9314ece1

data/lib/riffola.rb

@@ -0,0 +1,240 @@
+module Riffola
+
+  # Return a list of Riff chunk objects stored in a file, from a given offset.
+  # A chunk is defined as this:
+  # * A name (4 bytes)
+  # * A size (4 bytes by default)
+  # * A header (0 bytes by default)
+  # * Data (Size bytes)
+  #
+  # Parameters::
+  # * *file* (String): The file name
+  # * *offset* (Integer): The offset to read the file from [default: 0]
+  # * *chunks_format* (Hash<String, Hash<Symbol,Object> >): Chunks format. See Chunk#initialize for details. [default = {}]
+  # * *max_size* (Integer): Maximum readable size (starting from the file's offset) to retrieve chunks, or nil to read till the end of the file [default: nil]
+  # * *parent_chunk* (Chunk or nil): Parent chunk, or nil if none [default: nil]
+  # * *warnings* (Boolean): Do we activate warnings? [default: true]
+  # * *debug* (Boolean): Do we activate debugging logs? [default: false]
+  # * Proc: Optional code called for each chunk being decoded
+  #   * Parameters::
+  #     * *chunk* (Chunk): Chunk being decoded
+  #   * Result::
+  #     * Boolean: Do we continue decoding chunks?
+  # Result::
+  # * Array<Chunk>: The chunks list
+  def self.read(file, offset: 0, chunks_format: {}, max_size: nil, parent_chunk: nil, warnings: true, debug: false)
+    chunks = []
+    max_size = File.size(file) - offset if max_size.nil?
+    chunk = max_size > 0 ? Chunk.new(file,
+      offset: offset,
+      chunks_format: chunks_format,
+      max_size: max_size,
+      parent_chunk: parent_chunk,
+      warnings: warnings,
+      debug: debug
+    ) : nil
+    while !chunk.nil?
+      chunks << chunk
+      break if block_given? && !yield(chunk)
+      chunk = chunk.next
+    end
+    chunks
+  end
+
+  class Chunk
+
+    # Define default chunk format properties
+    DEFAULT_CHUNK_FORMAT = {
+      size_length: 4,
+      header_size: 0,
+      data_size_correction: 0
+    }
+
+    # Constructor
+    #
+    # Parameters::
+    # * *file_name* (String): The file name
+    # * *offset* (Integer): The offset to read the file from [default: 0]
+    # * *chunks_format* (Hash<String, Hash<Symbol,Object> >): Format of a given set of chunk names (use '*' for all chunks). For each chunk name, the following can be specified: [default = {}]
+    #   * *size_length* (Integer): Number of bytes encoding the size of the chunk [default: 4]
+    #   * *header_size* (Integer): Size of the chunk's header [default: 0]
+    #   * *data_size_correction* (Integer): Correction to apply to the data size read [default: 0]
+    #   Each property can also be a Proc taking the file handle (positioned at the beginning of the chunk) and returning the real value:
+    #     * Parameters::
+    #       * *file* (IO): The file IO, positioned at the beginning of the chunk (at the name)
+    #     * Result::
+    #       * Object: The corresponding property value
+    # * *max_size* (Integer): Maximum readable size (starting from the file's offset) to retrieve chunks, or nil to read till the end of the file [default: nil]
+    # * *parent_chunk* (Chunk or nil): Parent chunk, or nil if none [default: nil]
+    # * *warnings* (Boolean): Do we activate warnings? [default: true]
+    # * *debug* (Boolean): Do we activate debugging logs? [default: false]
+    def initialize(file_name, offset: 0, chunks_format: {}, max_size: nil, parent_chunk: nil, warnings: true, debug: false)
+      @file_name = file_name
+      @offset = offset
+      @chunks_format = chunks_format
+      # Fill the default format if not present
+      @chunks_format['*'] = {} unless @chunks_format.key?('*')
+      DEFAULT_CHUNK_FORMAT.each do |format_property, default_property_value|
+        @chunks_format['*'][format_property] = default_property_value unless @chunks_format['*'].key?(format_property)
+      end
+      @parent_chunk = parent_chunk
+      @max_size = max_size.nil? ? File.size(@file_name) - @offset : max_size
+      @warnings = warnings
+      @debug = debug
+      # Get chunk format in instance variables named after the property
+      chunk_name = self.name
+      DEFAULT_CHUNK_FORMAT.keys.each do |format_property|
+        property_value = @chunks_format.key?(chunk_name) && @chunks_format[chunk_name].key?(format_property) ? @chunks_format[chunk_name][format_property] : @chunks_format['*'][format_property]
+        if property_value.is_a?(Proc)
+          File.open(@file_name) do |file|
+            file.seek(@offset)
+            property_value = property_value.call(file)
+          end
+        end
+        instance_variable_set(:"@#{format_property}", property_value)
+      end
+      puts "[DEBUG] - Read chunk from #{@file_name}@#{@offset}/#{@max_size}: #{chunk_name} (size length: #{@size_length}, header size: #{@header_size}, data size: #{self.size}/#{@max_size})" if @debug
+      # puts "[DEBUG] - Chunks format: #{@chunks_format.inspect}" if @debug
+    end
+
+    # Return the name of this chunk
+    #
+    # Result::
+    # * String: Chunk name
+    def name
+      chunk_name = nil
+      File.open(@file_name) do |file|
+        file.seek(@offset, IO::SEEK_CUR)
+        chunk_name = file.read(4)
+      end
+      puts "[WARNING] - Doesn't look like a valid chunk name: #{chunk_name}" if @warnings && !chunk_name =~ /^[\w ]{4}$/
+      chunk_name
+    end
+
+    # Return the size of this chunk
+    #
+    # Result::
+    # * Integer: Chunk size in bytes
+    def size
+      chunk_size = nil
+      File.open(@file_name) do |file|
+        file.seek(@offset + 4, IO::SEEK_CUR)
+        case @size_length
+        when 4
+          chunk_size = file.read(@size_length).unpack('L').first
+        when 2
+          chunk_size = file.read(@size_length).unpack('S').first
+        else
+          raise "Can't decode size field of length #{@size_length}"
+        end
+      end
+      chunk_size + @data_size_correction
+    end
+
+    # Return the header of this chunk
+    #
+    # Result::
+    # * String: Header
+    def header
+      chunk_header = nil
+      File.open(@file_name) do |file|
+        file.seek(@offset + 4 + @size_length, IO::SEEK_CUR)
+        chunk_header = file.read(@header_size)
+      end
+      chunk_header
+    end
+
+    # Return the data of this chunk
+    #
+    # Result::
+    # * String: Data
+    def data
+      chunk_data = nil
+      data_size = self.size
+      complete_header_size = 4 + @size_length + @header_size
+      puts "[WARNING] - Data size is #{data_size} but the maximum readable size is #{@max_size} and the headers have #{complete_header_size}" if @warnings && complete_header_size + data_size > @max_size
+      File.open(@file_name) do |file|
+        file.seek(@offset + complete_header_size, IO::SEEK_CUR)
+        chunk_data = file.read(data_size)
+      end
+      chunk_data
+    end
+
+    # Return the parent chunk, or nil if none
+    #
+    # Result::
+    # * Chunk or nil: The parent chunk, or nil if none
+    def parent_chunk
+      @parent_chunk
+    end
+
+    # Return a string representation of this chunk
+    #
+    # Result::
+    # * String: tring representation of this chunk
+    def to_s
+      "<Riffola-Chunk #{self.name} (#{@file_name}@#{@offset})>"
+    end
+
+    # Return the next chunk
+    #
+    # Result::
+    # * Chunk or nil: The next chunk, or nil if none
+    def next
+      complete_chunk_size = 4 + @size_length + @header_size + self.size
+      remaining_size = @max_size - complete_chunk_size
+      raise "#{self} - Remaining size for next chunk: #{remaining_size}" if remaining_size < 0
+      remaining_size > 0 ? Chunk.new(@file_name,
+        offset: @offset + complete_chunk_size,
+        chunks_format: @chunks_format,
+        max_size: remaining_size,
+        parent_chunk: @parent_chunk,
+        warnings: @warnings,
+        debug: @debug
+      ) : nil
+    end
+
+    # Return this chunk's data as a list of sub-chunks
+    #
+    # Parameters::
+    # * *data_offset* (Integer): The offset to read the sub-chunks from this chunk's data [default: 0]
+    # * *sub_chunks_format* (Hash<String, Hash<Symbol,Object> >): Chunks format. See Chunk#initialize for details. [default = @chunks_format]
+    # * *warnings* (Boolean): Do we activate warnings? [default: @warnings]
+    # * *debug* (Boolean): Do we activate debugging logs? [default: @debug]
+    # * Proc: Optional code called for each chunk being decoded
+    #   * Parameters::
+    #     * *chunk* (Chunk): Chunk being decoded
+    #   * Result::
+    #     * Boolean: Do we continue decoding chunks?
+    # Result::
+    # * Array<Chunk>: List of sub-chunks
+    def sub_chunks(data_offset: 0, sub_chunk_size_length: @size_length, sub_chunk_header_size: @header_size, sub_chunks_format: @chunks_format, warnings: @warnings, debug: @debug, &callback)
+      data_size = self.size
+      data_size > 0 ? Riffola.read(@file_name,
+        offset: @offset + 4 + @size_length + @header_size + data_offset,
+        chunks_format: sub_chunks_format,
+        max_size: data_size - data_offset,
+        parent_chunk: self,
+        warnings: @warnings,
+        debug: @debug,
+        &callback
+      ) : []
+    end
+
+    # Compare Chunks
+    #
+    # Parameters::
+    # * *other* (Object): Other object
+    # Result::
+    # * Boolean: Are objects equal?
+    def ==(other)
+      other.is_a?(Chunk) &&
+        other.name == self.name &&
+        other.size == self.size &&
+        other.header == self.header &&
+        other.data == self.data
+    end
+
+  end
+
+end

data/lib/riffola/version.rb

@@ -0,0 +1,5 @@
+module Riffola
+
+  VERSION = '0.0.1'
+
+end

data/spec/riffola_spec.rb

@@ -0,0 +1,523 @@
+require 'riffola'
+require 'tempfile'
+require 'hex_string'
+
+describe Riffola do
+
+  # Are we in debug mode?
+  #
+  # Result::
+  # * Boolean: Are we in debug mode?
+  def debug?
+    ENV['TEST_DEBUG'] == '1'
+  end
+
+  HEX_DUMP_CHARS_SIZE = 16
+
+  # Convert a given string in a debuggable hexadecimal format
+  #
+  # Parameters::
+  # * *str* (String): String to be converted
+  # Result::
+  # * String: The output
+  def hex_dump(str)
+    str.scan(/.{1,#{HEX_DUMP_CHARS_SIZE}}/m).map do |line|
+      "#{"%-#{HEX_DUMP_CHARS_SIZE * 3}s" % line.to_hex_string}| #{line.gsub(/[^[:print:]]/, '.')}"
+    end.join("\n")
+  end
+
+  # Get a string encoding chunks
+  #
+  # Parameters::
+  # * *chunks* (Array< Hash<Symbol,Object> >): List of chunks data:
+  #   * *name* (String): Chunk's name
+  #   * *data* (String): Chunk's data
+  #   * *data_size* (Integer): Chunk's data size [default = data.size]
+  #   * *header* (String): Chunk's header [default = '']
+  #   * *size_length* (Integer): Size in bytes for size encoding [default = 4]
+  # Result::
+  # * String: The encoded chunks
+  def chunks_to_str(chunks)
+    chunks.map do |chunk_info|
+      chunk_info[:header] = '' unless chunk_info.key?(:header)
+      chunk_info[:size_length] = 4 unless chunk_info.key?(:size_length)
+      chunk_info[:data_size] = chunk_info[:data].size unless chunk_info.key?(:data_size)
+      size_pack_code =
+        case chunk_info[:size_length]
+        when 2
+          'S'
+        when 4
+          'L'
+        else
+          raise "Unknown size length to encode: #{chunk_info[:size_length]}"
+        end
+      "#{chunk_info[:name]}#{[chunk_info[:data_size]].pack(size_pack_code)}#{chunk_info[:header]}#{chunk_info[:data]}"
+    end.join
+  end
+
+  # Create a file with some chunks content and call code with its file name
+  #
+  # Parameters::
+  # * *chunks* (Array< Hash<Symbol,Object> >): List of chunks data (check chunks for details). [default = []]:
+  # * Proc: Code called once the file has been created. File is deleted after code execution.
+  #   * Parameters::
+  #     * *file* (String): File name
+  def with_file_content(chunks = [])
+    Tempfile.open do |tmp_file|
+      tmp_file.write(chunks_to_str(chunks))
+      tmp_file.flush
+      puts "[Test Debug] - File #{tmp_file.path} has content:\n#{hex_dump(File.read(tmp_file))}" if debug?
+      yield tmp_file.path
+    end
+  end
+
+  # Return the chunks read from a file content
+  #
+  # Parameters::
+  # * *chunks* (Array< Hash<Symbol,Object> >): List of chunks data. See with_file_content to understand the structure. [default = []]
+  # * *chunks_format* (Object): The chunks_format parameter give to Riffola.read [default: {}]
+  # * Proc: Code called with the chunks decoded from the file
+  #   * Parameters::
+  #     * *chunks* (Array<Riffola::Chunk>): List of chunks read from the file
+  def read_chunks(chunks = [], chunks_format: {})
+    with_file_content(chunks) do |file|
+      yield Riffola.read(file, chunks_format: chunks_format, debug: debug?)
+    end
+  end
+
+  it 'reads an empty file' do
+    read_chunks do |chunks|
+      expect(chunks).to eq []
+    end
+  end
+
+  it 'reads a file containing 1 chunk' do
+    chunk_name = 'ABCD'
+    chunk_data = 'TestData'
+    read_chunks([
+      {
+        name: chunk_name,
+        data: chunk_data
+      }
+    ]) do |chunks|
+      expect(chunks.size).to eq 1
+      chunk = chunks.first
+      expect(chunk.name).to eq chunk_name
+      expect(chunk.size).to eq chunk_data.size
+      expect(chunk.data).to eq chunk_data
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks' do
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1'
+      },
+      {
+        name: 'CHK2',
+        data: 'ChunkData2'
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3'
+      }
+    ]) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with size encoded in 2 bytes' do
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1',
+        size_length: 2
+      },
+      {
+        name: 'CHK2',
+        data: 'ChunkData2',
+        size_length: 2
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3',
+        size_length: 2
+      }
+    ], chunks_format: { '*' => { size_length: 2 } }) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with headers' do
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1',
+        header: 'ChunkHeader1'
+      },
+      {
+        name: 'CHK2',
+        data: 'ChunkData2',
+        header: 'ChunkHeader2'
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3',
+        header: 'ChunkHeader3'
+      }
+    ], chunks_format: { '*' => { header_size: 12 } }) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq 'ChunkHeader1'
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData2'
+      expect(chunk.header).to eq 'ChunkHeader2'
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq 'ChunkHeader3'
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with data size correction' do
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1',
+        data_size: 4
+      },
+      {
+        name: 'CHK2',
+        data: 'ChunkData2',
+        data_size: 4
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3',
+        data_size: 4
+      }
+    ], chunks_format: { '*' => { data_size_correction: 6 } }) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with data size correction given as a Proc' do
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1',
+        data_size: 4
+      },
+      {
+        name: 'CHK2',
+        data: 'ChunkData2',
+        data_size: 4
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3',
+        data_size: 4
+      }
+    ], chunks_format: { '*' => { data_size_correction: proc { |_file| 6 } } }) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with data size correction on some chunks only' do
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1'
+      },
+      {
+        name: 'CHK2',
+        data: 'ChunkData2',
+        data_size: 4
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3',
+        data_size: 14
+      }
+    ], chunks_format: { 'CHK2' => { data_size_correction: 6 }, 'CHK3' => { data_size_correction: -4 } }) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with sub-chunks' do
+    chunk2_data = chunks_to_str([
+      {
+        name: 'SCK1',
+        data: 'SubChunkData1'
+      },
+      {
+        name: 'SCK2',
+        data: 'SubChunkData2'
+      },
+      {
+        name: 'SCK3',
+        data: 'SubChunkData3'
+      }
+    ])
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1'
+      },
+      {
+        name: 'CHK2',
+        data: chunk2_data
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3'
+      }
+    ]) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq chunk2_data.size
+      expect(chunk.data).to eq chunk2_data
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+      sub_chunks = chunks[1].sub_chunks
+      expect(sub_chunks.size).to eq 3
+      chunk = sub_chunks.first
+      expect(chunk.name).to eq 'SCK1'
+      expect(chunk.size).to eq 13
+      expect(chunk.data).to eq 'SubChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq chunks[1]
+      expect(chunk.next).to eq sub_chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'SCK2'
+      expect(chunk.size).to eq 13
+      expect(chunk.data).to eq 'SubChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq chunks[1]
+      expect(chunk.next).to eq sub_chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'SCK3'
+      expect(chunk.size).to eq 13
+      expect(chunk.data).to eq 'SubChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq chunks[1]
+      expect(chunk.next).to eq nil
+    end
+  end
+
+  it 'reads a file containing several chunks with sub-chunks having specific formats' do
+    chunk2_data = chunks_to_str([
+      {
+        name: 'SCK1',
+        data: 'SubChunkData1'
+      },
+      {
+        name: 'SCK2',
+        data: 'SubChunkData2',
+        data_size: 7
+      },
+      {
+        name: 'SCK3',
+        data: 'SubChunkData3'
+      }
+    ])
+    read_chunks([
+      {
+        name: 'CHK1',
+        data: 'ChunkData1'
+      },
+      {
+        name: 'CHK2',
+        data: chunk2_data
+      },
+      {
+        name: 'CHK3',
+        data: 'ChunkData3'
+      }
+    ], chunks_format: { 'SCK2' => { data_size_correction: 6 } }) do |chunks|
+      expect(chunks.size).to eq 3
+      chunk = chunks.first
+      expect(chunk.name).to eq 'CHK1'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK2'
+      expect(chunk.size).to eq chunk2_data.size
+      expect(chunk.data).to eq chunk2_data
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'CHK3'
+      expect(chunk.size).to eq 10
+      expect(chunk.data).to eq 'ChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq nil
+      expect(chunk.next).to eq nil
+      sub_chunks = chunks[1].sub_chunks
+      expect(sub_chunks.size).to eq 3
+      chunk = sub_chunks.first
+      expect(chunk.name).to eq 'SCK1'
+      expect(chunk.size).to eq 13
+      expect(chunk.data).to eq 'SubChunkData1'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq chunks[1]
+      expect(chunk.next).to eq sub_chunks[1]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'SCK2'
+      expect(chunk.size).to eq 13
+      expect(chunk.data).to eq 'SubChunkData2'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq chunks[1]
+      expect(chunk.next).to eq sub_chunks[2]
+      chunk = chunk.next
+      expect(chunk.name).to eq 'SCK3'
+      expect(chunk.size).to eq 13
+      expect(chunk.data).to eq 'SubChunkData3'
+      expect(chunk.header).to eq ''
+      expect(chunk.parent_chunk).to eq chunks[1]
+      expect(chunk.next).to eq nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: riffola
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Muriel Salvan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hex_string
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library reading an extended RIFF format, supporting huge files. RIFF
+  format is composed of a list of chunks, each chunk being an identifier, an encoded
+  data size, an optional header and chunk data itself. Riffola has ways to deal with
+  RIFF files taking some liberties on the RIFF format (additional headers, wrong chunk
+  size...).
+email:
+- muriel@x-aeon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/riffola.rb
+- lib/riffola/version.rb
+- spec/riffola_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Muriel-Salvan/riffola
+licenses:
+- BSD-4-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Riffola - Reading extended RIFF files
+test_files: []