libuuidrb 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Sebastian Ohm. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,12 @@
+LICENSE
+Manifest
+README
+Rakefile
+ext/extconf.rb
+ext/lib_uuid.c
+ext/lib_uuid.h
+ext/uuid_base64.c
+ext/uuid_base64.h
+libuuidrb.gemspec
+test/test_compatibility.rb
+test/test_functionality.rb

data/README

@@ -0,0 +1,36 @@
+libuuidrb uses e2fsprogs'[1] libuuid (<uuid/uuid.h>) to generate DCE
+compatible universally unique identifiers.
+
+0. prerequesites
+
+$ irb
+>> require 'lib_uuid'
+
+1. generating
+
+>> u = LibUUID::UUID.new
+=> #<LibUUID::UUID:0x969decc>
+>> u.to_guid # => "965555c1-2860-47f5-a3f5-a9c83a3b0b5e"
+>> u.to_short_guid # => "llVVwShgR_Wj9anIOjsLXg"
+
+or
+
+>> LibUUID::UUID.guid # => "ca220b11-a974-4c1d-99d1-78c32d997848"
+>> LibUUID::UUID.short_guid # => "8fPommPCQ7y1BSh55d7kFw"
+
+2. parsing
+
+>> v = LibUUID::UUID.new(u.to_guid) # => #<LibUUID::UUID:0x9696b2c>
+>> w = LibUUID::UUID.new(u.to_short_guid) # => #<LibUUID::UUID:0x9693684>
+>> u == v # => true
+>> u == w # => true
+
+3. validating
+
+>> LibUUID::UUID.valid? u.to_guid # => true
+>> LibUUID::UUID.valid? v.to_short_guid # => true
+>> LibUUID::UUID.valid? u.to_guid, v.to_guid, w.to_short_guid # => true
+>> LibUUID::UUID.valid? 'foo' # => false
+
+
+[1] http://e2fsprogs.sourceforge.net/

data/Rakefile

@@ -0,0 +1,26 @@
+begin
+  require 'rubygems'
+  require 'rake'
+  require 'echoe'
+
+  Echoe.new('libuuidrb', '0.1.0') do |p|
+    p.author         = 'Sebastian Ohm'
+    p.url            = 'http://github.com/ohm/libuuidrb'
+    p.description    = 'libuuidrb uses libuuid to generate DCE compatible universally unique identifiers'
+    p.ignore_pattern = ['tmp/*', 'script/*', 'benchmark/*']
+    p.development_dependencies = []
+  end
+
+  desc 'valgrind functional tests'
+  task :valgrind do
+    opts = %W(
+      --partial-loads-ok=yes
+      --undef-value-errors=no
+      --leak-check=full
+    )
+
+    sh "valgrind #{opts.join(' ')} ruby test/test_functionality.rb"
+  end
+rescue LoadError => le
+  puts "#{le.message}"
+end

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+$CFLAGS = '-Wno-char-subscripts'
+
+extension_name = "lib_uuid"
+
+crash "need libuuid" if !have_library "uuid"
+
+dir_config extension_name
+create_makefile extension_name

data/ext/lib_uuid.c

@@ -0,0 +1,236 @@
+#include <ruby.h>
+#include <uuid/uuid.h>
+
+#include "uuid_base64.h"
+#include "lib_uuid.h"
+
+void
+lib_uuid_free(lib_uuid_t *s)
+{
+  free(s);
+}
+
+int
+uuid_from_obj(VALUE obj, uuid_t uu)
+{
+  long len;
+  char *ptr;
+
+  if( TYPE(obj) != T_STRING )
+    return -1;
+
+  len = RSTRING_LEN(obj);
+  ptr = RSTRING_PTR(obj);
+
+  if( len == GUID_STRLEN-1 )
+    return uuid_parse(ptr, uu);
+
+  if( len == SHORT_GUID_STRLEN-1)
+    return uuid_decode64(ptr, uu);
+
+  return -1;
+}
+
+int
+uuid_validity_check(const uuid_t uu)
+{
+  int type, variant;
+
+  type = uuid_type(uu);
+  if( type != UUID_TYPE_DCE_TIME && type != UUID_TYPE_DCE_RANDOM )
+    return -1;
+
+  variant = uuid_variant(uu);
+  if( variant < UUID_VARIANT_NCS || variant > UUID_VARIANT_OTHER )
+    return -1;
+
+  return 0;
+}
+
+VALUE
+lib_uuid_new(unsigned int argc, VALUE *argv, VALUE class)
+{
+  lib_uuid_t *s;
+  uuid_t     parsed_uu;
+  VALUE      ret;
+
+  if( argc > 1 )
+    rb_raise(rb_eArgError, "too many arguments");
+
+  if( argc == 0 )
+    uuid_generate(parsed_uu);
+
+  if( argc == 1 )
+  {
+    if( uuid_from_obj(argv[0], parsed_uu) == -1 )
+      return Qnil;
+
+    if( uuid_validity_check(parsed_uu) == -1 )
+      return Qnil;
+  }
+
+  s = ALLOC_N(lib_uuid_t, 1);
+  uuid_copy(s->uu, parsed_uu);
+  ret = Data_Wrap_Struct(class, NULL, lib_uuid_free, s);
+  rb_obj_call_init(ret, 0, 0);
+
+  return ret;
+}
+
+VALUE
+lib_uuid_valid(unsigned int argc, VALUE *argv, VALUE class)
+{
+  int   i;
+  VALUE test[1];
+
+  if( argc == 0 )
+    rb_raise(rb_eArgError, "too few arguments");
+
+  for( i=0 ; i<argc ; i++ )
+  {
+    test[0] = argv[i];
+    if( lib_uuid_new(1, test, class) == Qnil )
+      return Qfalse;
+  }
+
+  return Qtrue;
+}
+
+VALUE
+lib_uuid_generate_guid(VALUE class)
+{
+  char   uu_str[GUID_STRLEN];
+  uuid_t uu;
+
+  uuid_generate(uu);
+  uuid_unparse(uu, uu_str);
+
+  return rb_str_new(uu_str, GUID_STRLEN-1);
+}
+
+VALUE
+lib_uuid_generate_short_guid(VALUE class)
+{
+  char   uu_str[SHORT_GUID_STRLEN];
+  uuid_t uu;
+
+  uuid_generate(uu);
+  uuid_encode64(uu, uu_str);
+
+  return rb_str_new(uu_str, SHORT_GUID_STRLEN-1);
+}
+
+VALUE
+lib_uuid_initialize(VALUE self)
+{
+  lib_uuid_t *s;
+
+  Data_Get_Struct(self, lib_uuid_t, s);
+  s->guid = s->short_guid = s->type = s->variant = 0;
+  rb_iv_set(self, "@bytes", rb_str_new((char *) s->uu, 16));
+
+  return self;
+}
+
+VALUE
+lib_uuid_bytes(VALUE self)
+{
+  return rb_iv_get(self, "@bytes");
+}
+
+VALUE
+lib_uuid_type(VALUE self)
+{
+  lib_uuid_t *s;
+
+  Data_Get_Struct(self, lib_uuid_t, s);
+
+  if( s->type == 0 )
+    s->type = INT2NUM(uuid_type(s->uu));
+
+  return s->type;
+}
+
+VALUE
+lib_uuid_variant(VALUE self)
+{
+  lib_uuid_t *s;
+
+  Data_Get_Struct(self, lib_uuid_t, s);
+
+  if( s->variant == 0 )
+    s->variant = INT2NUM(uuid_variant(s->uu));
+
+  return s->variant;
+}
+
+VALUE
+lib_uuid_to_guid(VALUE self)
+{
+  lib_uuid_t *s;
+  char       uu_str[GUID_STRLEN];
+
+  Data_Get_Struct(self, lib_uuid_t, s);
+
+  if( s->guid == 0 )
+  {
+    uuid_unparse(s->uu, uu_str);
+    s->guid = rb_str_new(uu_str, GUID_STRLEN-1);
+  }
+
+  return s->guid;
+}
+
+VALUE
+lib_uuid_to_short_guid(VALUE self)
+{
+  lib_uuid_t *s;
+  char       uu_str[SHORT_GUID_STRLEN];
+
+  Data_Get_Struct(self, lib_uuid_t, s);
+
+  if( s->short_guid == 0 )
+  {
+    uuid_encode64(s->uu, uu_str);
+    s->short_guid = rb_str_new(uu_str, SHORT_GUID_STRLEN-1);
+  }
+
+  return s->short_guid;
+}
+
+VALUE
+lib_uuid_equality(VALUE self, VALUE other)
+{
+  lib_uuid_t *s, *o;
+
+  if( TYPE(self) != T_DATA || TYPE(other) != T_DATA )
+    return Qfalse;
+
+  Data_Get_Struct(self, lib_uuid_t, s);
+  Data_Get_Struct(other, lib_uuid_t, o);
+
+  if( uuid_compare(s->uu, o->uu) != 0 )
+    return Qfalse;
+
+  return Qtrue;
+}
+
+void
+Init_lib_uuid()
+{
+  VALUE m_lib_uuid, c_lib_uuid;
+
+  m_lib_uuid = rb_define_module("LibUUID");
+  c_lib_uuid = rb_define_class_under(m_lib_uuid, "UUID", rb_cObject);
+  rb_define_singleton_method(c_lib_uuid, "new", lib_uuid_new, -1);
+  rb_define_singleton_method(c_lib_uuid, "valid?", lib_uuid_valid, -1);
+  rb_define_singleton_method(c_lib_uuid, "guid", lib_uuid_generate_guid, 0);
+  rb_define_singleton_method(c_lib_uuid, "short_guid", lib_uuid_generate_short_guid, 0);
+  rb_define_method(c_lib_uuid, "initialize", lib_uuid_initialize, 0);
+  rb_define_method(c_lib_uuid, "bytes", lib_uuid_bytes, 0);
+  rb_define_method(c_lib_uuid, "type", lib_uuid_type, 0);
+  rb_define_method(c_lib_uuid, "variant", lib_uuid_variant, 0);
+  rb_define_method(c_lib_uuid, "to_guid", lib_uuid_to_guid, 0);
+  rb_define_method(c_lib_uuid, "to_short_guid", lib_uuid_to_short_guid, 0);
+  rb_define_method(c_lib_uuid, "==", lib_uuid_equality, 1);
+}

data/ext/lib_uuid.h

@@ -0,0 +1,11 @@
+#include <uuid/uuid.h>
+
+#define GUID_STRLEN       36+1
+#define SHORT_GUID_STRLEN 22+1
+
+typedef struct {
+
+  VALUE guid, short_guid, type, variant;
+  uuid_t uu;
+
+} lib_uuid_t;

data/ext/uuid_base64.c

@@ -0,0 +1,52 @@
+#include <uuid/uuid.h>
+
+#include "uuid_base64.h"
+
+void
+uuid_encode64(const uuid_t uu, char *str)
+{
+  int i;
+
+  for( i=0; i<5; i++ )
+  {
+    *str++ = e64[  uu[0] >> 2];
+    *str++ = e64[((uu[0] << 4) & 0x30) | (uu[1] >> 4)];
+    *str++ = e64[((uu[1] << 2) & 0x3c) | (uu[2] >> 6)];
+    *str++ = e64[  uu[2] & 0x3f];
+    uu += 3;
+  }
+
+  *str++ = e64[ uu[0] >> 2];
+  *str++ = e64[(uu[0] << 4) & 0x30];
+  *str++ = '\0';
+}
+
+int
+uuid_decode64(const char *str, uuid_t uu)
+{
+  int           i, j;
+  unsigned char buf[3];
+
+  for( i=0; i<5; i++ )
+  {
+    buf[0] = (unsigned char)  d64[str[0]] << 2 | d64[str[1]] >> 4;
+    buf[1] = (unsigned char)  d64[str[1]] << 4 | d64[str[2]] >> 2;
+    buf[2] = (unsigned char) (d64[str[2]] << 6) & 0xc0 | d64[str[3]];
+
+    for( j=0; j<3; j++ )
+      if( buf[j] != -1 )
+        *uu++ = buf[j];
+      else
+        return buf[j];
+
+    str += 4;
+  }
+
+  buf[0] = (unsigned char) d64[str[0]] << 2 | d64[str[1]] >> 4;
+  if( buf[0] != -1 )
+    *uu++ = buf[0];
+  else
+    return buf[0];
+
+  return 0;
+}

data/ext/uuid_base64.h

@@ -0,0 +1,20 @@
+static const char e64[] =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+static const char d64[] = {
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
+  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+  -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
+  -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
+};
+
+void
+uuid_encode64(const uuid_t uu, char *str);
+
+int
+uuid_decode64(const char *str, uuid_t uu);
+

data/libuuidrb.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{libuuidrb}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sebastian Ohm"]
+  s.date = %q{2010-03-07}
+  s.description = %q{libuuidrb uses libuuid to generate DCE compatible universally unique identifiers}
+  s.email = %q{}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = ["LICENSE", "README", "ext/extconf.rb", "ext/lib_uuid.c", "ext/lib_uuid.h", "ext/uuid_base64.c", "ext/uuid_base64.h", "libuuidrb.gemspec"]
+  s.files = ["LICENSE", "Manifest", "README", "Rakefile", "ext/extconf.rb", "ext/lib_uuid.c", "ext/lib_uuid.h", "ext/uuid_base64.c", "ext/uuid_base64.h", "libuuidrb.gemspec", "test/test_compatibility.rb", "test/test_functionality.rb"]
+  s.homepage = %q{http://github.com/ohm/libuuidrb}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Libuuidrb", "--main", "README"]
+  s.require_paths = ["ext"]
+  s.rubyforge_project = %q{libuuidrb}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{libuuidrb uses libuuid to generate DCE compatible universally unique identifiers}
+  s.test_files = ["test/test_compatibility.rb", "test/test_functionality.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/test_compatibility.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'test/unit'
+
+begin
+  require File.expand_path(File.dirname(__FILE__) + '/../ext/lib_uuid')
+  require 'simple_uuid'
+  require 'uuidtools'
+
+  class TestCompatibility < Test::Unit::TestCase
+    def test_parsing_uuidtools_timestamp_guids
+      u = UUIDTools::UUID.timestamp_create
+      l = LibUUID::UUID.new(u.to_s)
+      assert_equal u.to_s, l.to_guid
+      assert_equal 1, l.type
+      assert_equal 1, l.variant
+    end
+
+    def test_parsing_uuidtools_random_guids
+      u = UUIDTools::UUID.random_create
+      l = LibUUID::UUID.new(u.to_s)
+      assert_equal u.to_s, l.to_guid
+      assert_equal 4, l.type
+      assert_equal 1, l.variant
+    end
+
+    def test_parsing_simple_uuid_guids
+      f = SimpleUUID::UUID.new
+      g = LibUUID::UUID.new(f.to_guid)
+      assert_equal f.to_guid, g.to_guid
+      assert_equal 1, g.type
+      assert_equal 1, g.variant
+    end
+  end
+rescue LoadError => le
+  puts "Skipping compatibility tests: #{le.message}"
+end

data/test/test_functionality.rb

@@ -0,0 +1,109 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + '/../ext/lib_uuid')
+
+class TestLibUUUID < Test::Unit::TestCase
+
+  EXPR = {
+    :rfc => /\A[a-z0-9]{8}\-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}\Z/,
+    :b64 => /\A[A-Za-z0-9\-\_]{22}\Z/
+  }
+
+  def test_guid_generation
+    guids = []
+    1.upto(100) { guids << LibUUID::UUID.guid }
+    assert_equal guids.size, guids.uniq.size
+    assert_equal guids.size, guids.reject {|g| (g =~ EXPR[:rfc]) != 0}.size
+  end
+
+  def test_short_guid_generation
+    short_guids = []
+    1.upto(100) { short_guids << LibUUID::UUID.short_guid }
+    assert_equal short_guids.size, short_guids.uniq.size
+    assert_equal short_guids.size, short_guids.reject { |sg| (sg =~ EXPR[:b64]) != 0 }.size
+  end
+
+  def test_initialization
+    u = LibUUID::UUID.new
+    assert LibUUID::UUID == u.class
+    assert 4 == u.type
+    assert 1 == u.variant
+  end
+
+  def test_positive_equality
+    u = LibUUID::UUID.new
+    assert u == u
+  end
+
+  def test_negative_equality
+    u = LibUUID::UUID.new
+    v = LibUUID::UUID.new
+    assert u != v
+    assert u != 1
+    assert u != nil
+    assert u != 'foo'
+  end
+
+  def test_transformation_to_guid
+    u = LibUUID::UUID.new
+    assert_match EXPR[:rfc], u.to_guid
+    assert u.to_guid == u.to_guid
+  end
+
+  def test_transformation_to_short_guid
+    u = LibUUID::UUID.new
+    assert_match EXPR[:b64], u.to_short_guid
+    assert u.to_short_guid == u.to_short_guid
+  end
+
+  def test_parsing_guids
+    assert_nil LibUUID::UUID.new(nil)
+    assert_nil LibUUID::UUID.new(123)
+    assert_nil LibUUID::UUID.new('foo')
+
+    u = LibUUID::UUID.new
+    assert u == LibUUID::UUID.new(u.to_guid)
+    assert u == LibUUID::UUID.new(u.to_short_guid)
+
+    assert_raise ArgumentError do
+      LibUUID::UUID.new(u.to_guid, u.to_guid)
+    end
+  end
+
+  def test_positive_validating_guids_and_short_guids
+    assert LibUUID::UUID.valid?(LibUUID::UUID.guid)
+    assert LibUUID::UUID.valid?(LibUUID::UUID.short_guid)
+    assert LibUUID::UUID.valid?(LibUUID::UUID.guid, LibUUID::UUID.guid)
+    assert LibUUID::UUID.valid?(LibUUID::UUID.guid, LibUUID::UUID.short_guid)
+    assert LibUUID::UUID.valid?(LibUUID::UUID.short_guid, LibUUID::UUID.short_guid)
+  end
+
+  def test_negative_validating_guids_and_short_guids
+    assert false == LibUUID::UUID.valid?(1)
+    assert false == LibUUID::UUID.valid?('foo', LibUUID::UUID.short_guid)
+    assert false == LibUUID::UUID.valid?(nil, 'foo', LibUUID::UUID.guid)
+
+    assert_raise ArgumentError do
+      LibUUID::UUID.valid?
+    end
+  end
+
+  def test_accessing_raw_bytes
+    examples = {
+      "99744ce4-22ef-11df-9985-b2d60a1a84bd" =>
+        "\x99tL\xE4\"\xEF\x11\xDF\x99\x85\xB2\xD6\n\x1A\x84\xBD",
+      "9974502c-22ef-11df-9ef4-56b2ae6e82ba" =>
+        "\x99tP,\"\xEF\x11\xDF\x9E\xF4V\xB2\xAEn\x82\xBA",
+      "9974525c-22ef-11df-83d0-49d493d646c4" =>
+        "\x99tR\\\"\xEF\x11\xDF\x83\xD0I\xD4\x93\xD6F\xC4",
+      "9974546e-22ef-11df-9f68-0d1a49a6205e" =>
+        "\x99tTn\"\xEF\x11\xDF\x9Fh\r\x1AI\xA6 ^",
+      "99745680-22ef-11df-94f8-8f1188b64943" =>
+        "\x99tV\x80\"\xEF\x11\xDF\x94\xF8\x8F\x11\x88\xB6IC"
+    }
+
+    examples.each do |guid, bytes|
+      l = LibUUID::UUID.new(guid)
+      assert_equal bytes, l.bytes
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: libuuidrb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sebastian Ohm
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-07 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: libuuidrb uses libuuid to generate DCE compatible universally unique identifiers
+email: ""
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README
+- ext/extconf.rb
+- ext/lib_uuid.c
+- ext/lib_uuid.h
+- ext/uuid_base64.c
+- ext/uuid_base64.h
+- libuuidrb.gemspec
+files: 
+- LICENSE
+- Manifest
+- README
+- Rakefile
+- ext/extconf.rb
+- ext/lib_uuid.c
+- ext/lib_uuid.h
+- ext/uuid_base64.c
+- ext/uuid_base64.h
+- libuuidrb.gemspec
+- test/test_compatibility.rb
+- test/test_functionality.rb
+has_rdoc: true
+homepage: http://github.com/ohm/libuuidrb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Libuuidrb
+- --main
+- README
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: libuuidrb
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: libuuidrb uses libuuid to generate DCE compatible universally unique identifiers
+test_files: 
+- test/test_compatibility.rb
+- test/test_functionality.rb