mb-discid 0.1.4-x86-mswin32-60

data/CHANGES

@@ -0,0 +1,29 @@
+= Changelog
+
+== 0.1.4 (2009-11-19)
+* Fixed calling +read+ method without argument
+
+== 0.1.3 (2009-11-19)
+* Added singleton method +sectors_to_seconds+ to convert sectors into seconds
+* Added method +seconds+ to retrieve disc length in seconds
+* Added method +track_info+ for accessing more detailed information about tracks
+* Fixed building with Ruby 1.9 (Mihaly Csomay)
+
+== 0.1.2 (2007-07-04)
+* Support the method +put+ to set the TOC information directly instead of
+  reading it from a device.
+* Fixed possible core dump if +read+ was called twice and failed the
+  second time.
+* New to_s method (returns string representation of the ID itself).
+* Complete RDoc documentation.
+
+== 0.1.1 (2007-06-03)
+* Minor changes to source to support MS compiler
+* Provide Win32 binary gem
+* Changed require of library to "require 'mb-discid'" (was "require 'DiscID'"
+  before, which was likely to cause problems)
+
+== 0.1.0 (2007-06-02)
+* Initial release
+
+$Id: CHANGES 301 2009-11-19 11:39:31Z phw $

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2007, Philipp Wolfer
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the RBrainz project nor the names of the
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,54 @@
+= MB-DiscID - Ruby bindings for MusicBrainz libdiscid
+
+== About
+MB-DiscID provides Ruby bindings for the MusicBrainz DiscID library libdiscid.
+It allows you to calculate MusicBrainz DiscIDs from audio CDs which you can use
+to find the release entry for your CD in the MusicBrainz database. 
+
+== Requirements
+* Ruby >= 1.8.6
+* libdiscid >= 0.1.0
+
+== Installation
+Before installing rdiscid make sure you have libdiscid installed. See
+http://musicbrainz.org/doc/libdiscid for more information on how to do this.
+
+=== Installation with RubyGems
+ gem install mb-discid
+ 
+=== Installation on Windows operating systems.
+For Windows a binary gem <tt>mb-discid-x.x.x-mswin32.gem</tt> is available. To
+install it follow the instructions below:
+
+1. Make sure you have at least Ruby 1.8.6 installed.
+2. Install RubyGems, if you don't already have it.
+3. Download <tt>libdiscid-0.1.1-win32bin.zip</tt> from
+   http://musicbrainz.org/doc/libdiscid.
+4. Copy the file <tt>discid.dll</tt> from <tt>libdiscid-0.1.1-win32bin.zip</tt>
+   to your Ruby bin directory (normally <tt>C:\ruby\bin</tt>).
+5. Run <tt>gem install mb-discid</tt> to install MB-DiscID.
+6. To test the installation try to run <tt>examples/discid.rb</tt>.
+ 
+=== Installing from source
+ rake install
+
+== Usage
+See the documentation of MusicBrainz::DiscID or the example files in the
++examples+ directory for usage information.
+
+== Contact
+MB-DiscID is part of the RBrainz project which provides a library to query
+the MusicBrainz XML web service. For more information about MB-DiscID or
+RBrainz visit http://rbrainz.rubyforge.org.
+
+If you have any questions or suggestions regarding MB-DiscID please write to
+the rbrainz-user mailinglist[http://rubyforge.org/mail/?group_id=3677].
+If you find bugs or if you have any feature requests please use the
+RBrainz bug tracker[http://rubyforge.org/tracker/?group_id=3677]. 
+
+== License
+MB-DiscID is Copyright (c) 2007 Philipp Wolfer.
+It is free softare distributed under a BSD style license. See
+LICENSE[link:files/LICENSE.html] for details.
+
+$Id: README 298 2009-11-19 09:26:45Z phw $

data/Rakefile

@@ -0,0 +1,137 @@
+# $Id: Rakefile 300 2009-11-19 11:31:42Z phw $
+# Copyright (c) 2007, Philipp Wolfer
+# All rights reserved.
+# See LICENSE for permissions.
+ 
+# Rakefile for RDiscID
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+task :default do
+  puts "Please see 'rake --tasks' for an overview of the available tasks."
+end
+
+# Packaging tasks: -------------------------------------------------------
+
+PKG_NAME     = 'mb-discid'
+PKG_VERSION  = '0.1.4'
+PKG_SUMMARY  = 'Ruby bindings for libdiscid.'
+PKG_AUTHOR   = 'Philipp Wolfer'
+PKG_EMAIL    = 'phw@rubyforge.org'
+PKG_HOMEPAGE = 'http://rbrainz.rubyforge.org'
+PKG_DESCRIPTION = <<EOF
+    Ruby bindings for libdiscid. See http://musicbrainz.org/doc/libdiscid
+    for more information on libdiscid and MusicBrainz.
+EOF
+PKG_FILES = FileList[
+  'Rakefile', 'LICENSE', 'README', 'CHANGES',
+  'examples/**/*.rb',
+  'ext/**/*.{c,rb}',
+  'lib/**/*.rb',
+  'test/**/*.rb'
+]
+PKG_EXTRA_RDOC_FILES = ['README', 'LICENSE', 'CHANGES']
+
+spec = Gem::Specification.new do |spec|
+  spec.name = PKG_NAME
+  spec.version = PKG_VERSION
+  spec.summary = PKG_SUMMARY
+  if ENV['BINARY_GEM']
+    spec.platform = Gem::Platform::CURRENT
+    spec.files = PKG_FILES << 'ext/MB_DiscID.so'
+    spec.bindir = 'bin'
+    spec.required_ruby_version = ">= #{RUBY_VERSION}"
+  else
+    spec.platform = Gem::Platform::RUBY
+    spec.files = PKG_FILES
+    spec.extensions << 'ext/extconf.rb'
+    spec.required_ruby_version = ">= 1.8.6"
+  end
+  spec.requirements << 'libdiscid (http://musicbrainz.org/doc/libdiscid)'
+  spec.require_paths = ['lib', 'ext']
+  spec.autorequire = spec.name
+  spec.description = PKG_DESCRIPTION
+  spec.author = PKG_AUTHOR
+  spec.email = PKG_EMAIL
+  spec.homepage = PKG_HOMEPAGE
+  spec.rubyforge_project = 'rbrainz'
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = PKG_EXTRA_RDOC_FILES
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar_gz= true
+end
+
+# Build tasks: -----------------------------------------------------------
+
+desc 'Build all the extensions'
+task :build do
+  extconf_args = ''
+
+  unless ENV['DISCID_DIR'].nil?
+    extconf_args = "--with-discid-dir=#{ENV['DISCID_DIR']}"
+  end
+
+  cd 'ext' do
+    unless system("ruby extconf.rb #{extconf_args}")
+      STDERR.puts "ERROR: could not configure extension!\n" +
+                  "\n#{INFO_NOTE}\n"
+      break
+    end
+
+    unless system('make') or system('nmake')
+      STDERR.puts 'ERROR: could not build extension!'
+      break
+    end
+  end
+end
+
+desc 'Install (and build) extensions'
+task :install => [:build] do
+  cd 'ext' do
+    unless system('make install')
+      STDERR.puts 'ERROR: could not install extension!'
+      break
+    end
+  end
+end
+
+desc 'Remove extension products'
+task :clobber_build do
+  FileList['ext/**/*'].each do |file|
+    unless FileList['ext/**/*.{c,rb}'].include?(file)
+      rm_r file if File.exists?(file)
+    end
+  end
+end
+
+desc 'Force a rebuild of the extension files'
+task :rebuild => [:clobber_build, :build]
+
+desc 'Remove all files created during the build process'
+task :clobber => [:clobber_build, :clobber_package]
+
+# Test tasks: ------------------------------------------------------------
+
+desc "Run just the unit tests"
+Rake::TestTask.new(:test => [:rebuild]) do |test|
+  test.test_files = FileList['test/test*.rb']
+  test.libs = ['lib', 'ext']
+  test.warning = true
+end
+
+# Documentation tasks: ---------------------------------------------------
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.title    = "MB-DiscID %s" % PKG_VERSION
+  rdoc.main     = 'README'
+  rdoc.rdoc_dir = 'doc/api'
+  rdoc.rdoc_files.include('ext/**/*.c', 'lib/**/*.rb', PKG_EXTRA_RDOC_FILES)
+  rdoc.options << '--inline-source' << '--line-numbers' #<< '--diagram'
+end
+

data/examples/discid.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+#
+# Example script for MB-DiscID.
+# 
+# This script will read the disc ID from the default device and print
+# the results. You can specify an alternate device to use by giving the
+# device's name as the first command line argument.
+# 
+# Example:
+#  ./discid.rb /dev/dvd
+#
+# $Id: discid.rb 201 2008-02-13 14:59:48Z phw $
+
+require 'mb-discid'
+
+# Read the device name from the command line or use the default.
+device = $*[0] ? $*[0] : MusicBrainz::DiscID.default_device
+
+# Create a new DiscID object and read the disc information.
+# In case of errors exit the application.
+puts "Reading TOC from device '#{device}'."
+begin
+  disc = MusicBrainz::DiscID.new
+  disc.read(device)
+  
+  # Instead of reading from a device we could set the TOC directly:
+  # disc.put(1, 82255, [150, 16157, 35932, 57527])
+rescue Exception => e
+  puts e
+  exit(1)
+end
+
+# Print information about the disc:
+print <<EOF
+
+DiscID      : #{disc.id}
+FreeDB ID   : #{disc.freedb_id}
+First track : #{disc.first_track_num}
+Last track  : #{disc.last_track_num}
+Total length: #{disc.seconds} seconds
+Sectors     : #{disc.sectors}
+EOF
+
+# Print information about individual tracks:
+disc.track_details do |track_info|
+  puts "Track ##{track_info.number}"
+  puts "  Length: %02d:%02d (%i sectors)" %
+      [track_info.seconds / 60, track_info.seconds % 60, track_info.sectors]
+  puts "  Start : %02d:%02d (sector %i)" %
+      [track_info.start_time / 60, track_info.start_time % 60, track_info.start_sector]
+  puts "  End   : %02d:%02d (sector %i)" %
+      [track_info.end_time / 60, track_info.end_time % 60, track_info.end_sector]
+end
+
+# Print a submission URL that can be used to submit
+# the disc ID to MusicBrainz.org.
+puts "\nSubmit via #{disc.submission_url}"

data/ext/extconf.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# $Id: extconf.rb 68 2007-06-03 14:12:21Z phw $
+
+require 'mkmf'
+
+if have_library('discid', 'discid_new') or
+   have_library('discid.dll', 'discid_new')
+  # Remove -MD from compiler flags on Windows.
+  $CFLAGS.sub!('-MD', '') if RUBY_PLATFORM.include? 'win32'
+  create_makefile('MB_DiscID')
+else
+  puts 'Required library libdiscid not found.'
+end

data/ext/mb_discid.c

@@ -0,0 +1,360 @@
+/**
+ * $Id: mb_discid.c 301 2009-11-19 11:39:31Z phw $
+ *
+ * Ruby bindings for libdiscid. See http://musicbrainz.org/doc/libdiscid
+ * for more information on libdiscid and MusicBrainz.
+ * 
+ * Author::    Philipp Wolfer (mailto:phw@rubyforge.org)
+ * Copyright:: Copyright (c) 2007, Philipp Wolfer
+ * License::   MB-DiscID is free software distributed under a BSD style license.
+ *             See LICENSE for permissions.
+ */
+
+#include "ruby.h"
+#include "discid/discid.h"
+
+/**
+ * The MusicBrainz module.
+ */
+static VALUE mMusicBrainz;
+
+/**
+ * The DiscID class.
+ */
+static VALUE cDiscID;
+
+/**
+ * call-seq:
+ *  id() -> string or nil
+ * 
+ * Returns the DiscID as a string.
+ * 
+ * Returns +nil+ if no ID was yet read.
+ */
+static VALUE mb_discid_id(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc;
+		Data_Get_Struct(self, DiscId, disc);
+		
+		return rb_str_new2(discid_get_id(disc));
+	}
+}
+
+/**
+ * call-seq:
+ *  submission_url() -> string or nil
+ * 
+ * Returns a submission URL for the DiscID as a string.
+ * 
+ * Returns +nil+ if no ID was yet read.
+ */
+static VALUE mb_discid_submission_url(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc;
+		Data_Get_Struct(self, DiscId, disc);
+		
+		return rb_str_new2(discid_get_submission_url(disc));
+	}
+}
+
+/**
+ * call-seq:
+ *  freedb_id() -> string or nil
+ * 
+ * Returns a FreeDB DiscID as a string.
+ * 
+ * Returns +nil+ if no ID was yet read.
+ */
+static VALUE mb_discid_freedb_id(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc;
+		Data_Get_Struct(self, DiscId, disc);
+		
+		return rb_str_new2(discid_get_freedb_id(disc));
+	}
+}
+
+/**
+ * call-seq:
+ *  first_track_num() -> int or nil
+ * 
+ * Return the number of the first track on this disc (usually 1).
+ * 
+ * Returns +nil+ if no ID was yet read.
+ */
+static VALUE mb_discid_first_track_num(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc;
+		Data_Get_Struct(self, DiscId, disc);
+		
+		return INT2FIX(discid_get_first_track_num(disc));
+	}
+}
+
+/**
+ * call-seq:
+ *  last_track_num() -> int or nil
+ * 
+ * Return the number of the last track on this disc.
+ * 
+ * Returns +nil+ if no ID was yet read.
+ */
+static VALUE mb_discid_last_track_num(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc;
+		Data_Get_Struct(self, DiscId, disc);
+		
+		return INT2FIX(discid_get_last_track_num(disc));
+	}
+}
+
+/**
+ * call-seq:
+ *  sectors() -> int or nil
+ * 
+ * Return the length of the disc in sectors.
+ * 
+ * Returns +nil+ if no ID was yet read.
+ */
+static VALUE mb_discid_sectors(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc;
+		Data_Get_Struct(self, DiscId, disc);
+		
+		return INT2FIX(discid_get_sectors(disc));
+	}
+}
+
+/**
+ * call-seq:
+ *  tracks() -> array
+ *  tracks() {|offset, length| block }
+ * 
+ * Returns an array of <tt>[offset, length]</tt> tuples for each track.
+ * 
+ * Offset and length are both integer values representing sectors.
+ * If a block is given this method returns +nil+ and instead iterates over the
+ * block calling the block with two arguments <tt>|offset, length|</tt>.
+ *
+ * Returns always +nil+ if no ID was yet read. The block won't be called in
+ * this case.
+ *
+ * You may want to use the method track_details instead of this method to
+ * retrieve more detailed information about the tracks.
+ */
+static VALUE mb_discid_tracks(VALUE self)
+{
+	if (rb_iv_get(self, "@read") == Qfalse)
+		return Qnil;
+	else
+	{
+		DiscId *disc; /* Pointer to the disc struct */
+		VALUE result = rb_ary_new(); /* Array of all [offset, length] tuples */
+		VALUE tuple; /* Array to store one [offset, length] tuple. */
+		int track;   /* Counter for the track number to process. */
+		
+		Data_Get_Struct(self, DiscId, disc);
+		
+		track = discid_get_first_track_num(disc); /* First track number */
+		while (track <= discid_get_last_track_num(disc))
+		{
+			tuple = rb_ary_new3(2,
+				INT2FIX(discid_get_track_offset(disc, track)),
+				INT2FIX(discid_get_track_length(disc, track)) );
+			
+			if (rb_block_given_p())
+				rb_yield(tuple);
+			else
+				rb_ary_push(result, tuple);
+				
+			track++;
+		}
+		
+		if (rb_block_given_p())
+			return Qnil;
+		else
+			return result;
+	}
+}
+
+/**
+ * call-seq:
+ *  read(device=nil)
+ * 
+ * Read the disc ID from the given device.
+ * 
+ * If no device is given the default device of the platform will be used.
+ * Throws an _Exception_ if the CD's TOC can not be read.
+ *
+ * Raises:: ArgumentError, TypeError, Exception
+ */
+static VALUE mb_discid_read(int argc, VALUE *argv, VALUE self)
+{
+	DiscId *disc;        /* Pointer to the disc struct */
+	VALUE device = Qnil; /* The device string as a Ruby string */
+	char* cdevice;       /* The device string as a C string */
+	
+	Data_Get_Struct(self, DiscId, disc);
+	
+	/* Check the number and types of arguments */
+	rb_scan_args(argc, argv, "01", &device);
+
+	/* Use the default device if none was given. */
+	if (device == Qnil)
+		cdevice = discid_get_default_device();
+	else if (rb_respond_to(device, rb_intern("to_s")))
+	{
+		device = rb_funcall(device, rb_intern("to_s"), 0, 0);
+		cdevice = StringValuePtr(device);
+	}
+	else
+		rb_raise(rb_eTypeError, "wrong argument type (expected String)");
+	
+	/* Mark the disc id as unread in case something goes wrong. */
+	rb_iv_set(self, "@read", Qfalse);
+	
+	/* Read the discid */
+	if (discid_read(disc, cdevice) == 0)
+		rb_raise(rb_eException, discid_get_error_msg(disc));
+	else /* Remember that we already read the ID. */
+		rb_iv_set(self, "@read", Qtrue);
+	
+	return Qnil;
+	
+}
+
+/**
+ * call-seq:
+ *  put(first_track, sectors, offsets)
+ * 
+ * Set the TOC information directly instead of reading it from a device.
+ * 
+ * Use this instead of read if the TOC information was already read elsewhere
+ * and you want to recalculate the ID.
+ * Throws an _Exception_ if the CD's TOC can not be read.
+ * 
+ * <b>Parameters:</b>
+ * [first_track] The number of the first track on the disc (usually 1).
+ * [sectors] The total number of sectors on the disc.
+ * [offsets] Array of all track offsets. The number of tracks must not exceed 99.
+ *
+ * Raises:: Exception
+ */
+static VALUE mb_discid_put(VALUE self, VALUE first_track, VALUE sectors,
+                           VALUE offsets)
+{
+	DiscId *disc;                       /* Pointer to the disc struct */
+	long length = RARRAY_LEN(offsets);  /* length of the offsets array */
+	int cfirst  = NUM2INT(first_track); /* number of the first track */
+	int clast   = length + 1 - cfirst;  /* number of the last track */
+	int coffsets[100];                  /* C array to hold the offsets */
+	int i = 1;                          /* Counter for iterating over coffsets*/
+	
+	Data_Get_Struct(self, DiscId, disc);
+	
+	/* Convert the Ruby array to an C array of integers. discid_puts expects
+	   always an offsets array with exactly 100 elements. */
+	coffsets[0] = NUM2INT(sectors); /* 0 is always the leadout track */
+	while (i <= length && i < 100)
+	{
+		coffsets[i] = NUM2INT(rb_ary_entry(offsets, i - 1));
+		i++;
+	}
+	
+	/* Mark the disc id as unread in case something goes wrong. */
+	rb_iv_set(self, "@read", Qfalse);
+	
+	/* Read the discid */
+	if (discid_put(disc, cfirst, clast, coffsets) == 0)
+		rb_raise(rb_eException, discid_get_error_msg(disc));
+	else /* Remember that we already read the ID. */
+		rb_iv_set(self, "@read", Qtrue);
+	
+	return Qnil;
+}
+
+/**
+ * call-seq:
+ *  MusicBrainz::DiscID.new(device=nil) -> obj
+ *
+ * Construct a new DiscID object.
+ * 
+ * As an optional argument the name of the device to read the ID from
+ * may be given. If you don't specify a device here you can later read
+ * the ID with the read method.
+ *
+ * Raises:: ArgumentError, TypeError, Exception
+ */
+VALUE mb_discid_new(int argc, VALUE *argv, VALUE class)
+{
+	DiscId *disc = discid_new();
+	VALUE tdata = Data_Wrap_Struct(class, 0, discid_free, disc);
+	VALUE device = Qnil;
+	rb_obj_call_init(tdata, 0, 0);
+	rb_iv_set(tdata, "@read", Qfalse);
+	
+	/* Check the number of arguments */
+	rb_scan_args(argc, argv, "01", &device);
+	
+	if (device != Qnil)
+		rb_funcall(tdata, rb_intern("read"), 1, device);
+	
+	return tdata;
+}
+
+/**
+ * call-seq:
+ *  MusicBrainz::DiscID.default_device(device=nil) -> string
+ *
+ * Returns a device string for the default device for this platform.
+ */
+VALUE mb_discid_default_device(VALUE class)
+{
+	return rb_str_new2(discid_get_default_device());
+}
+
+/**
+ * Initialize the DiscID class and make it available in Ruby.
+ */
+void Init_MB_DiscID()
+{
+	mMusicBrainz = rb_define_module("MusicBrainz");
+	cDiscID = rb_define_class_under(mMusicBrainz, "DiscID", rb_cObject);
+	rb_define_singleton_method(cDiscID, "new", mb_discid_new, -1);
+	rb_define_singleton_method(cDiscID, "default_device",
+	                           mb_discid_default_device, 0);
+	
+	rb_define_method(cDiscID, "read", mb_discid_read, -1);
+	rb_define_method(cDiscID, "put", mb_discid_put, 3);
+	rb_define_method(cDiscID, "id", mb_discid_id, 0);
+	rb_define_method(cDiscID, "submission_url", mb_discid_submission_url, 0);
+	rb_define_method(cDiscID, "freedb_id", mb_discid_freedb_id, 0);
+	rb_define_method(cDiscID, "first_track_num", mb_discid_first_track_num, 0);
+	rb_define_method(cDiscID, "last_track_num", mb_discid_last_track_num, 0);
+	rb_define_method(cDiscID, "sectors", mb_discid_sectors, 0);
+	rb_define_method(cDiscID, "tracks", mb_discid_tracks, 0);
+}

data/lib/mb-discid.rb

@@ -0,0 +1,229 @@
+# $Id: mb-discid.rb 201 2008-02-13 14:59:48Z phw $
+#
+# Just a helper file to allow loading the MB-DiscID library with
+# <tt>require 'mb-discid'</tt>, which is the only recommended way
+# to load the library.
+# 
+# This file may even provide extensions to the library in the future
+# to avoid to have to write everything in C.
+# 
+# Author::    Philipp Wolfer (mailto:phw@rubyforge.org)
+# Copyright:: Copyright (c) 2007, Philipp Wolfer
+# License::   MB-DiscID is free software distributed under a BSD style license.
+#             See LICENSE[file:../LICENSE.html] for permissions.
+
+require 'MB_DiscID.so'
+
+module MusicBrainz
+
+  # Class to calculate a MusicBrainz DiscID from an audio CD in the drive.
+  # 
+  # This is basically an interface to the libdiscid C library
+  # (http://musicbrainz.org/doc/libdiscid).
+  # 
+  # == Usage
+  # === Basic Usage:
+  #  
+  #  require 'mb-discid'
+  #  
+  #  # Create a new DiscID object.
+  #  disc = MusicBrainz::DiscID.new
+  #  
+  #  # Read the TOC from the default device.
+  #  # An audio CD must be inserted in the drive. An exception will be thrown
+  #  # if the CD can't be read.
+  #  begin
+  #    disc.read
+  #  rescue Exception => e
+  #    puts e
+  #    exit(1)
+  #  end
+  #  
+  #  # Print information about the disc:
+  #  print <<EOF
+  #  DiscID      : #{disc.id}
+  #  Submit via  : #{disc.submission_url}
+  #  FreeDB ID   : #{disc.freedb_id}
+  #  First track : #{disc.first_track_num}
+  #  Last track  : #{disc.last_track_num}
+  #  Total length: #{disc.seconds} seconds
+  #  Sectors     : #{disc.sectors}
+  #  EOF
+  #  
+  #  # Print information about individual tracks:
+  #  disc.track_details do |track_info|
+  #    puts "Track ##{track_info.number}"
+  #    puts "  Length: %02d:%02d (%i sectors)" %
+  #       [track_info.seconds / 60, track_info.seconds % 60, track_info.sectors]
+  #    puts "  Start : %02d:%02d (sector %i)" % 
+  #       [track_info.start_time / 60, track_info.start_time % 60, track_info.start_sector]
+  #    puts "  End   : %02d:%02d (sector %i)" %
+  #       [track_info.end_time / 60, track_info.end_time % 60, track_info.end_sector]
+  #  end
+  #  
+  #  # Print a submission URL that can be used to submit
+  #  # the disc ID to MusicBrainz.org.
+  #  puts "\nSubmit via #{disc.submission_url}"
+  #  
+  # === Specifying the device to read from:
+  # 
+  #  # Create a new DiscID object and read the disc in /dev/dvd:
+  #  disc = MusicBrainz::DiscID.new
+  #  disc.read('/dev/dvd')
+  #  
+  #  # Create a new DiscID object and directly read the disc in /dev/dvd:
+  #  disc = MusicBrainz::DiscID.new('/dev/dvd')
+  #  
+  #  # Create a new DiscID object and directly read the disc in the platform's
+  #  # default device:
+  #  disc = MusicBrainz::DiscID.new(MusicBrainz::DiscID.default_device)
+  #  
+  # === Calculating the DiscID for a given TOC
+  # 
+  #  disc = MusicBrainz::DiscID.new
+  #  
+  #  first_track   = 1
+  #  sectors       = 224556
+  #  track_offsets = [150, 9078, 13528, 34182, 53768, 70987, 96424,
+  #                   118425, 136793, 159514, 179777, 198006]
+  #  
+  #  disc.put(first_track, sectors, track_offsets)
+  #  puts disc.id # Should print "T_prJXQSrqbnH8OE.dgOKsHm5Uw-"
+  #  
+  class DiscID
+  
+    # This class holds information about a single track.
+    # 
+    # Currently this includes the following fields:
+    # [number]       The number of the track on the disc.
+    # [sectors]      Length of the track in sectors.
+    # [start_sector] Start position of the track on the disc in sectors.
+    # [end_sector]   End position of the track on the disc in sectors.
+    # [seconds]      Length of the track in seconds.
+    # [start_time]   Start position of the track on the disc in seconds.
+    # [end_time]     End position of the track on the disc in seconds.
+    # 
+    # You can access all fields either with directly or with the square bracket
+    # notation:
+    # 
+    #  track = TrackInfo.new(1, 150, 16007)
+    #  puts track.sectors   # 16007
+    #  puts track[:sectors] # 16007
+    #  
+    # See:: DiscID#track_details
+    class TrackInfo
+      
+      # The number of the track on the disc.
+      attr_reader :number
+      
+      # Length of the track in sectors.
+      attr_reader :sectors
+      
+      # Start position of the track on the disc in sectors.
+      attr_reader :start_sector
+      
+      # Returns a new TrackInfo.
+      def initialize(number, offset, length)
+        @number = number
+        @start_sector = offset
+        @sectors = length
+      end
+      
+      # End position of the track on the disc in sectors.
+      def end_sector
+        start_sector + sectors
+      end
+      
+      # Length of the track in seconds.
+      def seconds
+        DiscID.sectors_to_seconds(sectors)
+      end
+      
+      # Start position of the track on the disc in seconds.
+      def start_time
+        DiscID.sectors_to_seconds(start_sector)
+      end
+      
+      # End position of the track on the disc in seconds.
+      def end_time
+        DiscID.sectors_to_seconds(end_sector)
+      end
+      
+      # Allows access to all fields similar to accessing values in a hash.
+      # 
+      # Example:
+      #  track = TrackInfo.new(1, 150, 16007)
+      #  puts track.sectors   # 16007
+      #  puts track[:sectors] # 16007
+      def [](key)
+        if [:number, :sectors, :start_sector, :end_sector,
+            :seconds, :start_time, :end_time].include?(key.to_sym)
+          method(key).call
+        end
+      end
+      
+      # Converts the TrackInfo into a Hash.
+      def to_hash
+        {
+        :sectors      => sectors,
+        :start_sector => start_sector,
+        :end_sector   => end_sector,
+        :seconds      => seconds,
+        :start_time   => start_time,
+        :end_time     => end_time,
+        }
+      end
+      
+    end
+    
+    # DiscID to String conversion. Same as calling the method id but guaranteed
+    # to return a string.
+    def to_s
+      id.to_s
+    end
+    
+    # Return the length of the disc in sectors.
+    # 
+    # Returns <tt>nil</tt> if no ID was yet read. 
+    def seconds
+      DiscID.sectors_to_seconds(sectors) unless @read == false
+    end
+    
+    # Returns an array of TrackInfo objects. Each TrackInfo object contains
+    # detailed information about the track.
+    # 
+    # If a block is given this method returns <tt>nil</tt> and instead iterates
+    # over the block calling the block with one argument <tt>|track_info|</tt>.
+    # 
+    # Returns always <tt>nil</tt> if no ID was yet read. The block won't be
+    # called in this case.
+    def track_details
+      unless @read == false
+        track_number = self.first_track_num - 1
+        tracks = []
+        
+        self.tracks do |offset, length|
+          track_number += 1
+          track_info = TrackInfo.new(track_number, offset, length)
+          
+          if block_given?
+            yield track_info
+          else
+            tracks << track_info
+          end
+        end
+        
+        return tracks unless block_given?
+      end
+    end
+    
+    # Converts sectors to seconds.
+    # 
+    # According to the red book standard 75 sectors are one second.
+    def self.sectors_to_seconds(sectors)
+      return (sectors.to_f / 75).round
+    end
+    
+  end
+
+end

data/test/test_discid.rb

@@ -0,0 +1,173 @@
+# $Id: test_discid.rb 236 2009-05-07 05:58:07Z phw $
+#
+# Author::    Philipp Wolfer (mailto:phw@rubyforge.org)
+# Copyright:: Copyright (c) 2007, Philipp Wolfer
+# License::   RBrainz is free software distributed under a BSD style license.
+#             See LICENSE[file:../LICENSE.html] for permissions.
+
+require 'test/unit'
+require 'mb-discid'
+
+# Helper class which can't be converted into a string.
+class NotAString
+  
+  private
+  
+  def to_s
+  end
+
+end
+
+# Unit test for the MusicBrainz::DiscID class.
+class TestDiscID < Test::Unit::TestCase
+
+  def setup
+    @fiction_disc_id     = 'Wn8eRBtfLDfM0qjYPdxrz.Zjs_U-'
+    @fiction_first_track = 1
+    @fiction_last_track  = 10
+    @fiction_sectors     = 206535
+    @fiction_seconds     = 2754
+    @fiction_offsets     = [150, 18901, 39738, 59557, 79152, 100126,
+                            124833, 147278, 166336, 182560]
+    @fiction_lengths     = [18751, 20837, 19819, 19595, 20974,
+                            24707, 22445, 19058, 16224, 23975]
+  end
+
+  def teardown
+  end
+  
+  # Test reading the disc id from a device.
+  # We would need some kind of small test data to do this.
+  #def test_read
+  #  assert false, "Not implemented yet"
+  #end
+  
+  # Test how read reacts on different arguments.
+  # Those reads should all fail, but they must never cause a segmentation fault.
+  def test_read_invalid_arguments
+    assert_raise(TypeError) {MusicBrainz::DiscID.new(NotAString.new)}
+    assert_raise(Exception) {MusicBrainz::DiscID.new(1)}
+    assert_raise(Exception) {MusicBrainz::DiscID.new('invalid_device')}
+    assert_raise(Exception) {MusicBrainz::DiscID.new(:invalid_device)}
+    assert_raise(ArgumentError) {MusicBrainz::DiscID.new(
+                                           MusicBrainz::DiscID.default_device,
+                                           'second argument')}
+    
+    disc = MusicBrainz::DiscID.new
+    assert_raise(TypeError) {disc.read(NotAString.new)}
+    assert_raise(Exception) {disc.read(1)}
+    assert_raise(Exception) {disc.read('invalid_device')}
+    assert_raise(Exception) {disc.read(:invalid_device)}
+    assert_raise(ArgumentError) {disc.read(MusicBrainz::DiscID.default_device,
+                                           'second argument')}
+  end
+  
+  # Test calculation of the disc id if the TOC information
+  # gets set by the put method.
+  # All attributes should be nil after a failure, even if there was a
+  # successfull put before.
+  def test_put
+    disc = MusicBrainz::DiscID.new
+    assert_equal nil, disc.id
+    assert_equal '', disc.to_s
+    assert_equal nil, disc.first_track_num
+    assert_equal nil, disc.last_track_num
+    assert_equal nil, disc.sectors
+    assert_equal nil, disc.seconds
+    assert_equal nil, disc.tracks
+    
+    # First erroneous put
+    assert_raise(Exception) {disc.put(-1, @fiction_sectors, @fiction_offsets)}
+    assert_equal nil, disc.id
+    assert_equal '', disc.to_s
+    assert_equal nil, disc.first_track_num
+    assert_equal nil, disc.last_track_num
+    assert_equal nil, disc.sectors
+    assert_equal nil, disc.seconds
+    assert_equal nil, disc.tracks
+    
+    # Second successfull put
+    assert_nothing_raised {disc.put(@fiction_first_track, @fiction_sectors,
+                                    @fiction_offsets)}
+    assert_equal @fiction_disc_id, disc.id
+    assert_equal @fiction_disc_id, disc.to_s
+    assert_equal @fiction_first_track, disc.first_track_num
+    assert_equal @fiction_last_track, disc.last_track_num
+    assert_equal @fiction_sectors, disc.sectors
+    assert_equal @fiction_seconds, disc.seconds
+    assert_equal @fiction_offsets, disc.tracks.map{|t| t[0]}
+    assert_equal @fiction_lengths, disc.tracks.map{|t| t[1]}
+    
+    # Third erroneous put
+    assert_raise(Exception) {disc.put(@fiction_first_track, @fiction_sectors, 
+                                      Array.new(100, 1))}
+    assert_equal nil, disc.id
+    assert_equal '', disc.to_s
+    assert_equal nil, disc.first_track_num
+    assert_equal nil, disc.last_track_num
+    assert_equal nil, disc.sectors
+    assert_equal nil, disc.seconds
+    assert_equal nil, disc.tracks
+  end
+  
+  # Test the track info method and TrackInfo objects
+  def test_track_details
+    disc = MusicBrainz::DiscID.new
+    
+    assert_equal nil, disc.track_details
+    assert_nothing_raised {disc.put(@fiction_first_track, @fiction_sectors,
+                                    @fiction_offsets)}
+    
+    
+    # Save a block for testing each track
+    number = 0
+    proc_test_track = lambda do |track|
+      assert_equal number + 1, track.number
+      
+      assert_equal @fiction_offsets[number], track.start_sector
+      assert_equal @fiction_lengths[number], track.sectors
+      assert_equal @fiction_offsets[number]+ @fiction_lengths[number],
+                   track.end_sector
+                   
+      assert_equal MusicBrainz::DiscID.sectors_to_seconds(@fiction_offsets[number]),
+                   track.start_time
+      assert_equal MusicBrainz::DiscID.sectors_to_seconds(@fiction_lengths[number]),
+                   track.seconds
+      assert_equal MusicBrainz::DiscID.sectors_to_seconds(
+                     @fiction_offsets[number]+ @fiction_lengths[number]),
+                   track.end_time
+      
+      assert_equal track.number, track[:number]
+      assert_equal track.sectors, track[:sectors]
+      assert_equal track.start_sector, track[:start_sector]
+      assert_equal track.end_sector, track[:end_sector]
+      assert_equal track.seconds, track[:seconds]
+      assert_equal track.start_time, track[:start_time]
+      assert_equal track.end_time, track[:end_time]
+      
+      assert_equal nil, track[:invalid_value]
+      
+      number += 1
+    end
+    
+    # Call track_info and retrieve an Array
+    track_info = []                               
+    assert_nothing_raised {track_info = disc.track_details}
+    assert track_info.is_a?(Array)
+    track_info.each(&proc_test_track)
+    assert_equal disc.last_track_num, number
+    
+    # Calling track_info directly with a given block
+    number = 0 # Reset the number of tracks (the above block is a closure, so this works)
+    assert_equal nil, disc.track_details(&proc_test_track)
+    assert_equal disc.last_track_num, number
+  end
+  
+  # Test the conversion from sectors to seconds
+  def test_sectors_to_seconds
+    assert_equal 0, MusicBrainz::DiscID.sectors_to_seconds(0)
+    assert_equal @fiction_seconds,
+                 MusicBrainz::DiscID.sectors_to_seconds(@fiction_sectors)
+  end
+  
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: mb-discid
+version: !ruby/object:Gem::Version 
+  version: 0.1.4
+platform: x86-mswin32-60
+authors: 
+- Philipp Wolfer
+autorequire: mb-discid
+bindir: bin
+cert_chain: []
+
+date: 2009-11-19 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: "    Ruby bindings for libdiscid. See http://musicbrainz.org/doc/libdiscid\n    for more information on libdiscid and MusicBrainz.\n"
+email: phw@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- CHANGES
+files: 
+- Rakefile
+- LICENSE
+- README
+- CHANGES
+- examples/discid.rb
+- ext/mb_discid.c
+- ext/extconf.rb
+- lib/mb-discid.rb
+- test/test_discid.rb
+- ext/MB_DiscID.so
+has_rdoc: true
+homepage: http://rbrainz.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.7
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- libdiscid (http://musicbrainz.org/doc/libdiscid)
+rubyforge_project: rbrainz
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for libdiscid.
+test_files: []
+