flacinfo-rb 0.4 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 515af99f113f7d698f0443b909c529c12e406c845992ca5cbf896031b212bf14
+  data.tar.gz: 574ce1176c11a953d7de9d0cdcdcd62d4e60cc6373dc762d088e699a03db87f7
+SHA512:
+  metadata.gz: ac7d2d9a0fcd3bc7429c85fba5cc85065a247ef25e613ee645a8e551b42e5e5a227085d33adae1fd47777bb750b74c2e6945170161524ee19244cf01d230d5cd
+  data.tar.gz: 269e6754eeaef0fec13d77c73251168634b9a652577ead6301a76c813de92fb6ee4548017e7ad5c0db7572802604a0d359b44fe3819c0efaded6faf560dc7dd2

data/README.md

@@ -0,0 +1,52 @@
+# flacinfo-rb
+
+- Author: Darren Kirby
+- mailto:darren@dragonbyte.ca
+- License: GPL2
+
+[![Gem Version](https://badge.fury.io/rb/flacinfo-rb.svg)](https://badge.fury.io/rb/flacinfo-rb)
+
+## Quick API docs
+
+## Initializing
+
+```ruby
+require 'flacinfo'
+foo = FlacInfo.new("someSong.flac")
+```
+
+## Public attributes
+
+- `streaminfo`   - hash of STREAMINFO block metadata
+- `seektable`    - hash of arrays of seek points
+- `comment`      - array of VORBIS COMMENT block metadata
+- `tags`         - user-friendly hash of Vorbis comment metadata key=value pairs
+- `application`  - hash of APPLICATION block metadata
+- `padding`      - hash of PADDING block metadata
+- `cuesheet`     - hash of CUESHEET block metadata
+- `picture`      - hash of PICTURE block metadata
+- `flac_file`    - hash of APPLICATION Id 0x41544348 (Flac File) metadata if present
+
+## Public methods
+
+- `comment_add`       - adds a comment
+- `comment_del`       - deletes a comment
+- `hastag('str')`     - returns true if tags['str'] exists
+- `meta_flac`         - prints all META BLOCKS. (Mostly) equivelant to 'metaflac --list'
+- `padding_add!(b)`   - adds a PADDING block of size 'b' or 4096 bytes
+- `padding_del!`      - deletes the PADDING block
+- `padding_resize!`   - resizes (grow or shrink) a padding block to size 'b' or 4096 bytes
+- `print_seektable`   - pretty-print seektable hash
+- `print_streaminfo`  - pretty-print streaminfo hash
+- `print_tags`        - pretty-print tags hash
+- `raw_data_dump(?)`  - if passed a filename it will dump flac_file['raw_data'] to that file,
+                        otherwise it will dump it to the console (even if binary!)
+- `update!`           - writes comment changes to disk
+- `write_picture(?)`  - write image from PICTURE block(s) to optional file
+
+The public methods and attributes are very well documented in the source itself. Please read
+there if you don't understand any of this. You can also use Rdoc to generate HTML documentation.
+
+HELP: flacinfo-rb still does not parse cuesheets, as I have never encountered a flac file
+that contains one. If you have a flac file with a cuesheet please consider emailing it to
+me so I can add this remaining bit of code.

data/lib/flacinfo.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # = Description
 #
 # flacinfo-rb gives you access to low level information on Flac files.
@@ -11,46 +13,40 @@
 # * It parses zero or more picture blocks (METADATA_BLOCK_PICTURE)
 #   * It allows you to write the embedded images to a file.
 #
-# My goals are to create a nice native Ruby library interface which will allow
+# My goal is to create a nice native Ruby library interface which will allow
 # the user to mimic most functionality of the 'metaflac' binary programmatically.
 #
 # = Copyright and Disclaimer
 #
-# Copyright:: (c) 2006, 2007 Darren Kirby
+# Copyright:: (C) 2006 - 2026 Darren Kirby
 #
 # FlacInfo is free software. No warranty is provided and the author
 # cannot accept responsibility for lost or damaged files.
 #
-# License:: Ruby
-# Author:: Darren Kirby (mailto:bulliver@badcomputer.org)
-# Website:: http://badcomputer.org/unix/code/flacinfo/index.bot
+# License:: GPL2
+# Author:: Darren Kirby (mailto:darren@dragonbyte.ca)
+# Website:: https://github.com/DarrenKirby/flacinfo-rb
 #
 # = More information
 #
-# * There is an example irb session that shows typical usage at
-#   http://badcomputer.org/unix/code/flacinfo/index.bot
 # * The Flac spec is at:
 #   http://flac.sourceforge.net/format.html
 # * The Vorbis Comment spec is at:
 #   http://www.xiph.org/vorbis/doc/v-comment.html
 
-
 # FlacInfoError is raised for general user errors.
 # It will print a string that describes the problem.
-class FlacInfoError < StandardError
-end
+FlacInfoError = Class.new(StandardError)
 
 # FlacInfoReadError is raised when an error occurs parsing the Flac file.
-# It will print a string that describes in which block the error occured.
-class FlacInfoReadError < StandardError
-end
+# It will print a string that describes in which block the error occurred.
+FlacInfoReadError = Class.new(StandardError)
 
 # FlacInfoWriteError is raised when an error occurs writing the Flac file.
-# It will print a string that describes where the error occured.
-class FlacInfoWriteError < StandardError
-end
+# It will print a string that describes where the error occurred.
+FlacInfoWriteError = Class.new(StandardError)
 
-# Note: STREAMINFO is the only block guaranteed to be present in the Flac file.
+# STREAMINFO is the only block guaranteed to be present in the Flac file.
 # All attributes will be present but empty if the associated block is not present in the Flac file,
 # except for 'picture' which will have the key 'n' with the value '0'.
 # All 'offset' and 'block_size' values do not include the block header. All block headers are 4 bytes
@@ -60,8 +56,8 @@ class FlacInfo
   # A list of 'standard field names' according to the Vorbis Comment specification. It is certainly
   # possible to use a non-standard name, but the spec recommends against it.
   # See: http://www.xiph.org/vorbis/doc/v-comment.html
-  STANDARD_FIELD_NAMES= %w/TITLE VERSION ALBUM TRACKNUMBER ARTIST PERFORMER COPYRIGHT LICENSE
-                           ORGANIZATION DESCRIPTION GENRE DATE LOCATION CONTACT ISRC/
+  STANDARD_FIELD_NAMES = %w[TITLE VERSION ALBUM TRACKNUMBER ARTIST PERFORMER COPYRIGHT LICENSE
+                            ORGANIZATION DESCRIPTION GENRE DATE LOCATION CONTACT ISRC].freeze
 
   # Hash of values extracted from the STREAMINFO block. Keys are:
   # 'offset':: The STREAMINFO block's offset from the beginning of the file (not including the block header).
@@ -124,8 +120,8 @@ class FlacInfo
   # 'type_string':: A text value representing the picture type.
   # 'description_string':: A text description of the picture.
   # 'mime_type':: The MIME type string. May be '-->' to signify that the data part is a URL of the picture.
-  # 'colour_depth':: The color depth of the picture in bits-per-pixel.
-  # 'n_colours':: For indexed-color pictures (e.g. GIF), the number of colors used, or 0 for non-indexed pictures.
+  # 'colour_depth':: The colour depth of the picture in bits-per-pixel.
+  # 'n_colours':: For indexed-colour pictures (e.g. GIF), the number of colours used, or 0 for non-indexed pictures.
   # 'width':: The width of the picture in pixels.
   # 'height':: The height of the picture in pixels.
   # 'raw_data_offset':: The raw picture data's offset from the beginning of the file.
@@ -155,7 +151,7 @@ class FlacInfo
   #   FlacInfo.hastag?(tag)   -> bool
   #
   def hastag?(tag)
-    @tags["#{tag}"] ? true : false
+    @tags[tag.to_s] ? true : false
   end
 
   # Pretty print tags hash.
@@ -166,10 +162,9 @@ class FlacInfo
   # Raises FlacInfoError if METADATA_BLOCK_VORBIS_COMMENT is not present.
   #
   def print_tags
-    if @tags == {}
-      raise FlacInfoError, "METADATA_BLOCK_VORBIS_COMMENT not present"
-    end
-    @tags.each_pair { |key,val| puts "#{key}: #{val}" }
+    raise FlacInfoError, 'METADATA_BLOCK_VORBIS_COMMENT not present' if @tags == {}
+
+    @tags.each_pair { |key, val| puts "#{key}: #{val}" }
     nil
   end
 
@@ -180,7 +175,7 @@ class FlacInfo
   #
   def print_streaminfo
     #  No test: METADATA_BLOCK_STREAMINFO must be present in valid Flac file
-    @streaminfo.each_pair { |key,val| puts "#{key}: #{val}" }
+    @streaminfo.each_pair { |key, val| puts "#{key}: #{val}" }
     nil
   end
 
@@ -192,9 +187,8 @@ class FlacInfo
   # Raises FlacInfoError if METADATA_BLOCK_SEEKTABLE is not present.
   #
   def print_seektable
-    if @seektable == {}
-      raise FlacInfoError, "METADATA_BLOCK_SEEKTABLE not present"
-    end
+    raise FlacInfoError, 'METADATA_BLOCK_SEEKTABLE not present' if @seektable == {}
+
     puts "  seek points: #{@seektable['seek_points']}"
     n = 0
     @seektable['seek_points'].times do
@@ -217,23 +211,26 @@ class FlacInfo
     @metadata_blocks.each do |block|
       puts "METADATA block ##{n}"
       puts "  type: #{block[1]} (#{block[0].upcase})"
-      puts "  is last: #{block[2] == 0 ? "false" : "true"}"
+      puts "  is last: #{block[2].zero? ? 'false' : 'true'}"
       case block[1]
-        when 0
-          meta_stream
-        when 1
-          meta_padd
-        when 2
-          meta_app
-        when 3
-          meta_seek
-        when 4
-          meta_vorb
-        when 5
-          meta_cue
-        when 6
-          pictures_seen += 1
-          meta_pict(pictures_seen)
+      when 0
+        meta_stream
+      when 1
+        meta_pad
+      when 2
+        meta_app
+      when 3
+        meta_seek
+      when 4
+        meta_vorb
+      when 5
+        meta_cue
+      when 6
+        pictures_seen += 1
+        meta_pict(pictures_seen)
+      else
+        # This will never run ... file already parsed.
+        raise FlacInfoError, 'Unknown metadata blocktype found'
       end
       n += 1
     end
@@ -251,21 +248,18 @@ class FlacInfo
   # if there is no Flac File data present.
   #
   def raw_data_dump(outfile = nil)
-    if @flac_file == {}
-      raise FlacInfoError, "Flac File data not present"
-    end
-    if outfile == nil
+    raise FlacInfoError, 'Flac File data not present' if @flac_file == {}
+
+    if outfile.nil?
       puts @flac_file['raw_data']
     else
-      if @flac_file['mime_type'] =~ /text/
-        f = File.new(outfile, "w")
-        f.write(@flac_file['raw_data'])
-        f.close
-      else
-        f = File.new(outfile, "wb")
-        f.write(@flac_file['raw_data'])
-        f.close
-      end
+      f = if @flac_file['mime_type'] =~ /text/
+            File.new(outfile, 'w')
+          else
+            File.new(outfile, 'wb')
+          end
+      f.write(@flac_file['raw_data'])
+      f.close
     end
   end
 
@@ -283,32 +277,30 @@ class FlacInfo
   # extension appended. The argument to ':n' is which image to write in case of multiples.
   #
   def write_picture(args = {})
-    if @picture["n"] == 0
-      raise FlacInfoError, "There is no METADATA_BLOCK_PICTURE"
-    end
+    raise FlacInfoError, 'There is no METADATA_BLOCK_PICTURE' if @picture['n'].zero?
 
-    if args.has_key?(:n)
-      n = args[:n]
-    else
-      n = 1
-    end
+    n = if args.key?(:n)
+          args[:n]
+        else
+          1
+        end
 
     #  "image/jpeg" => "jpeg"
-    extension = @picture[n]["mime_type"].split("/")[1]
-
-    if not args.has_key?(:outfile)
-      if @tags["album"] == nil or @tags["album"] == ""
-        outfile = "flacimage#{n}.#{extension}"
-      else
-        #  Try to use contents of "album" tag for the filename
-        outfile = "#{@tags["album"]}#{n}.#{extension}"
-      end
-    else
-      outfile = "#{args[:outfile]}.#{extension}"
-    end
-
-    in_p  = File.new(@filename, "rb")
-    out_p = File.new(outfile, "wb")
+    extension = @picture[n]['mime_type'].split('/')[1]
+
+    outfile = if !args.key?(:outfile)
+                if [nil, ''].include?(@tags['album'])
+                  "flacimage#{n}.#{extension}"
+                else
+                  #  Try to use contents of "album" tag for the filename
+                  "#{@tags['album']}#{n}.#{extension}"
+                end
+              else
+                "#{args[:outfile]}.#{extension}"
+              end
+
+    in_p  = File.new(@filename, 'rb')
+    out_p = File.new(outfile, 'wb')
 
     out_p.binmode #  For Windows folks...
 
@@ -343,16 +335,17 @@ class FlacInfo
   # false otherwise. Remember to call 'update!' to write changes to the file.
   #
   def comment_add(name)
-    if name !~ /\w=/  #  We accept 'name=' in case you want to leave the value empty
+    if name !~ /\w=/ #  We accept 'name=' in case you want to leave the value empty
       raise FlacInfoError, "comments must be in the form 'name=value'"
     end
+
     begin
-      @comment[@comment.length] = name
+      @comment << name
       @comments_changed = 1
-    rescue
+    rescue StandardError
       return false
     end
-    return true
+    true
   end
 
   # Deletes a comment from the comment array
@@ -363,22 +356,22 @@ class FlacInfo
   # If 'str' is in the form 'name=value' only exact matches
   # will be deleted. If 'str' is in the form 'name' any and all
   # comments named 'name' will be deleted. Returns 'true' if a
-  # comment was deleted, false otherwise. Remember to call 
+  # comment was deleted, false otherwise. Remember to call
   # 'update!' to write changes to the file.
   #
   def comment_del(name)
-    bc = Array.new(@comment)  #  We need a copy
-    if name.include? "="
-      nc = @comment.delete_if { |x| x == name }
-    else
-      nc = @comment.delete_if { |x| x.split("=")[0] == name }
-    end
+    bc = Array.new(@comment) #  We need a copy
+    nc = if name.include? '='
+           @comment.delete_if { |x| x == name }
+         else
+           @comment.delete_if { |x| x.split('=')[0] == name }
+         end
 
     if nc == bc
-      return false
+      false
     else
       @comments_changed = 1
-      return true
+      true
     end
   end
 
@@ -391,11 +384,9 @@ class FlacInfo
   # size of the padding block. It defaults to 4096 bytes.
   # Returns true if successful, else false.
   #
-  def padding_add!(size=4096)
+  def padding_add!(size = 4096)
     @metadata_blocks.each do |type|
-      if type[0] == "padding"
-        raise FlacInfoError, "PADDING block exists. Use 'padding_resize!'"
-      end
+      raise FlacInfoError, "PADDING block exists. Use 'padding_resize!'" if type[0] == 'padding'
     end
     build_padding_block(size) ? true : false
   end
@@ -421,24 +412,19 @@ class FlacInfo
   # size of the new padding block. It defaults to 4096 bytes.
   # Returns true if successful, else false.
   #
-  def padding_resize!(size=4096)
-    begin
-      remove_padding_block
-      build_padding_block(size)
-      true
-    rescue
-      false
-    end
+  def padding_resize!(size = 4096)
+    remove_padding_block
+    build_padding_block(size)
   end
 
   #--
   #  This cleans up the output when using FlacInfo in irb
-  def inspect #:nodoc:
-    s = "#<#{self.class}:0x#{(self.object_id*2).to_s(16)} "
+  def inspect # :nodoc:
+    s = "#<#{self.class}:0x#{(object_id * 2).to_s(16)} "
     @metadata_blocks.each do |blk|
       s += "(#{blk[0].upcase} size=#{blk[4]} offset=#{blk[3]}) "
     end
-    s += "\b>"
+    "#{s}\b>"
   end
   #++
 
@@ -447,7 +433,7 @@ class FlacInfo
   #  The following six methods are just helpers for meta_flac
   def meta_stream
     puts "  length: #{@streaminfo['block_size']}"
-    puts "  minumum blocksize: #{@streaminfo['minimum_block']} samples"
+    puts "  minimum blocksize: #{@streaminfo['minimum_block']} samples"
     puts "  maximum blocksize: #{@streaminfo['maximum_block']} samples"
     puts "  minimum framesize: #{@streaminfo['minimum_frame']} bytes"
     puts "  maximum framesize: #{@streaminfo['maximum_frame']} bytes"
@@ -458,7 +444,7 @@ class FlacInfo
     puts "  MD5 signature: #{@streaminfo['md5']}"
   end
 
-  def meta_padd
+  def meta_pad
     puts "  length: #{@padding['block_size']}"
   end
 
@@ -466,18 +452,18 @@ class FlacInfo
     puts "  length: #{@application['block_size']}"
     puts "  id: #{@application['ID']}"
     puts "  application name: #{@application['name']}"
-    if @application['ID'] == "41544348"
+    if @application['ID'] == '41544348'
       puts "    description: #{@flac_file['description']}"
       puts "    mime type: #{@flac_file['mime_type']}"
       #  Don't want to dump binary data
       if @flac_file['mime_type'] =~ /text/
-        puts "    raw data:"
+        puts '    raw data:'
         puts @flac_file['raw_data']
       else
         puts "'Flac File' data may be binary. Use 'raw_data_dump' to see it"
       end
     else
-      puts "    raw data"
+      puts '    raw data'
       puts @application['raw_data']
     end
   end
@@ -517,8 +503,8 @@ class FlacInfo
 
   #  This is where the 'real' parsing starts
   def parse_flac_meta_blocks
-    @fp = File.new(@filename, "rb")  #  Our file pointer
-    @comments_changed = nil          #  Do we need to write a new VORBIS_BLOCK?
+    @fp = File.new(@filename, 'rb') #  Our file pointer
+    @comments_changed = nil #  Do we need to write a new VORBIS_BLOCK?
 
     #  These next 8 lines initialize our public data structures.
     @streaminfo  = {}
@@ -528,148 +514,138 @@ class FlacInfo
     @padding     = {}
     @application = {}
     @cuesheet    = {}
-    @picture     = {"n" => 0}
+    @picture     = { 'n' => 0 }
 
     header = @fp.read(4)
     #  First 4 bytes must be 0x66, 0x4C, 0x61, and 0x43
-    if header != 'fLaC'
-      raise FlacInfoReadError, "#{@filename} does not appear to be a valid Flac file"
-    end
+    raise FlacInfoReadError, "#{@filename} does not appear to be a valid Flac file" if header != 'fLaC'
 
-    typetable = { 0 => "streaminfo", 1 => "padding", 2 => "application",
-                  3 => "seektable", 4 => "vorbis_comment", 5 => "cuesheet",
-                  6 => "picture" }
+    type_table = { 0 => 'streaminfo', 1 => 'padding', 2 => 'application',
+                   3 => 'seektable', 4 => 'vorbis_comment', 5 => 'cuesheet',
+                   6 => 'picture' }
 
     @metadata_blocks = []
-    lastheader = 0
-    pos = 1
+    last_header = 0
 
-    until lastheader == 1
+    until last_header == 1
       #  first bit = Last-metadata-block flag
-      #  bits 2-8 = BLOCK_TYPE. See typetable above
-      block_header = @fp.read(1).unpack("B*")[0]
-      #puts block_header
-      lastheader = block_header[0].to_i & 1
-      type = sprintf("%u", "0b#{block_header[1..7]}").to_i
-      @metadata_blocks << [typetable[type], type, lastheader]
-
-      if type >= typetable.size
-        raise FlacInfoReadError, "Invalid block header type"
-      end
+      #  bits 2-8 = BLOCK_TYPE. See type_table above
+      block_header = @fp.read(1).unpack1('B*')
+      last_header = block_header[0].to_i & 1
+      type = format('%u', "0b#{block_header[1..7]}").to_i
+      @metadata_blocks << [type_table[type], type, last_header]
 
-      pos += 1
-      self.send "parse_#{typetable[type]}"
+      raise FlacInfoReadError, 'Invalid block header type' if type >= type_table.size
+
+      send "parse_#{type_table[type]}"
     end
 
     @fp.close
+    p @metadata_blocks
   end
 
   def parse_seektable
-    begin
-      @seektable['block_size']  = @fp.read(3).unpack("B*")[0].to_i(2)
-      @seektable['offset']      = @fp.tell
-      @seektable['seek_points'] = @seektable['block_size'] / 18
-
-      @metadata_blocks[-1] << @seektable['offset']
-      @metadata_blocks[-1] << @seektable['block_size']
-
-      n = 0
-      @seektable['points'] = {}
-
-      @seektable['seek_points'].times do
-        pt_arr = []
-        pt_arr << @fp.read(8).reverse.unpack("V*")[0]
-        pt_arr << @fp.read(8).reverse.unpack("V*")[0]
-        pt_arr << @fp.read(2).reverse.unpack("v*")[0]
-        @seektable['points'][n] = pt_arr
-        n += 1
-      end
 
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_SEEKTABLE"
+    @seektable['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+    @seektable['offset'] = @fp.tell
+    @seektable['seek_points'] = @seektable['block_size'] / 18
+
+    @metadata_blocks[-1] << @seektable['offset']
+    @metadata_blocks[-1] << @seektable['block_size']
+
+    n = 0
+    @seektable['points'] = {}
+
+    @seektable['seek_points'].times do
+      pt_arr = []
+      pt_arr << @fp.read(8).reverse.unpack1('V*')
+      pt_arr << @fp.read(8).reverse.unpack1('V*')
+      pt_arr << @fp.read(2).reverse.unpack1('v*')
+      @seektable['points'][n] = pt_arr
+      n += 1
     end
+
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse METADATA_BLOCK_SEEKTABLE: #{e.message}"
   end
 
-  #  Not parsed yet, I have no flacs with a cuesheet!
+  #  TODO: I finally found a flac file with a cuesheet!
   def parse_cuesheet
-    begin
-      @cuesheet['block_size'] = @fp.read(3).unpack("B*")[0].to_i(2)
-      @cuesheet['offset']     = @fp.tell
 
-      @metadata_blocks[-1] << @cuesheet['offset']
-      @metadata_blocks[-1] << @cuesheet['block_size']
+    @cuesheet['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+    @cuesheet['offset'] = @fp.tell
 
-      @fp.seek(@cuesheet['block_size'], IO::SEEK_CUR)
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_CUESHEET"
-    end
+    @metadata_blocks[-1] << @cuesheet['offset']
+    @metadata_blocks[-1] << @cuesheet['block_size']
+
+    @fp.seek(@cuesheet['block_size'], IO::SEEK_CUR)
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse METADATA_BLOCK_CUESHEET: #{e.message}"
   end
 
   def parse_picture
-    n = @picture["n"] + 1
-    @picture["n"] = n
+    n = @picture['n'] + 1
+    @picture['n'] = n
     @picture[n]   = {}
 
-    picture_type = ["Other", "32x32 pixels file icon", "Other file icon", "Cover (front)", "Cover (back)",
-                    "Leaflet page", "Media", "Lead artist/lead performer/soloist", "Artist/performer",
-                    "Conductor", "Band/Orchestra", "Composer", "Lyricist/text writer", "Recording Location",
-                    "During recording", "During performance", "Movie/video screen capture", "A bright 
-                     coloured fish", "Illustration", "Band/artist logotype", "Publisher/Studio logotype"]
+    picture_type = ['Other', '32x32 pixels file icon', 'Other file icon', 'Cover (front)', 'Cover (back)',
+                    'Leaflet page', 'Media', 'Lead artist/lead performer/soloist', 'Artist/performer',
+                    'Conductor', 'Band/Orchestra', 'Composer', 'Lyricist/text writer', 'Recording Location',
+                    'During recording', 'During performance', 'Movie/video screen capture', "A bright
+                     coloured fish", 'Illustration', 'Band/artist logotype', 'Publisher/Studio logotype']
 
     begin
-      @picture[n]['block_size'] = @fp.read(3).unpack("B*")[0].to_i(2)
-      @picture[n]['offset']     = @fp.tell
+      @picture[n]['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+      @picture[n]['offset'] = @fp.tell
 
       @metadata_blocks[-1] << @picture[n]['offset']
 
-      @picture[n]['type_int']           = @fp.read(4).reverse.unpack("v*")[0]
+      @picture[n]['type_int']           = @fp.read(4).reverse.unpack1('v*')
       @picture[n]['type_string']        = picture_type[@picture[n]['type_int']]
-      mime_length                       = @fp.read(4).reverse.unpack("v*")[0]
-      @picture[n]['mime_type']          = @fp.read(mime_length).unpack("a*")[0]
-      description_length                = @fp.read(4).reverse.unpack("v*")[0]
-      @picture[n]['description_string'] = @fp.read(description_length).unpack("M*")[0]
-      @picture[n]['width']              = @fp.read(4).reverse.unpack("v*")[0]
-      @picture[n]['height']             = @fp.read(4).reverse.unpack("v*")[0]
-      @picture[n]['colour_depth']       = @fp.read(4).reverse.unpack("v*")[0]
-      @picture[n]['n_colours']          = @fp.read(4).reverse.unpack("v*")[0]
-      @picture[n]['raw_data_length']    = @fp.read(4).reverse.unpack("V*")[0]
+      mime_length                       = @fp.read(4).reverse.unpack1('v*')
+      @picture[n]['mime_type']          = @fp.read(mime_length).unpack1('a*')
+      description_length                = @fp.read(4).reverse.unpack1('v*')
+      @picture[n]['description_string'] = @fp.read(description_length).unpack1('M*')
+      @picture[n]['width']              = @fp.read(4).reverse.unpack1('v*')
+      @picture[n]['height']             = @fp.read(4).reverse.unpack1('v*')
+      @picture[n]['colour_depth']       = @fp.read(4).reverse.unpack1('v*')
+      @picture[n]['n_colours']          = @fp.read(4).reverse.unpack1('v*')
+      @picture[n]['raw_data_length']    = @fp.read(4).reverse.unpack1('V*')
       @picture[n]['raw_data_offset']    = @fp.tell
 
       @metadata_blocks[-1] << @picture[n]['block_size']
 
-      @fp.seek((@picture[n]['raw_data_length']), IO::SEEK_CUR)
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_PICTURE"
+      @fp.seek(@picture[n]['raw_data_length'], IO::SEEK_CUR)
+    rescue StandardError => e
+      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_PICTURE: #{e.message}"
     end
   end
 
   def parse_application
-    begin
-      @application['block_size'] = @fp.read(3).unpack("B*")[0].to_i(2)
-      @application['offset']     = @fp.tell
+    @application['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+    @application['offset'] = @fp.tell
 
-      @metadata_blocks[-1] << @application['offset']
-      @metadata_blocks[-1] << @application['block_size']
+    @metadata_blocks[-1] << @application['offset']
+    @metadata_blocks[-1] << @application['block_size']
 
-      @application['ID'] = @fp.read(4).unpack("H*")[0]
+    @application['ID'] = @fp.read(4).unpack1('H*')
 
-      app_id = {"41544348" => "Flac File", "43756573" => "GoldWave Cue Points",
-                "4D754D4C" => "MusicML", "46696361" => "CUE Splitter",
-                "46746F6C" => "flac-tools", "5346464C" => "Sound Font FLAC",
-                "7065656D" => "Parseable Embedded Extensible Metadata", "74756E65" => "TagTuner",
-                "786D6364" => "xmcd"}
+    app_id = { '41544348' => 'Flac File', '43756573' => 'GoldWave Cue Points',
+               '4D754D4C' => 'MusicML', '46696361' => 'CUE Splitter',
+               '46746F6C' => 'flac-tools', '5346464C' => 'Sound Font FLAC',
+               '7065656D' => 'Parseable Embedded Extensible Metadata', '74756E65' => 'TagTuner',
+               '786D6364' => 'xmcd' }
 
-      @application['name'] = "#{app_id[@application['ID']]}"
+    @application['name'] = app_id[@application['ID']].to_s
 
-      #  We only know how to parse data from 'Flac File'...
-      if @application['ID'] = "41544348"
-        parse_flac_file_contents(@application['block_size'] - 4)
-      else
-        @application['raw_data'] = @fp.read(@application['block_size'] - 4)
-      end
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_APPLICATION" 
+    #  We only know how to parse data from 'Flac File'...
+    if @application['ID'] == '41544348'
+      parse_flac_file_contents(@application['block_size'] - 4)
+    else
+      @application['raw_data'] = @fp.read(@application['block_size'] - 4)
     end
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse METADATA_BLOCK_APPLICATION: #{e.message}"
   end
 
   #  Unlike most values in the Flac header
@@ -679,163 +655,156 @@ class FlacInfo
   #  @tags is a more user-friendly data structure with the values
   #  separated into key=value pairs
   def parse_vorbis_comment
-    begin
-      @tags['block_size'] = @fp.read(3).unpack("B*")[0].to_i(2)
-      @tags['offset']     = @fp.tell
-
-      @metadata_blocks[-1] << @tags['offset']
-      @metadata_blocks[-1] << @tags['block_size']
+    @tags['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+    @tags['offset']     = @fp.tell
 
-      vendor_length = @fp.read(4).reverse.unpack("B*")[0].to_i(2)
+    @metadata_blocks[-1] << @tags['offset']
+    @metadata_blocks[-1] << @tags['block_size']
 
-      @tags['vendor_tag']      = @fp.read(vendor_length)
-      user_comment_list_length = @fp.read(4).reverse.unpack("B*")[0].to_i(2)
+    vendor_length = @fp.read(4).reverse.unpack1('B*').to_i(2)
 
-      n = 0
-      user_comment_list_length.times do
-        length = @fp.read(4).reverse.unpack("B*")[0].to_i(2)
-        @comment[n] = @fp.read(length)
-        n += 1
-      end
+    @tags['vendor_tag'] = @fp.read(vendor_length)
+    user_comment_list_length = @fp.read(4).reverse.unpack1('B*').to_i(2)
 
-      @comment.each do |c|
-        k,v = c.split("=")
-        #  Vorbis spec says we can have more than one identical comment ie:
-        #  comment[0]="Artist=Charlie Parker"
-        #  comment[1]="Artist=Miles Davis"
-        #  so we just append the second and subsequent values to the first
-        if @tags.has_key?(k)
-          @tags[k] = "#{@tags[k]}, #{v}"
-        else
-          @tags[k] = v
-        end
-      end
+    n = 0
+    user_comment_list_length.times do
+      length = @fp.read(4).reverse.unpack1('B*').to_i(2)
+      @comment[n] = @fp.read(length)
+      n += 1
+    end
 
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_VORBIS_COMMENT"
+    @comment.each do |c|
+      k, v = c.split('=', 2)
+      #  Vorbis spec says we can have more than one identical comment ie:
+      #  comment[0]="Artist=Charlie Parker"
+      #  comment[1]="Artist=Miles Davis"
+      #  so we just append the second and subsequent values to the first
+      @tags[k] = if @tags.key?(k)
+                   "#{@tags[k]}, #{v}"
+                 else
+                   v
+                 end
     end
+
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse METADATA_BLOCK_VORBIS_COMMENT: #{e.message}"
   end
 
   # padding is just a bunch of '0' bytes
   def parse_padding
-    begin
-      @padding['block_size'] = @fp.read(3).unpack("B*")[0].to_i(2)
-      @padding['offset']     = @fp.tell
+    @padding['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+    @padding['offset'] = @fp.tell
 
-      @metadata_blocks[-1] << @padding['offset']
-      @metadata_blocks[-1] << @padding['block_size']
+    @metadata_blocks[-1] << @padding['offset']
+    @metadata_blocks[-1] << @padding['block_size']
 
-      @fp.seek(@padding['block_size'], IO::SEEK_CUR)
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_PADDING"
-    end
+    @fp.seek(@padding['block_size'], IO::SEEK_CUR)
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse METADATA_BLOCK_PADDING: #{e.message}"
   end
 
   def parse_streaminfo
-    begin
-      @streaminfo['block_size']    = @fp.read(3).unpack("B*")[0].to_i(2)
-      @streaminfo['offset']        = @fp.tell
-
-      @metadata_blocks[-1] << @streaminfo['offset']
-      @metadata_blocks[-1] << @streaminfo['block_size']
-
-      @streaminfo['minimum_block'] = @fp.read(2).reverse.unpack("v*")[0]
-      @streaminfo['maximum_block'] = @fp.read(2).reverse.unpack("v*")[0]
-      @streaminfo['minimum_frame'] = @fp.read(3).reverse.unpack("v*")[0]
-      @streaminfo['maximum_frame'] = @fp.read(3).reverse.unpack("v*")[0]
-
-      #  64 bits in MSB order
-      bitstring = @fp.read(8).unpack("B*")[0]
-      #  20 bits :: Sample rate in Hz.
-      @streaminfo['samplerate']      = sprintf("%u", "0b#{bitstring[0..19]}").to_i
-      #  3 bits :: (number of channels)-1
-      @streaminfo['channels']        = sprintf("%u", "0b#{bitstring[20..22]}").to_i + 1
-      #  5 bits :: (bits per sample)-1
-      @streaminfo['bits_per_sample'] = sprintf("%u", "0b#{bitstring[23..27]}").to_i + 1
-      #  36 bits :: Total samples in stream.
-      @streaminfo['total_samples']   = sprintf("%u", "0b#{bitstring[28..63]}").to_i
-
-      #  128 bits :: MD5 signature of the unencoded audio data.
-      @streaminfo['md5'] = @fp.read(16).unpack("H32")[0]
-    rescue
-      raise FlacInfoReadError, "Could not parse METADATA_BLOCK_STREAMINFO"
-    end
+    @streaminfo['block_size'] = @fp.read(3).unpack1('B*').to_i(2)
+    @streaminfo['offset'] = @fp.tell
+
+    @metadata_blocks[-1] << @streaminfo['offset']
+    @metadata_blocks[-1] << @streaminfo['block_size']
+
+    @streaminfo['minimum_block'] = @fp.read(2).reverse.unpack1('v*')
+    @streaminfo['maximum_block'] = @fp.read(2).reverse.unpack1('v*')
+    @streaminfo['minimum_frame'] = @fp.read(3).reverse.unpack1('v*')
+    @streaminfo['maximum_frame'] = @fp.read(3).reverse.unpack1('v*')
+
+    #  64 bits in MSB order
+    bitstring = @fp.read(8).unpack1('B*')
+
+    #  20 bits :: Sample rate in Hz.
+    @streaminfo['samplerate'] = format('%u', "0b#{bitstring[0..19]}").to_i
+
+    #  3 bits :: (number of channels)-1
+    @streaminfo['channels'] = format('%u', "0b#{bitstring[20..22]}").to_i + 1
+
+    #  5 bits :: (bits per sample)-1
+    @streaminfo['bits_per_sample'] = format('%u', "0b#{bitstring[23..27]}").to_i + 1
+
+    #  36 bits :: Total samples in stream.
+    @streaminfo['total_samples'] = format('%u', "0b#{bitstring[28..63]}").to_i
+
+    #  128 bits :: MD5 signature of the unencoded audio data.
+    @streaminfo['md5'] = @fp.read(16).unpack1('H32')
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse METADATA_BLOCK_STREAMINFO: #{e.message}"
   end
 
   #  See http://firestuff.org/flacfile/
   def parse_flac_file_contents(size)
-    begin
-      @flac_file = {}
-      desc_length = @fp.read(1).unpack("C")[0]
-      @flac_file['description'] = @fp.read(desc_length)
-      mime_length = @fp.read(1).reverse.unpack("C")[0]
-      @flac_file['mime_type'] = @fp.read(mime_length)
-      size = size - 2 - desc_length - mime_length
-      @flac_file['raw_data'] = @fp.read(size)
-    rescue
-      raise FlacInfoReadError, "Could not parse Flac File data"
-    end
+    @flac_file = {}
+    desc_length = @fp.read(1).unpack1('C')
+    @flac_file['description'] = @fp.read(desc_length)
+    mime_length = @fp.read(1).reverse.unpack1('C')
+    @flac_file['mime_type'] = @fp.read(mime_length)
+    size = size - 2 - desc_length - mime_length
+    @flac_file['raw_data'] = @fp.read(size)
+  rescue StandardError => e
+    raise FlacInfoReadError, "Could not parse Flac File data: #{e.message}"
   end
 
   #  Here we begin the FlacInfo write methods
 
-
   #  Build a block header given a type, a size, and whether it is last
   def build_block_header(type, size, last)
-    begin
-      bit_string = sprintf("%b%7b", last, type).gsub(" ","0")
-      block_header_s = [bit_string].pack("B*")
-      block_header_s += [size].pack("VX").reverse  # size is 3 bytes
-    rescue
-      raise FlacInfoWriteError, "error building block header"
-    end
+    bit_string = format('%b%7b', last, type).gsub(' ', '0')
+    block_header_s = [bit_string].pack('B*')
+    block_header_s + [size].pack('VX').reverse # size is 3 bytes
+  rescue StandardError => e
+    raise FlacInfoWriteError, "error building block header: #{e.message}"
   end
 
   #  Build a string of packed data for the Vorbis comments
   def build_vorbis_comment_block
-    begin
-      vorbis_comm_s  = [@tags["vendor_tag"].length].pack("V")
-      vorbis_comm_s += [@tags["vendor_tag"]].pack("A*")
-      vorbis_comm_s += [@comment.length].pack("V")
-      @comment.each do |c|
-        vorbis_comm_s += [c.length].pack("V")
-        vorbis_comm_s += [c].pack("A*")
-      end
-      vorbis_comm_s
-    rescue
-      raise FlacInfoWriteError, "error building vorbis comment block"
+    vorbis_comm_s  = [@tags['vendor_tag'].length].pack('V')
+    vorbis_comm_s += [@tags['vendor_tag']].pack('A*')
+    vorbis_comm_s += [@comment.length].pack('V')
+
+    @comment.each do |c|
+      vorbis_comm_s += [c.bytesize].pack('V')
+      vorbis_comm_s += [c].pack('A*')
     end
+
+    vorbis_comm_s
+  rescue StandardError => e
+    raise FlacInfoWriteError, "error building vorbis comment block: #{e.message}"
   end
 
   def write_to_disk
-    if @comments_changed == nil
-      raise FlacInfoWriteError, "No changes to write"
-    else
-      vcd = build_vorbis_comment_block            #  Build the VORBIS_COMMENT data
-      vch = build_block_header(4, vcd.length, 0)  #  Build the VORBIS_COMMENT header
-    end
+    raise FlacInfoWriteError, 'No changes to write' if @comments_changed.nil?
+
+    #  Build the VORBIS_COMMENT data
+    vcd = build_vorbis_comment_block
+    #  Build the VORBIS_COMMENT header
+    vch = build_block_header(4, vcd.length, 0)
 
     #  Determine if we can shuffle the data or if a rewrite is necessary
     begin
-      if not @padding.has_key?("block_size") or vcd.length > @padding['block_size']
+      if !@padding.key?('block_size') || (vcd.length > @padding['block_size'])
         rewrite(vcd, vch)  # Rewriting is simpler but more expensive
       else
         shuffle(vcd, vch)  # Shuffling is more complicated but cheaper
       end
-      parse_flac_meta_blocks  #  Parse the file again to update new values
-      return true
-    rescue
-      raise FlacInfoWriteError, "error writing new data to #{@filename}"
+      parse_flac_meta_blocks #  Parse the file again to update new values
+      true
+    rescue StandardError => e
+      raise FlacInfoWriteError, "error writing new data to #{@filename}: #{e.message}"
     end
   end
 
   #  Shuffle the data and update the PADDING block
   def shuffle(vcd, vch)
-    flac = File.new(@filename, "r+b")
+    flac = File.new(@filename, 'r+b')
     flac.binmode #  For Windows folks...
 
     #  Position ourselves at end of current Vorbis block
-    flac.seek((@tags['offset'] + @tags['block_size']), IO::SEEK_CUR)
+    flac.seek(@tags['offset'] + @tags['block_size'], IO::SEEK_CUR)
     #  The data we need to shuffle starts at current position and ends at
     #  the beginning of the padding block, so the size we need to read is:
     #
@@ -844,13 +813,13 @@ class FlacInfo
     size_to_read = (@padding['offset'] - 4) - flac.tell
     data_to_shuffle = flac.read(size_to_read)
 
-    flac.seek((@tags['offset'] - 4), IO::SEEK_SET)
+    flac.seek(@tags['offset'] - 4, IO::SEEK_SET)
     flac.write(vch)              #  Write the VORBIS_COMMENT header
     flac.write(vcd)              #  Write the VORBIS_COMMENT data
     flac.write(data_to_shuffle)  #  Write the shuffled data
 
     new_padding_size = @padding['block_size'] - (vcd.length - @tags['block_size'])
-    ph = build_block_header(1, new_padding_size, 1)  #  Build the new PADDING header
+    ph = build_block_header(1, new_padding_size, 1) #  Build the new PADDING header
 
     flac.write(ph)  #  Write the new PADDING header
     flac.close      #  ...and we're done
@@ -858,12 +827,12 @@ class FlacInfo
 
   #  Rewrite the entire file
   def rewrite(vcd, vch)
-    flac = File.new(@filename, "r+b")
+    flac = File.new(@filename, 'r+b')
     flac.binmode #  For Windows folks...
 
-    flac.seek((@tags['offset'] + @tags['block_size']), IO::SEEK_CUR)
-    rest_of_file = flac.read()
-    flac.seek((@tags['offset'] - 4), IO::SEEK_SET)
+    flac.seek(@tags['offset'] + @tags['block_size'], IO::SEEK_CUR)
+    rest_of_file = flac.read
+    flac.seek(@tags['offset'] - 4, IO::SEEK_SET)
 
     flac.write(vch)           #  Write the VORBIS_COMMENT header
     flac.write(vcd)           #  Write the VORBIS_COMMENT data
@@ -874,66 +843,64 @@ class FlacInfo
 
   # remove the padding block
   def remove_padding_block
-    begin
-      new_last_block = @metadata_blocks[-2]
+    new_last_block = @metadata_blocks[-2]
 
-      flac = File.new(@filename, "r+b")
-      flac.binmode
+    flac = File.new(@filename, 'r+b')
+    flac.binmode
 
-      flac.seek((@padding['offset'] + @padding['block_size']), IO::SEEK_CUR)
-      rest_of_file = flac.read()
+    flac.seek(@padding['offset'] + @padding['block_size'], IO::SEEK_SET)
+    rest_of_file = flac.read
 
-      flac.seek((@padding['offset'] - 4), IO::SEEK_SET)
-      flac.write(rest_of_file)
+    flac.seek(@padding['offset'] - 4, IO::SEEK_SET)
+    flac.write(rest_of_file)
+    # Truncate the file at the 'new' end of file.
+    flac.truncate(flac.tell)
 
-      nbh = build_block_header(new_last_block[1], new_last_block[4], 1)
+    nbh = build_block_header(new_last_block[1], new_last_block[4], 1)
 
-      flac.seek((new_last_block[3] - 4), IO::SEEK_SET)
-      flac.write(nbh)
-      flac.close()
+    flac.seek(new_last_block[3] - 4, IO::SEEK_SET)
+    flac.write(nbh)
+    flac.close
 
-      parse_flac_meta_blocks  #  Parse the file again to update new values
-      true
-    rescue
-      false
-    end
+    parse_flac_meta_blocks  #  Parse the file again to update new values
+    true
+  rescue StandardError => e
+    raise FlacInfoWriteError, "Could not update padding block: #{e.message}"
   end
 
   def build_padding_block(size)
-    begin
-      old_last_block = @metadata_blocks[-1]
+    old_last_block = @metadata_blocks[-1]
 
-      a = Array.new(size / 2, 0)
-      pbd = a.pack("v*")
-      pbh = build_block_header(1, size, 1)
+    a = Array.new(size / 2, 0)
+    pbd = a.pack('v*')
+    pbh = build_block_header(1, size, 1)
 
-      flac = File.new(@filename, "r+b")
-      flac.binmode
+    flac = File.new(@filename, 'r+b')
+    flac.binmode
 
-      flac.seek((old_last_block[4] + old_last_block[3]), IO::SEEK_CUR)
-      co = flac.tell
-      rest_of_file = flac.read()
-      flac.seek(co, IO::SEEK_SET)
+    flac.seek(old_last_block[4] + old_last_block[3], IO::SEEK_SET)
+    co = flac.tell
+    rest_of_file = flac.read
+    flac.seek(co, IO::SEEK_SET)
 
-      flac.write(pbh)
-      flac.write(pbd)
-      flac.write(rest_of_file)
-      nbh = build_block_header(old_last_block[1], old_last_block[4], 0)
+    flac.write(pbh)
+    flac.write(pbd)
+    flac.write(rest_of_file)
+    nbh = build_block_header(old_last_block[1], old_last_block[4], 0)
 
-      flac.seek((old_last_block[3] - 4), IO::SEEK_SET)
-      flac.write(nbh)
+    flac.seek(old_last_block[3] - 4, IO::SEEK_SET)
+    flac.write(nbh)
 
-      flac.close()
-      parse_flac_meta_blocks  #  Parse the file again to update new values
-      true
-    rescue
-      false
-    end
+    flac.close
+    parse_flac_meta_blocks  #  Parse the file again to update new values
+    true
+  rescue StandardError => e
+    raise FlacInfoWriteError, "Could not update padding block: #{e.message}"
   end
 end
 
 # If called directly from the command line, run meta_flac on each argument
-if __FILE__ == $0
+if __FILE__ == $PROGRAM_NAME
   ARGV.each do |filename|
     FlacInfo.new(filename).meta_flac
     puts

metadata

@@ -1,48 +1,49 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
+--- !ruby/object:Gem::Specification
 name: flacinfo-rb
-version: !ruby/object:Gem::Version 
-  version: "0.4"
-date: 2007-09-08 00:00:00 -06:00
-summary: Pure Ruby library for accessing metadata from Flac files
-require_paths: 
-- lib
-email: bulliver@badcomputer.org
-homepage: http://badcomputer.org/unix/code/flacinfo/
-rubyforge_project: flacinfo-rb
-description: 
-autorequire: flacinfo
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+version: !ruby/object:Gem::Version
+  version: 1.1.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
-authors: 
+authors:
 - Darren Kirby
-files: 
-- README
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      flacinfo-rb is a pure Ruby library for low-level access to Flac files.
+      You can use it to read, set, or delete 'id3' like data (Vorbis comments),
+      delete, add, or resize padding blocks, and so on.
+email: darren@dragonbyte.ca
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
 - lib/flacinfo.rb
-test_files: 
 - test/test-flacinfo.rb
 - test/test.flac
+homepage: https://github.com/DarrenKirby/flacinfo-rb
+licenses:
+- GPL-2.0-only
+metadata: {}
 rdoc_options: []
-
-extra_rdoc_files: 
-- README
-executables: []
-
-extensions: []
-
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-dependencies: []
-
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Pure Ruby library for accessing metadata from Flac files
+test_files:
+- test/test-flacinfo.rb
+- test/test.flac

data/README

@@ -1,43 +0,0 @@
-:: FlacInfo-rb ::
-Author: Darren Kirby
-mailto:bulliver@badcomputer.org
-License: Ruby
-
- = Quick API docs =
-
- == Initializing ==
-
-require 'flacinfo'
-foo = FlacInfo.new("someSong.flac")
-
- == Public attributes ==
-
-streaminfo   :: hash of STREAMINFO block metadata
-seektable    :: hash of arrays of seek points
-comment      :: array of VORBIS COMMENT block metadata
-tags         :: user-friendly hash of Vorbis comment metadata key=value pairs
-application  :: hash of APPLICATION block metadata
-padding      :: hash of PADDING block metadata
-cuesheet     :: hash of CUESHEET block metadata
-picture      :: hash of PICTURE block metadata
-flac_file    :: hash of APPLICATION Id 0x41544348 (Flac File) metadata if present
-
- == Public methods ==
-
-comment_add       :: adds a comment
-comment_del       :: deletes a comment
-hastag('str')     :: returns true if tags['str'] exists
-meta_flac         :: prints all META BLOCKS. (Mostly) equivelant to 'metaflac --list'
-padding_add!(b)   :: adds a PADDING block of size 'b' or 4096 bytes
-padding_del!      :: deletes the PADDING block
-padding_resize!   :: resizes (grow or shrink) a padding block to size 'b' or 4096 bytes
-print_seektable   :: pretty-print seektable hash
-print_streaminfo  :: pretty-print streaminfo hash
-print_tags        :: pretty-print tags hash
-raw_data_dump(?)  :: if passed a filename it will dump flac_file['raw_data'] to that file,
-                       otherwise it will dump it to the console (even if binary!)
-update!           :: writes comment changes to disk
-write_picture(?)  :: write image from PICTURE block(s) to optional file
-
-For more/different documentation see http://badcomputer.org/unix/code/flacinfo/
-