bzip2-ruby-rb20 0.2.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d53fed8813747479d6f28b31d519c2e160266f73
+  data.tar.gz: d35d85059cfd805ca21b56c13f8f0d8c98a6647d
+SHA512:
+  metadata.gz: 9f932725f330c2524e9639ca0f808902035e392e6f9471212b235dd6f0cdaff53d70b388464e8b4c02c564b1c65b0de9af594341e53c7c77995bda893ee1797f
+  data.tar.gz: 7969c3049e2e1fbff585adddf83ac952157a903ac93ee294e7cc00ce26d5219b977d3d8174d1bba13e09f08e8f62446d5b43336793fca86e8356869e59f9ef9f

data/.gitignore

@@ -0,0 +1,10 @@
+_10lines_
+doc
+ext/Makefile
+*.o
+*.so
+*.bundle
+pkg
+.bundle
+tmp
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format=documentation

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx
+  - ree
+  - ruby-head
+  - rbx-18mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode
+script:
+  - bundle exec rake
+  - bundle exec rspec

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/CHANGELOG.md

@@ -0,0 +1,94 @@
+## 0.2.7 2010-11-16
+
+* Add documentation for an overview of the Bzip2 module
+* Document the class methods on Bzip2 and get them to show up in yarddoc
+* Remove the ConfigError class because searching for it showed no instances of its usage
+* Add a Usage section to the README and a bit about adding it to a Gemfile
+* Improve the reader_spec.rb by making it more resilient in lots of places and a bit more descriptive/terse in
+* Add a lot more documentation for the Reader class and also touch up the Writer class a bit
+* Make the Writer specs more descriptive by giving them some doc strings.
+* Wrap up documentation of the Bzip2::Writer class.
+* Add lib/bzip2-ruby.rb so it's not always necessary to specify to require 'bzip2' in Gemfiles and such
+* Start documenting the Bzip2::Writer class
+* Fix a few compiler warnings
+* Removed some dead code
+* Fix for ruby 1.9 compatibility.
+* Fix segfault when exiting in ruby 1.9
+* Follow the newer conventions of rspec
+* Migrate to using Bundler instead of Jeweler
+* use malloc/free instead of ruby_xmalloc/ruby_xfree
+
+## 0.2.6 2009-10-6
+
+* Updated to support Ruby 1.8.5
+
+## 0.2.5 2009-06-07
+
+* initial conversion of original tests over to rspec
+
+## 0.2.4 2009-05-02
+
+* renamed BZ2 module/namespace to Bzip2
+
+## 0.2.3 2009-05-02
+
+* renamed gem to bzip2-ruby from bz2
+* initial conversion to jeweler
+* bundling gemspec
+* README and file structure organization updates
+* updated Init_*() ruby initializer function to match new gem name
+
+## 0.2.2 2008-12-22
+
+* 1 major enhancement:
+  * Gemify bz2 library from http://moulon.inra.fr/ruby/bz2.html
+  * All credit goes to Guy Decoux <ts@moulon.inra.fr>
+
+## 0.2.1
+
+* replaced rb_proc_new() with bz_proc_new() for 1.6
+(Thanks "Akinori MUSHA" <knu@iDaemons.org>)
+
+## 0.1.9
+
+* corrected BZ_FINISH_OK (Thanks Rudi Cilibrasi <Rudi.Cilibrasi@cwi.nl>)
+
+## 0.1.6
+
+* adapted for 1.8.0 (ihi)
+* modified ::new
+* BZ2::Writer#finish (same than #flush)
+
+## 0.1.5
+
+* corrected extconf.rb
+* added close!
+* replaced close(false) by #finish
+* corrected #flush
+
+## 0.1.4
+
+* corrected bz_iv
+* #to_io
+* corrected ::Reader#close
+
+## 0.1.3
+
+* corrected #lineno
+* corrected ::Writer::new(nil)
+* taint result
+
+## 0.1.2
+
+* better (???) interface for #read
+* finalize for objects which respond to #closed?
+
+## 0.1.1
+
+* better interface for T_FILE
+* corrected bug with gc (buf)
+* Reader#lineno, Reader#lineno=, Reader#ungets
+* corrected Reader#unused
+* taint check in #initialize
+* BZ2::bzip2, BZ2::bunzip2
+* too many exceptions

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,69 @@
+# Ruby C bindings to libbzip2
+
+## Installation
+
+First make sure you’ve got Gemcutter in your sources list:
+
+`gem sources -a http://gemcutter.org`
+
+Then go ahead and install it as usual:
+
+`sudo gem install bzip2-ruby`
+
+You may need to specify:
+
+`--with-bz2-dir=<include file directory for libbzip2>`
+
+Or in a Gemfile
+
+`gem 'bzip2-ruby'`
+
+## Usage
+
+The full documentation is hosted on [rdoc.info](http://rdoc.info/github/brianmario/bzip2-ruby/master/frames).
+
+Here's a quick overview, hower:
+
+``` ruby
+require 'bzip2'
+
+# Quick shortcuts
+data = Bzip2.compress 'string'
+Bzip2.uncompress data
+
+# Creating a bz2 compressed file
+writer = Bzip2::Writer.new File.open('file')
+writer << 'data1'
+writer.puts 'data2'
+writer.print 'data3'
+writer.printf '%s', 'data4'
+writer.close
+
+Bzip2::Writer.open('file'){ |f| f << data }
+
+# Reading a bz2 compressed file
+reader = Bzip2::Reader.new File.open('file')
+reader.gets # => "data1data2\n"
+reader.read # => 'data3data4'
+
+reader.readline # => raises Bzip2::EOZError
+
+Bzip2::Reader.open('file'){ |f| puts f.read }
+```
+
+## Copying
+
+```
+This extension module is copyrighted free software by Guy Decoux
+You can redistribute it and/or modify it under the same term as Ruby.
+Guy Decoux <ts@moulon.inra.fr>
+```
+
+## Modifications from origin version
+
+* Switch to Jeweler
+* Renamed BZ2 module/namespace to Bzip2
+* Renamed compiled binary from "bz2" to "bzip2"
+* Renamed gem from "bz2" to "bzip2-ruby"
+* Converted original tests to rspec
+* 1.9 compatibility

data/Rakefile

@@ -0,0 +1,35 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# rspec
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+
+  desc "Run all examples with RCov"
+  RSpec::Core::RakeTask.new('spec:rcov') do |t|
+    t.rcov = true
+  end
+  RSpec::Core::RakeTask.new('spec') do |t|
+    t.verbose = true
+  end
+
+  task :default => :spec
+rescue LoadError
+  puts "rspec, or one of its dependencies, is not available. Install it with: sudo gem install rspec"
+end
+
+# rake-compiler
+require 'rake' unless defined? Rake
+
+gem 'rake-compiler', '>= 0.7.5'
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('bzip2') do |ext|
+  ext.cross_compile = true
+  ext.cross_platform = ['x86-mingw32', 'x86-mswin32-60']
+
+  ext.lib_dir = File.join 'lib', 'bzip2'
+end
+
+Rake::Task[:spec].prerequisites << :compile

data/bzip2-ruby.gemspec

@@ -0,0 +1,21 @@
+require './lib/bzip2/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'bzip2-ruby-rb20'
+  s.version  = Bzip2::VERSION
+  s.authors  = ['Guy Decoux', 'Brian Lopezs']
+  s.date     = Time.now.utc.strftime("%Y-%m-%d")
+  s.email    = ['seniorlopez@gmail.com']
+  s.extensions = ['ext/bzip2/extconf.rb']
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'http://github.com/brianmario/bzip2-ruby'
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ['lib']
+  s.rubygems_version = %q{1.4.2}
+  s.summary  = 'Ruby C bindings to libbzip2.'
+  s.test_files = `git ls-files spec`.split("\n")
+
+  # tests
+  s.add_development_dependency 'rake-compiler', ">= 0.7.5"
+  s.add_development_dependency 'rspec', ">= 2.0.0"
+end

data/ext/bzip2/bzip2.c

@@ -0,0 +1,250 @@
+#include <ruby.h>
+#include <bzlib.h>
+
+#include "common.h"
+#include "reader.h"
+#include "writer.h"
+
+VALUE bz_cWriter, bz_cReader, bz_cInternal;
+VALUE bz_eError, bz_eEOZError;
+
+VALUE bz_internal_ary;
+
+ID id_new, id_write, id_open, id_flush, id_read;
+ID id_closed, id_close, id_str;
+
+void bz_internal_finalize(VALUE data) {
+    VALUE elem;
+    int closed, i;
+    struct bz_iv *bziv;
+    struct bz_file *bzf;
+
+    for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
+        elem = RARRAY_PTR(bz_internal_ary)[i];
+        Data_Get_Struct(elem, struct bz_iv, bziv);
+        if (bziv->bz2) {
+            RDATA(bziv->bz2)->dfree = free;
+            if (TYPE(bziv->io) == T_FILE) {
+                RFILE(bziv->io)->fptr->finalize = bziv->finalize;
+            } else if (TYPE(bziv->io) == T_DATA) {
+                RDATA(bziv->io)->dfree = bziv->finalize;
+            }
+            Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
+            closed = bz_writer_internal_flush(bzf);
+            if (bzf->flags & BZ2_RB_CLOSE) {
+                bzf->flags &= ~BZ2_RB_CLOSE;
+                if (!closed && rb_respond_to(bzf->io, id_close)) {
+                    rb_funcall2(bzf->io, id_close, 0, 0);
+                }
+            }
+        }
+    }
+}
+
+/*
+ * call-seq:
+ *   compress(str)
+ *
+ * Shortcut for compressing just a string.
+ *
+ *    Bzip2.uncompress Bzip2.compress('data') # => 'data'
+ *
+ * @param [String] str the string to compress
+ * @return [String] +str+ compressed with bz2
+ */
+VALUE bz_compress(VALUE self, VALUE str) {
+    VALUE bz2, argv[1] = {Qnil};
+
+    str = rb_str_to_str(str);
+    bz2 = rb_funcall2(bz_cWriter, id_new, 1, argv);
+    if (OBJ_TAINTED(str)) {
+        struct bz_file *bzf;
+        Data_Get_Struct(bz2, struct bz_file, bzf);
+        OBJ_TAINT(bzf->io);
+    }
+    bz_writer_write(bz2, str);
+    return bz_writer_close(bz2);
+}
+
+/*
+ * Returns the io stream underlying this stream. If the strem was constructed
+ * with a file, that is returned. Otherwise, an empty string is returned.
+ *
+ * @return [File, String] similar to whatever the stream was constructed with
+ * @raise [IOError] if the stream has been closed
+ */
+VALUE bz_to_io(VALUE obj) {
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    return bzf->io;
+}
+
+VALUE bz_str_read(int argc, VALUE *argv, VALUE obj) {
+    struct bz_str *bzs;
+    VALUE res, len;
+    int count;
+
+    Data_Get_Struct(obj, struct bz_str, bzs);
+    rb_scan_args(argc, argv, "01", &len);
+    if (NIL_P(len)) {
+        count = (int) RSTRING_LEN(bzs->str);
+    } else {
+        count = NUM2INT(len);
+        if (count < 0) {
+            rb_raise(rb_eArgError, "negative length %d given", count);
+        }
+    }
+    if (!count || bzs->pos == -1) {
+        return Qnil;
+    }
+    if ((bzs->pos + count) >= RSTRING_LEN(bzs->str)) {
+        res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos,
+            RSTRING_LEN(bzs->str) - bzs->pos);
+        bzs->pos = -1;
+    } else {
+        res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, count);
+        bzs->pos += count;
+    }
+    return res;
+}
+
+/*
+ * call-seq:
+ *    uncompress(data)
+ * Decompress a string of bz2 compressed data.
+ *
+ *    Bzip2.uncompress Bzip2.compress('asdf') # => 'asdf'
+ *
+ * @param [String] data bz2 compressed data
+ * @return [String] +data+ as uncompressed bz2 data
+ * @raise [Bzip2::Error] if +data+ is not valid bz2 data
+ */
+VALUE bz_uncompress(VALUE self, VALUE data) {
+    VALUE bz2, nilv = Qnil, argv[1];
+
+    argv[0] = rb_str_to_str(data);
+    bz2 = rb_funcall2(bz_cReader, id_new, 1, argv);
+    return bz_reader_read(1, &nilv, bz2);
+}
+
+/*
+ * Internally allocates data,
+ *
+ * @see Bzip2::Writer#initialize
+ * @see Bzip2::Reader#initialize
+ * @private
+ */
+VALUE bz_s_new(int argc, VALUE *argv, VALUE obj) {
+    VALUE res = rb_funcall2(obj, rb_intern("allocate"), 0, 0);
+    rb_obj_call_init(res, argc, argv);
+    return res;
+}
+
+void Init_bzip2() {
+    VALUE bz_mBzip2, bz_mBzip2Singleton;
+
+    bz_internal_ary = rb_ary_new();
+    rb_global_variable(&bz_internal_ary);
+    rb_set_end_proc(bz_internal_finalize, Qnil);
+
+    id_new    = rb_intern("new");
+    id_write  = rb_intern("write");
+    id_open   = rb_intern("open");
+    id_flush  = rb_intern("flush");
+    id_read   = rb_intern("read");
+    id_close  = rb_intern("close");
+    id_closed = rb_intern("closed?");
+    id_str    = rb_intern("to_str");
+
+    bz_mBzip2    = rb_define_module("Bzip2");
+    bz_eError    = rb_define_class_under(bz_mBzip2, "Error", rb_eIOError);
+    bz_eEOZError = rb_define_class_under(bz_mBzip2, "EOZError", bz_eError);
+
+    bz_mBzip2Singleton = rb_singleton_class(bz_mBzip2);
+    rb_define_singleton_method(bz_mBzip2, "compress",   bz_compress,    1);
+    rb_define_singleton_method(bz_mBzip2, "uncompress", bz_uncompress,  1);
+    rb_define_alias(bz_mBzip2Singleton, "bzip2",      "compress");
+    rb_define_alias(bz_mBzip2Singleton, "decompress", "uncompress");
+    rb_define_alias(bz_mBzip2Singleton, "bunzip2",    "uncompress");
+
+    /*
+      Writer
+    */
+    bz_cWriter = rb_define_class_under(bz_mBzip2, "Writer", rb_cData);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_define_alloc_func(bz_cWriter, bz_writer_s_alloc);
+#else
+    rb_define_singleton_method(bz_cWriter, "allocate", bz_writer_s_alloc, 0);
+#endif
+    rb_define_singleton_method(bz_cWriter, "new",   bz_s_new,            -1);
+    rb_define_singleton_method(bz_cWriter, "open",  bz_writer_s_open,    -1);
+    rb_define_method(bz_cWriter, "initialize",      bz_writer_init,      -1);
+    rb_define_method(bz_cWriter, "write",           bz_writer_write,      1);
+    rb_define_method(bz_cWriter, "putc",            bz_writer_putc,       1);
+    rb_define_method(bz_cWriter, "puts",            rb_io_puts,          -1);
+    rb_define_method(bz_cWriter, "print",           rb_io_print,         -1);
+    rb_define_method(bz_cWriter, "printf",          rb_io_printf,        -1);
+    rb_define_method(bz_cWriter, "<<",              rb_io_addstr,         1);
+    rb_define_method(bz_cWriter, "flush",           bz_writer_flush,      0);
+    rb_define_method(bz_cWriter, "close",           bz_writer_close,      0);
+    rb_define_method(bz_cWriter, "close!",          bz_writer_close_bang, 0);
+    rb_define_method(bz_cWriter, "closed?",         bz_writer_closed,     0);
+    rb_define_method(bz_cWriter, "to_io",           bz_to_io,             0);
+    rb_define_alias(bz_cWriter, "finish", "flush");
+    rb_define_alias(bz_cWriter, "closed", "closed?");
+
+    /*
+      Reader
+    */
+    bz_cReader = rb_define_class_under(bz_mBzip2, "Reader", rb_cData);
+    rb_include_module(bz_cReader, rb_mEnumerable);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_define_alloc_func(bz_cReader, bz_reader_s_alloc);
+#else
+    rb_define_singleton_method(bz_cReader, "allocate", bz_reader_s_alloc, 0);
+#endif
+    rb_define_singleton_method(bz_cReader, "new",       bz_s_new,         -1);
+    rb_define_singleton_method(bz_cReader, "open",      bz_reader_s_open, -1);
+    rb_define_singleton_method(bz_cReader, "foreach",   bz_reader_s_foreach,   -1);
+    rb_define_singleton_method(bz_cReader, "readlines", bz_reader_s_readlines, -1);
+    rb_define_method(bz_cReader, "initialize",  bz_reader_init,      -1);
+    rb_define_method(bz_cReader, "read",        bz_reader_read,      -1);
+    rb_define_method(bz_cReader, "unused",      bz_reader_unused,     0);
+    rb_define_method(bz_cReader, "unused=",     bz_reader_set_unused, 1);
+    rb_define_method(bz_cReader, "ungetc",      bz_reader_ungetc,     1);
+    rb_define_method(bz_cReader, "ungets",      bz_reader_ungets,     1);
+    rb_define_method(bz_cReader, "getc",        bz_reader_getc,       0);
+    rb_define_method(bz_cReader, "gets",        bz_reader_gets_m,    -1);
+    rb_define_method(bz_cReader, "readchar",    bz_reader_readchar,   0);
+    rb_define_method(bz_cReader, "readline",    bz_reader_readline,  -1);
+    rb_define_method(bz_cReader, "readlines",   bz_reader_readlines, -1);
+    rb_define_method(bz_cReader, "each",        bz_reader_each_line, -1);
+    rb_define_method(bz_cReader, "each_byte",   bz_reader_each_byte,  0);
+    rb_define_method(bz_cReader, "close",       bz_reader_close,      0);
+    rb_define_method(bz_cReader, "close!",      bz_reader_close_bang, 0);
+    rb_define_method(bz_cReader, "finish",      bz_reader_finish,     0);
+    rb_define_method(bz_cReader, "closed?",     bz_reader_closed,     0);
+    rb_define_method(bz_cReader, "eoz?",        bz_reader_eoz,        0);
+    rb_define_method(bz_cReader, "eof?",        bz_reader_eof,        0);
+    rb_define_method(bz_cReader, "lineno",      bz_reader_lineno,     0);
+    rb_define_method(bz_cReader, "lineno=",     bz_reader_set_lineno, 1);
+    rb_define_method(bz_cReader, "to_io",       bz_to_io,             0);
+    rb_define_alias(bz_cReader, "each_line", "each");
+    rb_define_alias(bz_cReader, "closed", "closed?");
+    rb_define_alias(bz_cReader, "eoz", "eoz?");
+    rb_define_alias(bz_cReader, "eof", "eof?");
+
+    /*
+      Internal
+    */
+    bz_cInternal = rb_define_class_under(bz_mBzip2, "InternalStr", rb_cData);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_undef_alloc_func(bz_cInternal);
+#else
+    rb_undef_method(CLASS_OF(bz_cInternal), "allocate");
+#endif
+    rb_undef_method(CLASS_OF(bz_cInternal), "new");
+    rb_undef_method(bz_cInternal, "initialize");
+    rb_define_method(bz_cInternal, "read", bz_str_read, -1);
+}