bzip2-ruby 0.2.6 → 0.2.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (23) hide show
  1. data/.gitignore +8 -0
  2. data/.yardopts +1 -0
  3. data/CHANGELOG.rdoc +70 -1
  4. data/Gemfile +3 -0
  5. data/Gemfile.lock +26 -0
  6. data/README.rdoc +44 -3
  7. data/Rakefile +2 -19
  8. data/bzip2-ruby.gemspec +14 -48
  9. data/ext/bzip2.c +1012 -823
  10. data/ext/extconf.rb +4 -1
  11. data/lib/bzip2-ruby.rb +1 -0
  12. data/lib/bzip2.rb +10 -2
  13. data/lib/bzip2/internals.rb +13 -0
  14. data/lib/bzip2/reader.rb +27 -0
  15. data/lib/bzip2/version.rb +3 -0
  16. data/lib/bzip2/writer.rb +63 -0
  17. data/spec/reader_spec.rb +118 -214
  18. data/spec/spec_helper.rb +9 -1
  19. data/spec/writer_spec.rb +64 -74
  20. metadata +50 -17
  21. data/VERSION.yml +0 -4
  22. data/tasks/extconf.rake +0 -13
  23. data/tasks/extconf/bz2.rake +0 -43
data/.gitignore ADDED
@@ -0,0 +1,8 @@
1
+ _10lines_
2
+ doc
3
+ ext/Makefile
4
+ ext/*.o
5
+ ext/*.so
6
+ ext/*.bundle
7
+ pkg
8
+ .bundle
data/.yardopts ADDED
@@ -0,0 +1 @@
1
+ --no-private
data/CHANGELOG.rdoc CHANGED
@@ -1,8 +1,28 @@
1
+ == 0.2.7 2010-11-16
2
+
3
+ * Add documentation for an overview of the Bzip2 module
4
+ * Document the class methods on Bzip2 and get them to show up in yarddoc
5
+ * Remove the ConfigError class because searching for it showed no instances of its usage
6
+ * Add a Usage section to the README and a bit about adding it to a Gemfile
7
+ * Improve the reader_spec.rb by making it more resilient in lots of places and a bit more descriptive/terse in
8
+ * Add a lot more documentation for the Reader class and also touch up the Writer class a bit
9
+ * Make the Writer specs more descriptive by giving them some doc strings.
10
+ * Wrap up documentation of the Bzip2::Writer class.
11
+ * Add lib/bzip2-ruby.rb so it's not always necessary to specify to require 'bzip2' in Gemfiles and such
12
+ * Start documenting the Bzip2::Writer class
13
+ * Fix a few compiler warnings
14
+ * Removed some dead code
15
+ * Fix for ruby 1.9 compatibility.
16
+ * Fix segfault when exiting in ruby 1.9
17
+ * Follow the newer conventions of rspec
18
+ * Migrate to using Bundler instead of Jeweler
19
+ * use malloc/free instead of ruby_xmalloc/ruby_xfree
20
+
1
21
  == 0.2.6 2009-10-6
2
22
 
3
23
  * Updated to support Ruby 1.8.5
4
24
 
5
- == 0.2.5 ???
25
+ == 0.2.5 2009-06-07
6
26
 
7
27
  * initial conversion of original tests over to rspec
8
28
 
@@ -23,3 +43,52 @@
23
43
  * 1 major enhancement:
24
44
  * Gemify bz2 library from http://moulon.inra.fr/ruby/bz2.html
25
45
  * All credit goes to Guy Decoux <ts@moulon.inra.fr>
46
+
47
+ === 0.2.1
48
+
49
+ * replaced rb_proc_new() with bz_proc_new() for 1.6
50
+ (Thanks "Akinori MUSHA" <knu@iDaemons.org>)
51
+
52
+ === 0.1.9
53
+
54
+ * corrected BZ_FINISH_OK (Thanks Rudi Cilibrasi <Rudi.Cilibrasi@cwi.nl>)
55
+
56
+ === 0.1.6
57
+
58
+ * adapted for 1.8.0 (ihi)
59
+ * modified ::new
60
+ * BZ2::Writer#finish (same than #flush)
61
+
62
+ === 0.1.5
63
+
64
+ * corrected extconf.rb
65
+ * added close!
66
+ * replaced close(false) by #finish
67
+ * corrected #flush
68
+
69
+ === 0.1.4
70
+
71
+ * corrected bz_iv
72
+ * #to_io
73
+ * corrected ::Reader#close
74
+
75
+ === 0.1.3
76
+
77
+ * corrected #lineno
78
+ * corrected ::Writer::new(nil)
79
+ * taint result
80
+
81
+ === 0.1.2
82
+
83
+ * better (???) interface for #read
84
+ * finalize for objects which respond to #closed?
85
+
86
+ === 0.1.1
87
+
88
+ * better interface for T_FILE
89
+ * corrected bug with gc (buf)
90
+ * Reader#lineno, Reader#lineno=, Reader#ungets
91
+ * corrected Reader#unused
92
+ * taint check in #initialize
93
+ * BZ2::bzip2, BZ2::bunzip2
94
+ * too many exceptions
data/Gemfile ADDED
@@ -0,0 +1,3 @@
1
+ source :gemcutter
2
+
3
+ gemspec
data/Gemfile.lock ADDED
@@ -0,0 +1,26 @@
1
+ PATH
2
+ remote: .
3
+ specs:
4
+ bzip2-ruby (0.2.6)
5
+
6
+ GEM
7
+ remote: http://rubygems.org/
8
+ specs:
9
+ diff-lcs (1.1.2)
10
+ rspec (2.0.0)
11
+ rspec-core (= 2.0.0)
12
+ rspec-expectations (= 2.0.0)
13
+ rspec-mocks (= 2.0.0)
14
+ rspec-core (2.0.0)
15
+ rspec-expectations (2.0.0)
16
+ diff-lcs (>= 1.1.2)
17
+ rspec-mocks (2.0.0)
18
+ rspec-core (= 2.0.0)
19
+ rspec-expectations (= 2.0.0)
20
+
21
+ PLATFORMS
22
+ ruby
23
+
24
+ DEPENDENCIES
25
+ bzip2-ruby!
26
+ rspec (>= 2.0.0)
data/README.rdoc CHANGED
@@ -2,14 +2,55 @@
2
2
 
3
3
  == Installation
4
4
 
5
- sudo gem install brianmario-bzip2-ruby -s http://gems.github.com/
6
-
5
+ First make sure you’ve got Gemcutter in your sources list:
6
+
7
+ gem sources -a http://gemcutter.org
8
+
9
+ Then go ahead and install it as usual:
10
+
11
+ sudo gem install bzip2-ruby
12
+
7
13
  You may need to specify:
8
14
 
9
15
  --with-bz2-dir=<include file directory for libbzip2>
10
16
 
17
+ Or in a Gemfile
18
+
19
+ gem 'bzip2-ruby'
20
+
21
+ == Usage
22
+
23
+ The full documentation is hosted on {rdoc.info}[http://rdoc.info/github/brianmario/bzip2-ruby/master/frames].
24
+
25
+ Here's a quick overview, hower:
26
+
27
+ require 'bzip2'
28
+
29
+ # Quick shortcuts
30
+ data = Bzip2.compress 'string'
31
+ Bzip2.uncompress data
32
+
33
+ # Creating a bz2 compressed file
34
+ writer = Bzip2::Writer.new File.open('file')
35
+ writer << 'data1'
36
+ writer.puts 'data2'
37
+ writer.print 'data3'
38
+ writer.printf '%s', 'data4'
39
+ writer.close
40
+
41
+ Bzip2::Writer.open('file'){ |f| f << data }
42
+
43
+ # Reading a bz2 compressed file
44
+ reader = Bzip2::Reader.new File.open('file')
45
+ reader.gets # => "data1data2\n"
46
+ reader.read # => 'data3data4'
47
+
48
+ reader.readline # => raises Bzip2::EOZError
49
+
50
+ Bzip2::Reader.open('file'){ |f| puts f.read }
51
+
11
52
  == Copying
12
-
53
+
13
54
  This extension module is copyrighted free software by Guy Decoux
14
55
  You can redistribute it and/or modify it under the same term as Ruby.
15
56
  Guy Decoux <ts@moulon.inra.fr>
data/Rakefile CHANGED
@@ -1,19 +1,2 @@
1
- # encoding: UTF-8
2
- begin
3
- require 'jeweler'
4
- Jeweler::Tasks.new do |gem|
5
- gem.name = "bzip2-ruby"
6
- gem.summary = "Ruby C bindings to libbzip2."
7
- gem.email = "seniorlopez@gmail.com"
8
- gem.homepage = "http://github.com/brianmario/bzip2-ruby"
9
- gem.authors = ["Guy Decoux", "Brian Lopez"]
10
- gem.require_paths = ["lib", "ext"]
11
- gem.extra_rdoc_files = `git ls-files *.rdoc`.split("\n")
12
- gem.files = `git ls-files`.split("\n")
13
- gem.extensions = ["ext/extconf.rb"]
14
- gem.files.include %w(lib/jeweler/templates/.document lib/jeweler/templates/.gitignore)
15
- # gem.rubyforge_project = "bzip2-ruby"
16
- end
17
- rescue LoadError
18
- puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
19
- end
1
+ require 'bundler'
2
+ Bundler::GemHelper.install_tasks
data/bzip2-ruby.gemspec CHANGED
@@ -1,54 +1,20 @@
1
- # Generated by jeweler
2
- # DO NOT EDIT THIS FILE
3
- # Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
4
1
  # -*- encoding: utf-8 -*-
2
+ $:.push File.expand_path('../lib', __FILE__)
3
+ require 'bzip2/version'
5
4
 
6
5
  Gem::Specification.new do |s|
7
- s.name = %q{bzip2-ruby}
8
- s.version = "0.2.6"
6
+ s.name = 'bzip2-ruby'
7
+ s.version = Bzip2::VERSION
8
+ s.platform = Gem::Platform::RUBY
9
+ s.authors = ['Guy Decoux', 'Brian Lopezs']
10
+ s.email = ['seniorlopez@gmail.com']
11
+ s.homepage = 'http://github.com/brianmario/bzip2-ruby'
12
+ s.summary = 'Ruby C bindings to libbzip2.'
9
13
 
10
- s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
11
- s.authors = ["Guy Decoux", "Brian Lopez"]
12
- s.date = %q{2009-10-06}
13
- s.email = %q{seniorlopez@gmail.com}
14
- s.extensions = ["ext/extconf.rb"]
15
- s.extra_rdoc_files = [
16
- "CHANGELOG.rdoc",
17
- "README.rdoc"
18
- ]
19
- s.files = [
20
- "CHANGELOG.rdoc",
21
- "README.rdoc",
22
- "Rakefile",
23
- "VERSION.yml",
24
- "bzip2-ruby.gemspec",
25
- "ext/bzip2.c",
26
- "ext/extconf.rb",
27
- "lib/bzip2.rb",
28
- "spec/reader_spec.rb",
29
- "spec/spec_helper.rb",
30
- "spec/writer_spec.rb",
31
- "tasks/extconf.rake",
32
- "tasks/extconf/bz2.rake"
33
- ]
34
- s.homepage = %q{http://github.com/brianmario/bzip2-ruby}
35
- s.rdoc_options = ["--charset=UTF-8"]
36
- s.require_paths = ["lib", "ext"]
37
- s.rubygems_version = %q{1.3.5}
38
- s.summary = %q{Ruby C bindings to libbzip2.}
39
- s.test_files = [
40
- "spec/reader_spec.rb",
41
- "spec/spec_helper.rb",
42
- "spec/writer_spec.rb"
43
- ]
14
+ s.extensions = ['ext/extconf.rb']
15
+ s.files = `git ls-files`.split("\n")
16
+ s.test_files = `git ls-files -- spec/*`.split("\n")
17
+ s.require_paths = ['lib', 'ext']
44
18
 
45
- if s.respond_to? :specification_version then
46
- current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
47
- s.specification_version = 3
48
-
49
- if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
50
- else
51
- end
52
- else
53
- end
19
+ s.add_development_dependency 'rspec', '>= 2.0.0'
54
20
  end
data/ext/bzip2.c CHANGED
@@ -1,5 +1,6 @@
1
1
  #include <ruby.h>
2
2
  #include <bzlib.h>
3
+ #include <unistd.h>
3
4
  #ifndef RUBY_19_COMPATIBILITY
4
5
  #include <rubyio.h>
5
6
  #include <version.h>
@@ -8,7 +9,7 @@
8
9
  #endif
9
10
 
10
11
  static VALUE bz_cWriter, bz_cReader, bz_cInternal;
11
- static VALUE bz_eError, bz_eConfigError, bz_eEOZError;
12
+ static VALUE bz_eError, bz_eEOZError;
12
13
 
13
14
  static VALUE bz_internal_ary;
14
15
 
@@ -36,7 +37,7 @@ struct bz_file {
36
37
  bz_stream bzs;
37
38
  VALUE in, io;
38
39
  char *buf;
39
- int buflen;
40
+ unsigned int buflen;
40
41
  int blocks, work, small;
41
42
  int flags, lineno, state;
42
43
  };
@@ -51,150 +52,123 @@ struct bz_iv {
51
52
  void (*finalize)();
52
53
  };
53
54
 
54
- #define Get_BZ2(obj, bzf) \
55
- rb_io_taint_check(obj); \
55
+ #define Get_BZ2(obj, bzf) \
56
+ rb_io_taint_check(obj); \
56
57
  Data_Get_Struct(obj, struct bz_file, bzf); \
57
- if (!RTEST(bzf->io)) { \
58
- rb_raise(rb_eIOError, "closed IO"); \
58
+ if (!RTEST(bzf->io)) { \
59
+ rb_raise(rb_eIOError, "closed IO"); \
59
60
  }
60
61
 
61
- static VALUE
62
- bz_raise(error)
63
- int error;
64
- {
62
+ static VALUE bz_raise(int error) {
65
63
  VALUE exc;
66
- char *msg;
64
+ const char *msg;
67
65
 
68
66
  exc = bz_eError;
69
67
  switch (error) {
70
- case BZ_SEQUENCE_ERROR:
71
- msg = "incorrect sequence";
72
- break;
73
- case BZ_PARAM_ERROR:
74
- msg = "parameter out of range";
75
- break;
76
- case BZ_MEM_ERROR:
77
- msg = "not enough memory is available";
78
- break;
79
- case BZ_DATA_ERROR:
80
- msg = "data integrity error is detected";
81
- break;
82
- case BZ_DATA_ERROR_MAGIC:
83
- msg = "compressed stream does not start with the correct magic bytes";
84
- break;
85
- case BZ_IO_ERROR:
86
- msg = "error reading or writing";
87
- break;
88
- case BZ_UNEXPECTED_EOF:
89
- exc = bz_eEOZError;
90
- msg = "compressed file finishes before the logical end of stream is detected";
91
- break;
92
- case BZ_OUTBUFF_FULL:
93
- msg = "output buffer full";
94
- break;
95
- case BZ_CONFIG_ERROR:
96
- exc = bz_eConfigError;
97
- msg = "library has been improperly compiled on your platform";
98
- break;
99
- default:
100
- msg = "unknown error";
101
- exc = bz_eError;
68
+ case BZ_SEQUENCE_ERROR:
69
+ msg = "incorrect sequence";
70
+ break;
71
+ case BZ_PARAM_ERROR:
72
+ msg = "parameter out of range";
73
+ break;
74
+ case BZ_MEM_ERROR:
75
+ msg = "not enough memory is available";
76
+ break;
77
+ case BZ_DATA_ERROR:
78
+ msg = "data integrity error is detected";
79
+ break;
80
+ case BZ_DATA_ERROR_MAGIC:
81
+ msg = "compressed stream does not start with the correct magic bytes";
82
+ break;
83
+ case BZ_IO_ERROR:
84
+ msg = "error reading or writing";
85
+ break;
86
+ case BZ_UNEXPECTED_EOF:
87
+ exc = bz_eEOZError;
88
+ msg = "compressed file finishes before the logical end of stream is detected";
89
+ break;
90
+ case BZ_OUTBUFF_FULL:
91
+ msg = "output buffer full";
92
+ break;
93
+ default:
94
+ msg = "unknown error";
95
+ exc = bz_eError;
102
96
  }
103
- rb_raise(exc, msg);
97
+ rb_raise(exc, "%s", msg);
104
98
  }
105
-
106
- static void
107
- bz_str_mark(bzs)
108
- struct bz_str *bzs;
109
- {
99
+
100
+ static void bz_str_mark(struct bz_str *bzs) {
110
101
  rb_gc_mark(bzs->str);
111
102
  }
112
103
 
113
- static void
114
- bz_file_mark(bzf)
115
- struct bz_file *bzf;
116
- {
104
+ static void bz_file_mark(struct bz_file * bzf) {
117
105
  rb_gc_mark(bzf->io);
118
106
  rb_gc_mark(bzf->in);
119
107
  }
120
108
 
121
- static struct bz_iv *
122
- bz_find_struct(obj, ptr, posp)
123
- VALUE obj;
124
- void *ptr;
125
- int *posp;
126
- {
109
+ static struct bz_iv * bz_find_struct(VALUE obj, void *ptr, int *posp) {
127
110
  struct bz_iv *bziv;
128
111
  int i;
129
112
 
130
113
  for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
131
- Data_Get_Struct(RARRAY_PTR(bz_internal_ary)[i], struct bz_iv, bziv);
132
- if (ptr) {
114
+ Data_Get_Struct(RARRAY_PTR(bz_internal_ary)[i], struct bz_iv, bziv);
115
+ if (ptr) {
133
116
  #ifndef RUBY_19_COMPATIBILITY
134
- if (TYPE(bziv->io) == T_FILE && RFILE(bziv->io)->fptr == (OpenFile *)ptr) {
117
+ if (TYPE(bziv->io) == T_FILE && RFILE(bziv->io)->fptr == (OpenFile *)ptr) {
135
118
  #else
136
- if (TYPE(bziv->io) == T_FILE && RFILE(bziv->io)->fptr == (rb_io_t *)ptr) {
119
+ if (TYPE(bziv->io) == T_FILE && RFILE(bziv->io)->fptr == (rb_io_t *)ptr) {
137
120
  #endif
121
+ if (posp) {
122
+ *posp = i;
123
+ }
124
+ return bziv;
125
+ } else if (TYPE(bziv->io) == T_DATA && DATA_PTR(bziv->io) == ptr) {
126
+ if (posp) *posp = i;
127
+ return bziv;
128
+ }
129
+ } else if (bziv->io == obj) {
138
130
  if (posp) *posp = i;
139
131
  return bziv;
140
132
  }
141
- else if (TYPE(bziv->io) == T_DATA && DATA_PTR(bziv->io) == ptr) {
142
- if (posp) *posp = i;
143
- return bziv;
144
- }
145
- }
146
- else if (bziv->io == obj) {
147
- if (posp) *posp = i;
148
- return bziv;
149
- }
150
133
  }
151
134
  if (posp) *posp = -1;
152
135
  return 0;
153
136
  }
154
137
 
155
- static VALUE
156
- bz_writer_internal_flush(bzf)
157
- struct bz_file *bzf;
158
- {
138
+ static VALUE bz_writer_internal_flush(struct bz_file *bzf) {
159
139
  int closed = 1;
160
140
 
161
141
  if (rb_respond_to(bzf->io, id_closed)) {
162
- closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
142
+ closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
163
143
  }
164
144
  if (bzf->buf) {
165
- if (!closed && bzf->state == BZ_OK) {
166
- bzf->bzs.next_in = NULL;
167
- bzf->bzs.avail_in = 0;
168
- do {
169
- bzf->bzs.next_out = bzf->buf;
170
- bzf->bzs.avail_out = bzf->buflen;
171
- bzf->state = BZ2_bzCompress(&(bzf->bzs), BZ_FINISH);
172
- if (bzf->state != BZ_FINISH_OK &&
173
- bzf->state != BZ_STREAM_END) {
174
- break;
145
+ if (!closed && bzf->state == BZ_OK) {
146
+ bzf->bzs.next_in = NULL;
147
+ bzf->bzs.avail_in = 0;
148
+ do {
149
+ bzf->bzs.next_out = bzf->buf;
150
+ bzf->bzs.avail_out = bzf->buflen;
151
+ bzf->state = BZ2_bzCompress(&(bzf->bzs), BZ_FINISH);
152
+ if (bzf->state != BZ_FINISH_OK && bzf->state != BZ_STREAM_END) {
153
+ break;
154
+ }
155
+ if (bzf->bzs.avail_out < bzf->buflen) {
156
+ rb_funcall(bzf->io, id_write, 1, rb_str_new(bzf->buf, bzf->buflen - bzf->bzs.avail_out));
157
+ }
158
+ } while (bzf->state != BZ_STREAM_END);
175
159
  }
176
- if (bzf->bzs.avail_out < bzf->buflen) {
177
- rb_funcall(bzf->io, id_write, 1,
178
- rb_str_new(bzf->buf,
179
- bzf->buflen - bzf->bzs.avail_out));
160
+ free(bzf->buf);
161
+ bzf->buf = 0;
162
+ BZ2_bzCompressEnd(&(bzf->bzs));
163
+ bzf->state = BZ_OK;
164
+ if (!closed && rb_respond_to(bzf->io, id_flush)) {
165
+ rb_funcall2(bzf->io, id_flush, 0, 0);
180
166
  }
181
- } while (bzf->state != BZ_STREAM_END);
182
- }
183
- free(bzf->buf);
184
- bzf->buf = 0;
185
- BZ2_bzCompressEnd(&(bzf->bzs));
186
- bzf->state = BZ_OK;
187
- if (!closed && rb_respond_to(bzf->io, id_flush)) {
188
- rb_funcall2(bzf->io, id_flush, 0, 0);
189
- }
190
167
  }
191
168
  return closed;
192
169
  }
193
170
 
194
- static VALUE
195
- bz_writer_internal_close(bzf)
196
- struct bz_file *bzf;
197
- {
171
+ static VALUE bz_writer_internal_close(struct bz_file *bzf) {
198
172
  struct bz_iv *bziv;
199
173
  int pos, closed;
200
174
  VALUE res;
@@ -202,82 +176,87 @@ bz_writer_internal_close(bzf)
202
176
  closed = bz_writer_internal_flush(bzf);
203
177
  bziv = bz_find_struct(bzf->io, 0, &pos);
204
178
  if (bziv) {
205
- if (TYPE(bzf->io) == T_FILE) {
206
- RFILE(bzf->io)->fptr->finalize = bziv->finalize;
207
- }
208
- else if (TYPE(bziv->io) == T_DATA) {
209
- RDATA(bziv->io)->dfree = bziv->finalize;
210
- }
211
- RDATA(bziv->bz2)->dfree = ruby_xfree;
212
- bziv->bz2 = 0;
213
- rb_ary_delete_at(bz_internal_ary, pos);
179
+ if (TYPE(bzf->io) == T_FILE) {
180
+ RFILE(bzf->io)->fptr->finalize = bziv->finalize;
181
+ } else if (TYPE(bziv->io) == T_DATA) {
182
+ RDATA(bziv->io)->dfree = bziv->finalize;
183
+ }
184
+ RDATA(bziv->bz2)->dfree = free;
185
+ bziv->bz2 = 0;
186
+ rb_ary_delete_at(bz_internal_ary, pos);
214
187
  }
215
188
  if (bzf->flags & BZ2_RB_CLOSE) {
216
- bzf->flags &= ~BZ2_RB_CLOSE;
217
- if (!closed && rb_respond_to(bzf->io, id_close)) {
218
- rb_funcall2(bzf->io, id_close, 0, 0);
219
- }
220
- res = Qnil;
221
- }
222
- else {
223
- res = bzf->io;
189
+ bzf->flags &= ~BZ2_RB_CLOSE;
190
+ if (!closed && rb_respond_to(bzf->io, id_close)) {
191
+ rb_funcall2(bzf->io, id_close, 0, 0);
192
+ }
193
+ res = Qnil;
194
+ } else {
195
+ res = bzf->io;
224
196
  }
225
197
  bzf->io = Qnil;
226
198
  return res;
227
199
  }
228
200
 
229
- static VALUE
230
- bz_internal_finalize(ary, obj)
231
- VALUE ary, obj;
232
- {
201
+ static void bz_internal_finalize(VALUE data) {
233
202
  VALUE elem;
234
203
  int closed, i;
235
204
  struct bz_iv *bziv;
236
205
  struct bz_file *bzf;
237
206
 
238
207
  for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
239
- elem = RARRAY_PTR(bz_internal_ary)[i];
240
- Data_Get_Struct(elem, struct bz_iv, bziv);
241
- if (bziv->bz2) {
242
- RDATA(bziv->bz2)->dfree = ruby_xfree;
243
- if (TYPE(bziv->io) == T_FILE) {
244
- RFILE(bziv->io)->fptr->finalize = bziv->finalize;
245
- }
246
- else if (TYPE(bziv->io) == T_DATA) {
247
- RDATA(bziv->io)->dfree = bziv->finalize;
248
- }
249
- Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
250
- closed = bz_writer_internal_flush(bzf);
251
- if (bzf->flags & BZ2_RB_CLOSE) {
252
- bzf->flags &= ~BZ2_RB_CLOSE;
253
- if (!closed && rb_respond_to(bzf->io, id_close)) {
254
- rb_funcall2(bzf->io, id_close, 0, 0);
255
- }
208
+ elem = RARRAY_PTR(bz_internal_ary)[i];
209
+ Data_Get_Struct(elem, struct bz_iv, bziv);
210
+ if (bziv->bz2) {
211
+ RDATA(bziv->bz2)->dfree = free;
212
+ if (TYPE(bziv->io) == T_FILE) {
213
+ RFILE(bziv->io)->fptr->finalize = bziv->finalize;
214
+ } else if (TYPE(bziv->io) == T_DATA) {
215
+ RDATA(bziv->io)->dfree = bziv->finalize;
216
+ }
217
+ Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
218
+ closed = bz_writer_internal_flush(bzf);
219
+ if (bzf->flags & BZ2_RB_CLOSE) {
220
+ bzf->flags &= ~BZ2_RB_CLOSE;
221
+ if (!closed && rb_respond_to(bzf->io, id_close)) {
222
+ rb_funcall2(bzf->io, id_close, 0, 0);
223
+ }
224
+ }
256
225
  }
257
226
  }
258
- }
259
- return Qnil;
260
227
  }
261
228
 
262
- static VALUE
263
- bz_writer_close(obj)
264
- VALUE obj;
265
- {
229
+ /*
230
+ * Closes this writer for further use. The remaining data is compressed and
231
+ * flushed.
232
+ *
233
+ * If the writer was constructed with an io object, that object is returned.
234
+ * Otherwise, the actual compressed data is returned
235
+ *
236
+ * writer = Bzip2::Writer.new File.open('path', 'w')
237
+ * writer << 'a'
238
+ * writer.close # => #<File:path>
239
+ *
240
+ * writer = Bzip2::Writer.new
241
+ * writer << 'a'
242
+ * writer.close # => "BZh91AY&SY...
243
+ */
244
+ static VALUE bz_writer_close(VALUE obj) {
266
245
  struct bz_file *bzf;
267
246
  VALUE res;
268
247
 
269
248
  Get_BZ2(obj, bzf);
270
249
  res = bz_writer_internal_close(bzf);
271
250
  if (!NIL_P(res) && (bzf->flags & BZ2_RB_INTERNAL)) {
272
- RBASIC(res)->klass = rb_cString;
251
+ RBASIC(res)->klass = rb_cString;
273
252
  }
274
253
  return res;
275
254
  }
276
255
 
277
- static VALUE
278
- bz_writer_close_bang(obj)
279
- VALUE obj;
280
- {
256
+ /*
257
+ * Calls Bzip2::Writer#close and then does some more stuff...
258
+ */
259
+ static VALUE bz_writer_close_bang(VALUE obj) {
281
260
  struct bz_file *bzf;
282
261
  int closed;
283
262
 
@@ -285,28 +264,22 @@ bz_writer_close_bang(obj)
285
264
  closed = bzf->flags & (BZ2_RB_INTERNAL|BZ2_RB_CLOSE);
286
265
  bz_writer_close(obj);
287
266
  if (!closed && rb_respond_to(bzf->io, id_close)) {
288
- if (rb_respond_to(bzf->io, id_closed)) {
289
- closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
290
- }
291
- if (!closed) {
292
- rb_funcall2(bzf->io, id_close, 0, 0);
293
- }
267
+ if (rb_respond_to(bzf->io, id_closed)) {
268
+ closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
269
+ }
270
+ if (!closed) {
271
+ rb_funcall2(bzf->io, id_close, 0, 0);
272
+ }
294
273
  }
295
274
  return Qnil;
296
275
  }
297
276
 
298
- static void
299
- bz_writer_free(bzf)
300
- struct bz_file *bzf;
301
- {
277
+ static void bz_writer_free(struct bz_file *bzf) {
302
278
  bz_writer_internal_close(bzf);
303
- ruby_xfree(bzf);
279
+ free(bzf);
304
280
  }
305
281
 
306
- static void
307
- bz_io_data_finalize(ptr)
308
- void *ptr;
309
- {
282
+ static void bz_io_data_finalize(void *ptr) {
310
283
  struct bz_file *bzf;
311
284
  struct bz_iv *bziv;
312
285
  int pos;
@@ -315,8 +288,8 @@ bz_io_data_finalize(ptr)
315
288
  if (bziv) {
316
289
  rb_ary_delete_at(bz_internal_ary, pos);
317
290
  Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
318
- rb_protect(bz_writer_internal_flush, (VALUE)bzf, 0);
319
- RDATA(bziv->bz2)->dfree = ruby_xfree;
291
+ rb_protect((VALUE (*)(VALUE))bz_writer_internal_flush, (VALUE)bzf, 0);
292
+ RDATA(bziv->bz2)->dfree = free;
320
293
  if (bziv->finalize) {
321
294
  (*bziv->finalize)(ptr);
322
295
  } else if (TYPE(bzf->io) == T_FILE) {
@@ -333,7 +306,8 @@ bz_io_data_finalize(ptr)
333
306
  #else
334
307
  rb_io_t *file = (rb_io_t *)ptr;
335
308
  if (file->fd) {
336
- fclose(file->fd);
309
+ close(file->fd);
310
+
337
311
  file->fd = 0;
338
312
  }
339
313
  if (file->stdio_file) {
@@ -343,33 +317,27 @@ bz_io_data_finalize(ptr)
343
317
  #endif
344
318
  }
345
319
  }
320
+
346
321
  }
347
322
 
348
- static void *
349
- bz_malloc(opaque, m, n)
350
- void *opaque;
351
- int m, n;
352
- {
353
- return ruby_xmalloc(m * n);
323
+ static void * bz_malloc(void *opaque, int m, int n) {
324
+ return malloc(m * n);
354
325
  }
355
326
 
356
- static void
357
- bz_free(opaque, p)
358
- void *opaque, *p;
359
- {
360
- ruby_xfree(p);
327
+ static void bz_free(void *opaque, void *p) {
328
+ free(p);
361
329
  }
362
330
 
363
331
  #define DEFAULT_BLOCKS 9
364
332
 
365
- static VALUE
366
- bz_writer_s_alloc(obj)
367
- VALUE obj;
368
- {
333
+ /*
334
+ * Internally allocates information about a new writer
335
+ * @private
336
+ */
337
+ static VALUE bz_writer_s_alloc(VALUE obj) {
369
338
  struct bz_file *bzf;
370
339
  VALUE res;
371
- res = Data_Make_Struct(obj, struct bz_file, bz_file_mark,
372
- bz_writer_free, bzf);
340
+ res = Data_Make_Struct(obj, struct bz_file, bz_file_mark, bz_writer_free, bzf);
373
341
  bzf->bzs.bzalloc = bz_malloc;
374
342
  bzf->bzs.bzfree = bz_free;
375
343
  bzf->blocks = DEFAULT_BLOCKS;
@@ -377,139 +345,171 @@ bz_writer_s_alloc(obj)
377
345
  return res;
378
346
  }
379
347
 
380
- static VALUE
381
- bz_writer_flush(obj)
382
- VALUE obj;
383
- {
348
+ /*
349
+ * Flushes all of the data in this stream to the underlying IO.
350
+ *
351
+ * If this writer was constructed with no underlying io object, the compressed
352
+ * data is returned as a string.
353
+ *
354
+ * @return [String, nil]
355
+ * @raise [IOError] if the stream has been closed
356
+ */
357
+ static VALUE bz_writer_flush(VALUE obj) {
384
358
  struct bz_file *bzf;
385
359
 
386
360
  Get_BZ2(obj, bzf);
387
361
  if (bzf->flags & BZ2_RB_INTERNAL) {
388
- return bz_writer_close(obj);
362
+ return bz_writer_close(obj);
389
363
  }
390
364
  bz_writer_internal_flush(bzf);
391
365
  return Qnil;
392
366
  }
393
367
 
394
- static VALUE
395
- bz_writer_s_open(argc, argv, obj)
396
- int argc;
397
- VALUE obj, *argv;
398
- {
368
+ /*
369
+ * call-seq:
370
+ * open(filename, mode='wb', &block=nil) -> Bzip2::Writer
371
+ *
372
+ * @param [String] filename the name of the file to write to
373
+ * @param [String] mode a mode string passed to Kernel#open
374
+ * @yieldparam [Bzip2::Writer] writer the Bzip2::Writer instance
375
+ *
376
+ * If a block is given, the created Bzip2::Writer instance is yielded to the
377
+ * block and will be closed when the block completes. It is guaranteed via
378
+ * +ensure+ that the writer is closed
379
+ *
380
+ * If a block is not given, a Bzip2::Writer instance will be returned
381
+ *
382
+ * Bzip2::Writer.open('file') { |f| f << data }
383
+ *
384
+ * writer = Bzip2::Writer.open('file')
385
+ * writer << data
386
+ * writer.close
387
+ *
388
+ * @return [Bzip2::Writer, nil]
389
+ */
390
+ static VALUE bz_writer_s_open(int argc, VALUE *argv, VALUE obj) {
399
391
  VALUE res;
400
392
  struct bz_file *bzf;
401
393
 
402
394
  if (argc < 1) {
403
- rb_raise(rb_eArgError, "invalid number of arguments");
395
+ rb_raise(rb_eArgError, "invalid number of arguments");
404
396
  }
405
397
  if (argc == 1) {
406
- argv[0] = rb_funcall(rb_mKernel, id_open, 2, argv[0],
407
- rb_str_new2("wb"));
408
- }
409
- else {
410
- argv[1] = rb_funcall2(rb_mKernel, id_open, 2, argv);
411
- argv += 1;
412
- argc -= 1;
398
+ argv[0] = rb_funcall(rb_mKernel, id_open, 2, argv[0],
399
+ rb_str_new2("wb"));
400
+ } else {
401
+ argv[1] = rb_funcall2(rb_mKernel, id_open, 2, argv);
402
+ argv += 1;
403
+ argc -= 1;
413
404
  }
414
405
  res = rb_funcall2(obj, id_new, argc, argv);
415
406
  Data_Get_Struct(res, struct bz_file, bzf);
416
407
  bzf->flags |= BZ2_RB_CLOSE;
417
408
  if (rb_block_given_p()) {
418
- return rb_ensure(rb_yield, res, bz_writer_close, res);
409
+ return rb_ensure(rb_yield, res, bz_writer_close, res);
419
410
  }
420
411
  return res;
421
412
  }
422
413
 
423
- static VALUE
424
- bz_str_write(obj, str)
425
- VALUE obj, str;
426
- {
414
+ static VALUE bz_str_write(VALUE obj, VALUE str) {
427
415
  if (TYPE(str) != T_STRING) {
428
- rb_raise(rb_eArgError, "expected a String");
416
+ rb_raise(rb_eArgError, "expected a String");
429
417
  }
430
418
  if (RSTRING_LEN(str)) {
431
- rb_str_cat(obj, RSTRING_PTR(str), RSTRING_LEN(str));
419
+ rb_str_cat(obj, RSTRING_PTR(str), RSTRING_LEN(str));
432
420
  }
433
421
  return str;
434
422
  }
435
423
 
436
- static VALUE
437
- bz_str_closed(obj)
438
- VALUE obj;
439
- {
424
+ static VALUE bz_str_closed(VALUE obj) {
440
425
  return Qfalse;
441
426
  }
442
427
 
443
- static VALUE
444
- bz_writer_init(argc, argv, obj)
445
- int argc;
446
- VALUE obj, *argv;
447
- {
428
+ /*
429
+ * call-seq:
430
+ * initialize(io = nil)
431
+ *
432
+ * @param [File] io the file which to write compressed data to
433
+ *
434
+ * Creates a new Bzip2::Writer for compressing a stream of data. An optional
435
+ * io object (something responding to +write+) can be supplied which data
436
+ * will be written to.
437
+ *
438
+ * If nothing is given, the Bzip2::Writer#flush method can be called to retrieve
439
+ * the compressed stream so far.
440
+ *
441
+ * writer = Bzip2::Writer.new File.open('files.bz2')
442
+ * writer << 'a'
443
+ * writer << 'b'
444
+ * writer.close
445
+ *
446
+ * writer = Bzip2::Writer.new
447
+ * writer << 'abcde'
448
+ * writer.flush # => 'abcde' compressed
449
+ */
450
+ static VALUE bz_writer_init(int argc, VALUE *argv, VALUE obj) {
448
451
  struct bz_file *bzf;
449
452
  int blocks = DEFAULT_BLOCKS;
450
453
  int work = 0;
451
454
  VALUE a, b, c;
452
455
 
453
456
  switch(rb_scan_args(argc, argv, "03", &a, &b, &c)) {
454
- case 3:
455
- work = NUM2INT(c);
457
+ case 3:
458
+ work = NUM2INT(c);
456
459
  /* ... */
457
- case 2:
458
- blocks = NUM2INT(b);
460
+ case 2:
461
+ blocks = NUM2INT(b);
459
462
  }
460
463
  Data_Get_Struct(obj, struct bz_file, bzf);
461
464
  if (NIL_P(a)) {
462
- a = rb_str_new(0, 0);
463
- rb_define_method(rb_singleton_class(a), "write", bz_str_write, 1);
464
- rb_define_method(rb_singleton_class(a), "closed?", bz_str_closed, 0);
465
- bzf->flags |= BZ2_RB_INTERNAL;
466
- }
467
- else {
468
- VALUE iv;
469
- struct bz_iv *bziv;
465
+ a = rb_str_new(0, 0);
466
+ rb_define_method(rb_singleton_class(a), "write", bz_str_write, 1);
467
+ rb_define_method(rb_singleton_class(a), "closed?", bz_str_closed, 0);
468
+ bzf->flags |= BZ2_RB_INTERNAL;
469
+ } else {
470
+ VALUE iv;
471
+ struct bz_iv *bziv;
470
472
  #ifndef RUBY_19_COMPATIBILITY
471
- OpenFile *fptr;
473
+ OpenFile *fptr;
472
474
  #else
473
- rb_io_t *fptr;
475
+ rb_io_t *fptr;
474
476
  #endif
475
477
 
476
- rb_io_taint_check(a);
477
- if (!rb_respond_to(a, id_write)) {
478
- rb_raise(rb_eArgError, "first argument must respond to #write");
479
- }
480
- if (TYPE(a) == T_FILE) {
481
- GetOpenFile(a, fptr);
482
- rb_io_check_writable(fptr);
483
- }
484
- else if (rb_respond_to(a, id_closed)) {
485
- iv = rb_funcall2(a, id_closed, 0, 0);
486
- if (RTEST(iv)) {
487
- rb_raise(rb_eArgError, "closed object");
478
+ rb_io_taint_check(a);
479
+ if (!rb_respond_to(a, id_write)) {
480
+ rb_raise(rb_eArgError, "first argument must respond to #write");
488
481
  }
489
- }
490
- bziv = bz_find_struct(a, 0, 0);
491
- if (bziv) {
492
- if (RTEST(bziv->bz2)) {
493
- rb_raise(rb_eArgError, "invalid data type");
482
+ if (TYPE(a) == T_FILE) {
483
+ GetOpenFile(a, fptr);
484
+ rb_io_check_writable(fptr);
485
+ } else if (rb_respond_to(a, id_closed)) {
486
+ iv = rb_funcall2(a, id_closed, 0, 0);
487
+ if (RTEST(iv)) {
488
+ rb_raise(rb_eArgError, "closed object");
489
+ }
490
+ }
491
+ bziv = bz_find_struct(a, 0, 0);
492
+ if (bziv) {
493
+ if (RTEST(bziv->bz2)) {
494
+ rb_raise(rb_eArgError, "invalid data type");
495
+ }
496
+ bziv->bz2 = obj;
497
+ } else {
498
+ iv = Data_Make_Struct(rb_cData, struct bz_iv, 0, free, bziv);
499
+ bziv->io = a;
500
+ bziv->bz2 = obj;
501
+ rb_ary_push(bz_internal_ary, iv);
502
+ }
503
+ switch (TYPE(a)) {
504
+ case T_FILE:
505
+ bziv->finalize = RFILE(a)->fptr->finalize;
506
+ RFILE(a)->fptr->finalize = (void (*)(struct rb_io_t *, int))bz_io_data_finalize;
507
+ break;
508
+ case T_DATA:
509
+ bziv->finalize = RDATA(a)->dfree;
510
+ RDATA(a)->dfree = bz_io_data_finalize;
511
+ break;
494
512
  }
495
- bziv->bz2 = obj;
496
- }
497
- else {
498
- iv = Data_Make_Struct(rb_cData, struct bz_iv, 0, free, bziv);
499
- bziv->io = a;
500
- bziv->bz2 = obj;
501
- rb_ary_push(bz_internal_ary, iv);
502
- }
503
- switch (TYPE(a)) {
504
- case T_FILE:
505
- bziv->finalize = RFILE(a)->fptr->finalize;
506
- RFILE(a)->fptr->finalize = bz_io_data_finalize;
507
- break;
508
- case T_DATA:
509
- bziv->finalize = RDATA(a)->dfree;
510
- RDATA(a)->dfree = bz_io_data_finalize;
511
- break;
512
- }
513
513
  }
514
514
  bzf->io = a;
515
515
  bzf->blocks = blocks;
@@ -519,86 +519,105 @@ bz_writer_init(argc, argv, obj)
519
519
 
520
520
  #define BZ_RB_BLOCKSIZE 4096
521
521
 
522
- static VALUE
523
- bz_writer_write(obj, a)
524
- VALUE obj, a;
525
- {
522
+ /*
523
+ * call-seq:
524
+ * write(data)
525
+ * Actually writes some data into this stream.
526
+ *
527
+ * @param [String] data the data to write
528
+ * @return [Integer] the length of the data which was written (uncompressed)
529
+ * @raise [IOError] if the stream has been closed
530
+ */
531
+ static VALUE bz_writer_write(VALUE obj, VALUE a) {
526
532
  struct bz_file *bzf;
527
533
  int n;
528
534
 
529
535
  a = rb_obj_as_string(a);
530
536
  Get_BZ2(obj, bzf);
531
537
  if (!bzf->buf) {
532
- if (bzf->state != BZ_OK) {
533
- bz_raise(bzf->state);
534
- }
535
- bzf->state = BZ2_bzCompressInit(&(bzf->bzs), bzf->blocks,
536
- 0, bzf->work);
537
- if (bzf->state != BZ_OK) {
538
- bz_writer_internal_flush(bzf);
539
- bz_raise(bzf->state);
540
- }
541
- bzf->buf = ALLOC_N(char, BZ_RB_BLOCKSIZE + 1);
542
- bzf->buflen = BZ_RB_BLOCKSIZE;
543
- bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
538
+ if (bzf->state != BZ_OK) {
539
+ bz_raise(bzf->state);
540
+ }
541
+ bzf->state = BZ2_bzCompressInit(&(bzf->bzs), bzf->blocks,
542
+ 0, bzf->work);
543
+ if (bzf->state != BZ_OK) {
544
+ bz_writer_internal_flush(bzf);
545
+ bz_raise(bzf->state);
546
+ }
547
+ bzf->buf = ALLOC_N(char, BZ_RB_BLOCKSIZE + 1);
548
+ bzf->buflen = BZ_RB_BLOCKSIZE;
549
+ bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
544
550
  }
545
551
  bzf->bzs.next_in = RSTRING_PTR(a);
546
552
  bzf->bzs.avail_in = RSTRING_LEN(a);
547
553
  while (bzf->bzs.avail_in) {
548
- bzf->bzs.next_out = bzf->buf;
549
- bzf->bzs.avail_out = bzf->buflen;
550
- bzf->state = BZ2_bzCompress(&(bzf->bzs), BZ_RUN);
551
- if (bzf->state == BZ_SEQUENCE_ERROR || bzf->state == BZ_PARAM_ERROR) {
552
- bz_writer_internal_flush(bzf);
553
- bz_raise(bzf->state);
554
- }
555
- bzf->state = BZ_OK;
556
- if (bzf->bzs.avail_out < bzf->buflen) {
557
- n = bzf->buflen - bzf->bzs.avail_out;
558
- rb_funcall(bzf->io, id_write, 1, rb_str_new(bzf->buf, n));
559
- }
554
+ bzf->bzs.next_out = bzf->buf;
555
+ bzf->bzs.avail_out = bzf->buflen;
556
+ bzf->state = BZ2_bzCompress(&(bzf->bzs), BZ_RUN);
557
+ if (bzf->state == BZ_SEQUENCE_ERROR || bzf->state == BZ_PARAM_ERROR) {
558
+ bz_writer_internal_flush(bzf);
559
+ bz_raise(bzf->state);
560
+ }
561
+ bzf->state = BZ_OK;
562
+ if (bzf->bzs.avail_out < bzf->buflen) {
563
+ n = bzf->buflen - bzf->bzs.avail_out;
564
+ rb_funcall(bzf->io, id_write, 1, rb_str_new(bzf->buf, n));
565
+ }
560
566
  }
561
567
  return INT2NUM(RSTRING_LEN(a));
562
568
  }
563
569
 
564
- static VALUE
565
- bz_writer_putc(obj, a)
566
- VALUE obj, a;
567
- {
570
+ /*
571
+ * call-seq:
572
+ * putc(num)
573
+ *
574
+ * Write one byte into this stream.
575
+ * @param [Integer] num the number value of the character to write
576
+ * @return [Integer] always 1
577
+ * @raise [IOError] if the stream has been closed
578
+ */
579
+ static VALUE bz_writer_putc(VALUE obj, VALUE a) {
568
580
  char c = NUM2CHR(a);
569
581
  return bz_writer_write(obj, rb_str_new(&c, 1));
570
582
  }
571
583
 
572
- static VALUE
573
- bz_compress(argc, argv, obj)
574
- int argc;
575
- VALUE obj, *argv;
576
- {
584
+ /*
585
+ * call-seq:
586
+ * compress(str)
587
+ *
588
+ * Shortcut for compressing just a string.
589
+ *
590
+ * Bzip2.uncompress Bzip2.compress('data') # => 'data'
591
+ *
592
+ * @param [String] str the string to compress
593
+ * @return [String] +str+ compressed with bz2
594
+ */
595
+ static VALUE bz_compress(int argc, VALUE *argv, VALUE obj) {
577
596
  VALUE bz2, str;
578
597
 
579
598
  if (!argc) {
580
- rb_raise(rb_eArgError, "need a String to compress");
599
+ rb_raise(rb_eArgError, "need a String to compress");
581
600
  }
582
601
  str = rb_str_to_str(argv[0]);
583
602
  argv[0] = Qnil;
584
603
  bz2 = rb_funcall2(bz_cWriter, id_new, argc, argv);
585
604
  if (OBJ_TAINTED(str)) {
586
- struct bz_file *bzf;
587
- Data_Get_Struct(bz2, struct bz_file, bzf);
588
- OBJ_TAINT(bzf->io);
605
+ struct bz_file *bzf;
606
+ Data_Get_Struct(bz2, struct bz_file, bzf);
607
+ OBJ_TAINT(bzf->io);
589
608
  }
590
609
  bz_writer_write(bz2, str);
591
610
  return bz_writer_close(bz2);
592
611
  }
593
612
 
594
- static VALUE
595
- bz_reader_s_alloc(obj)
596
- VALUE obj;
597
- {
613
+ /*
614
+ * Internally allocates data for a new Reader
615
+ * @private
616
+ */
617
+ static VALUE bz_reader_s_alloc(VALUE obj) {
598
618
  struct bz_file *bzf;
599
619
  VALUE res;
600
- res = Data_Make_Struct(obj, struct bz_file, bz_file_mark,
601
- ruby_xfree, bzf);
620
+ res = Data_Make_Struct(obj, struct bz_file, bz_file_mark, free, bzf);
602
621
  bzf->bzs.bzalloc = bz_malloc;
603
622
  bzf->bzs.bzfree = bz_free;
604
623
  bzf->blocks = DEFAULT_BLOCKS;
@@ -608,79 +627,103 @@ bz_reader_s_alloc(obj)
608
627
 
609
628
  static VALUE bz_reader_close __((VALUE));
610
629
 
611
- static VALUE
612
- bz_reader_s_open(argc, argv, obj)
613
- int argc;
614
- VALUE obj, *argv;
615
- {
630
+ /*
631
+ * call-seq:
632
+ * open(filename, &block=nil) -> Bzip2::Reader
633
+ *
634
+ * @param [String] filename the name of the file to read from
635
+ * @yieldparam [Bzip2::Reader] reader the Bzip2::Reader instance
636
+ *
637
+ * If a block is given, the created Bzip2::Reader instance is yielded to the
638
+ * block and will be closed when the block completes. It is guaranteed via
639
+ * +ensure+ that the reader is closed
640
+ *
641
+ * If a block is not given, a Bzip2::Reader instance will be returned
642
+ *
643
+ * Bzip2::Reader.open('file') { |f| puts f.gets }
644
+ *
645
+ * reader = Bzip2::Reader.open('file')
646
+ * puts reader.gets
647
+ * reader.close
648
+ *
649
+ * @return [Bzip2::Reader, nil]
650
+ */
651
+ static VALUE bz_reader_s_open(int argc, VALUE *argv, VALUE obj) {
616
652
  VALUE res;
617
653
  struct bz_file *bzf;
618
654
 
619
655
  if (argc < 1) {
620
- rb_raise(rb_eArgError, "invalid number of arguments");
656
+ rb_raise(rb_eArgError, "invalid number of arguments");
621
657
  }
622
658
  argv[0] = rb_funcall2(rb_mKernel, id_open, 1, argv);
623
- if (NIL_P(argv[0])) return Qnil;
659
+ if (NIL_P(argv[0])) {
660
+ return Qnil;
661
+ }
624
662
  res = rb_funcall2(obj, id_new, argc, argv);
625
663
  Data_Get_Struct(res, struct bz_file, bzf);
626
664
  bzf->flags |= BZ2_RB_CLOSE;
627
665
  if (rb_block_given_p()) {
628
- return rb_ensure(rb_yield, res, bz_reader_close, res);
666
+ return rb_ensure(rb_yield, res, bz_reader_close, res);
629
667
  }
630
668
  return res;
631
669
  }
632
670
 
633
- static VALUE
634
- bz_reader_init(argc, argv, obj)
635
- int argc;
636
- VALUE obj, *argv;
637
- {
671
+ /*
672
+ * call-seq:
673
+ * initialize(io)
674
+ *
675
+ * Creates a new stream for reading a bzip file or string
676
+ *
677
+ * @param [File, string, #read] io the source for input data. If the source is
678
+ * a file or something responding to #read, then data will be read via #read,
679
+ * otherwise if the input is a string it will be taken as the literal data
680
+ * to decompress
681
+ */
682
+ static VALUE bz_reader_init(int argc, VALUE *argv, VALUE obj) {
638
683
  struct bz_file *bzf;
639
684
  int small = 0;
640
685
  VALUE a, b;
641
686
  int internal = 0;
642
687
 
643
688
  if (rb_scan_args(argc, argv, "11", &a, &b) == 2) {
644
- small = RTEST(b);
689
+ small = RTEST(b);
645
690
  }
646
691
  rb_io_taint_check(a);
647
692
  if (OBJ_TAINTED(a)) {
648
- OBJ_TAINT(obj);
693
+ OBJ_TAINT(obj);
649
694
  }
650
695
  if (rb_respond_to(a, id_read)) {
651
- if (TYPE(a) == T_FILE) {
696
+ if (TYPE(a) == T_FILE) {
652
697
  #ifndef RUBY_19_COMPATIBILITY
653
- OpenFile *fptr;
698
+ OpenFile *fptr;
654
699
  #else
655
- rb_io_t *fptr;
700
+ rb_io_t *fptr;
656
701
  #endif
657
702
 
658
- GetOpenFile(a, fptr);
659
- rb_io_check_readable(fptr);
660
- }
661
- else if (rb_respond_to(a, id_closed)) {
662
- VALUE iv = rb_funcall2(a, id_closed, 0, 0);
663
- if (RTEST(iv)) {
664
- rb_raise(rb_eArgError, "closed object");
703
+ GetOpenFile(a, fptr);
704
+ rb_io_check_readable(fptr);
705
+ } else if (rb_respond_to(a, id_closed)) {
706
+ VALUE iv = rb_funcall2(a, id_closed, 0, 0);
707
+ if (RTEST(iv)) {
708
+ rb_raise(rb_eArgError, "closed object");
709
+ }
665
710
  }
666
- }
667
- }
668
- else {
669
- struct bz_str *bzs;
670
- VALUE res;
711
+ } else {
712
+ struct bz_str *bzs;
713
+ VALUE res;
671
714
 
672
- if (!rb_respond_to(a, id_str)) {
673
- rb_raise(rb_eArgError, "first argument must respond to #read");
674
- }
675
- a = rb_funcall2(a, id_str, 0, 0);
676
- if (TYPE(a) != T_STRING) {
677
- rb_raise(rb_eArgError, "#to_str must return a String");
678
- }
679
- res = Data_Make_Struct(bz_cInternal, struct bz_str,
680
- bz_str_mark, ruby_xfree, bzs);
681
- bzs->str = a;
682
- a = res;
683
- internal = BZ2_RB_INTERNAL;
715
+ if (!rb_respond_to(a, id_str)) {
716
+ rb_raise(rb_eArgError, "first argument must respond to #read");
717
+ }
718
+ a = rb_funcall2(a, id_str, 0, 0);
719
+ if (TYPE(a) != T_STRING) {
720
+ rb_raise(rb_eArgError, "#to_str must return a String");
721
+ }
722
+ res = Data_Make_Struct(bz_cInternal, struct bz_str,
723
+ bz_str_mark, free, bzs);
724
+ bzs->str = a;
725
+ a = res;
726
+ internal = BZ2_RB_INTERNAL;
684
727
  }
685
728
  Data_Get_Struct(obj, struct bz_file, bzf);
686
729
  bzf->io = a;
@@ -689,70 +732,63 @@ bz_reader_init(argc, argv, obj)
689
732
  return obj;
690
733
  }
691
734
 
692
- static struct bz_file *
693
- bz_get_bzf(obj)
694
- VALUE obj;
695
- {
735
+ static struct bz_file * bz_get_bzf(VALUE obj) {
696
736
  struct bz_file *bzf;
697
737
 
698
738
  Get_BZ2(obj, bzf);
699
739
  if (!bzf->buf) {
700
- if (bzf->state != BZ_OK) {
701
- bz_raise(bzf->state);
702
- }
703
- bzf->state = BZ2_bzDecompressInit(&(bzf->bzs), 0, bzf->small);
704
- if (bzf->state != BZ_OK) {
705
- BZ2_bzDecompressEnd(&(bzf->bzs));
706
- bz_raise(bzf->state);
707
- }
708
- bzf->buf = ALLOC_N(char, BZ_RB_BLOCKSIZE + 1);
709
- bzf->buflen = BZ_RB_BLOCKSIZE;
710
- bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
711
- bzf->bzs.total_out_hi32 = bzf->bzs.total_out_lo32 = 0;
712
- bzf->bzs.next_out = bzf->buf;
713
- bzf->bzs.avail_out = 0;
740
+ if (bzf->state != BZ_OK) {
741
+ bz_raise(bzf->state);
742
+ }
743
+ bzf->state = BZ2_bzDecompressInit(&(bzf->bzs), 0, bzf->small);
744
+ if (bzf->state != BZ_OK) {
745
+ BZ2_bzDecompressEnd(&(bzf->bzs));
746
+ bz_raise(bzf->state);
747
+ }
748
+ bzf->buf = ALLOC_N(char, BZ_RB_BLOCKSIZE + 1);
749
+ bzf->buflen = BZ_RB_BLOCKSIZE;
750
+ bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
751
+ bzf->bzs.total_out_hi32 = bzf->bzs.total_out_lo32 = 0;
752
+ bzf->bzs.next_out = bzf->buf;
753
+ bzf->bzs.avail_out = 0;
714
754
  }
715
755
  if (bzf->state == BZ_STREAM_END && !bzf->bzs.avail_out) {
716
- return 0;
756
+ return 0;
717
757
  }
718
758
  return bzf;
719
759
  }
720
760
 
721
- static int
722
- bz_next_available(bzf, in)
723
- struct bz_file *bzf;
724
- int in;
725
- {
761
+ static int bz_next_available(struct bz_file *bzf, int in){
726
762
  bzf->bzs.next_out = bzf->buf;
727
763
  bzf->bzs.avail_out = 0;
728
764
  if (bzf->state == BZ_STREAM_END) {
729
- return BZ_STREAM_END;
765
+ return BZ_STREAM_END;
730
766
  }
731
767
  if (!bzf->bzs.avail_in) {
732
- bzf->in = rb_funcall(bzf->io, id_read, 1, INT2FIX(1024));
733
- if (TYPE(bzf->in) != T_STRING || RSTRING_LEN(bzf->in) == 0) {
734
- BZ2_bzDecompressEnd(&(bzf->bzs));
735
- bzf->bzs.avail_out = 0;
736
- bzf->state = BZ_UNEXPECTED_EOF;
737
- bz_raise(bzf->state);
738
- }
739
- bzf->bzs.next_in = RSTRING_PTR(bzf->in);
740
- bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
768
+ bzf->in = rb_funcall(bzf->io, id_read, 1, INT2FIX(1024));
769
+ if (TYPE(bzf->in) != T_STRING || RSTRING_LEN(bzf->in) == 0) {
770
+ BZ2_bzDecompressEnd(&(bzf->bzs));
771
+ bzf->bzs.avail_out = 0;
772
+ bzf->state = BZ_UNEXPECTED_EOF;
773
+ bz_raise(bzf->state);
774
+ }
775
+ bzf->bzs.next_in = RSTRING_PTR(bzf->in);
776
+ bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
741
777
  }
742
778
  if ((bzf->buflen - in) < (BZ_RB_BLOCKSIZE / 2)) {
743
- bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen+BZ_RB_BLOCKSIZE+1);
744
- bzf->buflen += BZ_RB_BLOCKSIZE;
745
- bzf->buf[bzf->buflen] = '\0';
779
+ bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen+BZ_RB_BLOCKSIZE+1);
780
+ bzf->buflen += BZ_RB_BLOCKSIZE;
781
+ bzf->buf[bzf->buflen] = '\0';
746
782
  }
747
783
  bzf->bzs.avail_out = bzf->buflen - in;
748
784
  bzf->bzs.next_out = bzf->buf + in;
749
785
  bzf->state = BZ2_bzDecompress(&(bzf->bzs));
750
786
  if (bzf->state != BZ_OK) {
751
- BZ2_bzDecompressEnd(&(bzf->bzs));
752
- if (bzf->state != BZ_STREAM_END) {
753
- bzf->bzs.avail_out = 0;
754
- bz_raise(bzf->state);
755
- }
787
+ BZ2_bzDecompressEnd(&(bzf->bzs));
788
+ if (bzf->state != BZ_STREAM_END) {
789
+ bzf->bzs.avail_out = 0;
790
+ bz_raise(bzf->state);
791
+ }
756
792
  }
757
793
  bzf->bzs.avail_out = bzf->buflen - bzf->bzs.avail_out;
758
794
  bzf->bzs.next_out = bzf->buf;
@@ -761,101 +797,99 @@ bz_next_available(bzf, in)
761
797
 
762
798
  #define ASIZE (1 << CHAR_BIT)
763
799
 
764
- static VALUE
765
- bz_read_until(bzf, str, len, td1)
766
- struct bz_file *bzf;
767
- char *str;
768
- int len;
769
- int *td1;
770
- {
800
+ static VALUE bz_read_until(struct bz_file *bzf, const char *str, int len, int *td1) {
771
801
  VALUE res;
772
802
  int total, i, nex = 0;
773
- char *p, *t, *tx, *end, *pend = str + len;
803
+ char *p, *t, *tx, *end, *pend = ((char*) str) + len;
774
804
 
775
805
  res = rb_str_new(0, 0);
776
806
  while (1) {
777
- total = bzf->bzs.avail_out;
778
- if (len == 1) {
779
- tx = memchr(bzf->bzs.next_out, *str, bzf->bzs.avail_out);
780
- if (tx) {
781
- i = tx - bzf->bzs.next_out + len;
782
- res = rb_str_cat(res, bzf->bzs.next_out, i);
783
- bzf->bzs.next_out += i;
784
- bzf->bzs.avail_out -= i;
785
- return res;
786
- }
787
- }
788
- else {
789
- tx = bzf->bzs.next_out;
790
- end = bzf->bzs.next_out + bzf->bzs.avail_out;
791
- while (tx + len <= end) {
792
- for (p = str, t = tx; p != pend; ++p, ++t) {
793
- if (*p != *t) break;
794
- }
795
- if (p == pend) {
796
- i = tx - bzf->bzs.next_out + len;
797
- res = rb_str_cat(res, bzf->bzs.next_out, i);
798
- bzf->bzs.next_out += i;
799
- bzf->bzs.avail_out -= i;
800
- return res;
801
- }
802
- if (td1) {
803
- tx += td1[(int)*(tx + len)];
804
- }
805
- else {
806
- tx += 1;
807
- }
808
- }
809
- }
810
- nex = 0;
811
- if (total) {
812
- nex = len - 1;
813
- res = rb_str_cat(res, bzf->bzs.next_out, total - nex);
814
- if (nex) {
815
- MEMMOVE(bzf->buf, bzf->bzs.next_out + total - nex, char, nex);
807
+ total = bzf->bzs.avail_out;
808
+ if (len == 1) {
809
+ tx = memchr(bzf->bzs.next_out, *str, bzf->bzs.avail_out);
810
+ if (tx) {
811
+ i = tx - bzf->bzs.next_out + len;
812
+ res = rb_str_cat(res, bzf->bzs.next_out, i);
813
+ bzf->bzs.next_out += i;
814
+ bzf->bzs.avail_out -= i;
815
+ return res;
816
+ }
817
+ } else {
818
+ tx = bzf->bzs.next_out;
819
+ end = bzf->bzs.next_out + bzf->bzs.avail_out;
820
+ while (tx + len <= end) {
821
+ for (p = (char*) str, t = tx; p != pend; ++p, ++t) {
822
+ if (*p != *t) break;
823
+ }
824
+ if (p == pend) {
825
+ i = tx - bzf->bzs.next_out + len;
826
+ res = rb_str_cat(res, bzf->bzs.next_out, i);
827
+ bzf->bzs.next_out += i;
828
+ bzf->bzs.avail_out -= i;
829
+ return res;
830
+ }
831
+ if (td1) {
832
+ tx += td1[(int)*(tx + len)];
833
+ } else {
834
+ tx += 1;
835
+ }
836
+ }
816
837
  }
817
- }
818
- if (bz_next_available(bzf, nex) == BZ_STREAM_END) {
819
- if (nex) {
820
- res = rb_str_cat(res, bzf->buf, nex);
838
+ nex = 0;
839
+ if (total) {
840
+ nex = len - 1;
841
+ res = rb_str_cat(res, bzf->bzs.next_out, total - nex);
842
+ if (nex) {
843
+ MEMMOVE(bzf->buf, bzf->bzs.next_out + total - nex, char, nex);
844
+ }
821
845
  }
822
- if (RSTRING_LEN(res)) {
823
- return res;
846
+ if (bz_next_available(bzf, nex) == BZ_STREAM_END) {
847
+ if (nex) {
848
+ res = rb_str_cat(res, bzf->buf, nex);
849
+ }
850
+ if (RSTRING_LEN(res)) {
851
+ return res;
852
+ }
853
+ return Qnil;
824
854
  }
825
- return Qnil;
826
- }
827
855
  }
828
856
  return Qnil;
829
857
  }
830
858
 
831
- static int
832
- bz_read_while(bzf, c)
833
- struct bz_file *bzf;
834
- char c;
835
- {
859
+ static int bz_read_while(struct bz_file *bzf, char c) {
836
860
  char *end;
837
861
 
838
862
  while (1) {
839
- end = bzf->bzs.next_out + bzf->bzs.avail_out;
840
- while (bzf->bzs.next_out < end) {
841
- if (c != *bzf->bzs.next_out) {
842
- bzf->bzs.avail_out = end - bzf->bzs.next_out;
843
- return *bzf->bzs.next_out;
863
+ end = bzf->bzs.next_out + bzf->bzs.avail_out;
864
+ while (bzf->bzs.next_out < end) {
865
+ if (c != *bzf->bzs.next_out) {
866
+ bzf->bzs.avail_out = end - bzf->bzs.next_out;
867
+ return *bzf->bzs.next_out;
868
+ }
869
+ ++bzf->bzs.next_out;
870
+ }
871
+ if (bz_next_available(bzf, 0) == BZ_STREAM_END) {
872
+ return EOF;
844
873
  }
845
- ++bzf->bzs.next_out;
846
- }
847
- if (bz_next_available(bzf, 0) == BZ_STREAM_END) {
848
- return EOF;
849
- }
850
874
  }
851
875
  return EOF;
852
876
  }
853
877
 
854
- static VALUE
855
- bz_reader_read(argc, argv, obj)
856
- int argc;
857
- VALUE obj, *argv;
858
- {
878
+ /*
879
+ * call-seq:
880
+ * read(len = nil)
881
+ *
882
+ * Read decompressed data from the stream.
883
+ *
884
+ * Bzip2::Reader.new(Bzip2.compress('ab')).read # => "ab"
885
+ * Bzip2::Reader.new(Bzip2.compress('ab')).read(1) # => "a"
886
+ *
887
+ * @return [String, nil] the decompressed data read or +nil+ if eoz has been
888
+ * reached
889
+ * @param [Integer] len the number of decompressed bytes which should be read.
890
+ * If nothing is specified, the entire stream is read
891
+ */
892
+ static VALUE bz_reader_read(int argc, VALUE *argv, VALUE obj) {
859
893
  struct bz_file *bzf;
860
894
  VALUE res, length;
861
895
  int total;
@@ -863,449 +897,552 @@ bz_reader_read(argc, argv, obj)
863
897
 
864
898
  rb_scan_args(argc, argv, "01", &length);
865
899
  if (NIL_P(length)) {
866
- n = -1;
867
- }
868
- else {
869
- n = NUM2INT(length);
870
- if (n < 0) {
871
- rb_raise(rb_eArgError, "negative length %d given", n);
872
- }
900
+ n = -1;
901
+ } else {
902
+ n = NUM2INT(length);
903
+ if (n < 0) {
904
+ rb_raise(rb_eArgError, "negative length %d given", n);
905
+ }
873
906
  }
874
907
  bzf = bz_get_bzf(obj);
875
908
  if (!bzf) {
876
- return Qnil;
909
+ return Qnil;
877
910
  }
878
911
  res = rb_str_new(0, 0);
879
912
  if (OBJ_TAINTED(obj)) {
880
- OBJ_TAINT(res);
913
+ OBJ_TAINT(res);
881
914
  }
882
915
  if (n == 0) {
883
- return res;
884
- }
885
- while (1) {
886
- total = bzf->bzs.avail_out;
887
- if (n != -1 && (RSTRING_LEN(res) + total) >= n) {
888
- n -= RSTRING_LEN(res);
889
- res = rb_str_cat(res, bzf->bzs.next_out, n);
890
- bzf->bzs.next_out += n;
891
- bzf->bzs.avail_out -= n;
892
- return res;
893
- }
894
- if (total) {
895
- res = rb_str_cat(res, bzf->bzs.next_out, total);
896
- }
897
- if (bz_next_available(bzf, 0) == BZ_STREAM_END) {
898
916
  return res;
899
917
  }
918
+ while (1) {
919
+ total = bzf->bzs.avail_out;
920
+ if (n != -1 && (RSTRING_LEN(res) + total) >= n) {
921
+ n -= RSTRING_LEN(res);
922
+ res = rb_str_cat(res, bzf->bzs.next_out, n);
923
+ bzf->bzs.next_out += n;
924
+ bzf->bzs.avail_out -= n;
925
+ return res;
926
+ }
927
+ if (total) {
928
+ res = rb_str_cat(res, bzf->bzs.next_out, total);
929
+ }
930
+ if (bz_next_available(bzf, 0) == BZ_STREAM_END) {
931
+ return res;
932
+ }
900
933
  }
901
934
  return Qnil;
902
935
  }
903
936
 
904
- static int
905
- bz_getc(obj)
906
- VALUE obj;
907
- {
937
+ static int bz_getc(VALUE obj) {
908
938
  VALUE length = INT2FIX(1);
909
939
  VALUE res = bz_reader_read(1, &length, obj);
910
940
  if (NIL_P(res) || RSTRING_LEN(res) == 0) {
911
- return EOF;
941
+ return EOF;
912
942
  }
913
943
  return RSTRING_PTR(res)[0];
914
944
  }
915
945
 
916
- static VALUE
917
- bz_reader_ungetc(obj, a)
918
- VALUE obj, a;
919
- {
946
+ /*
947
+ * call-seq:
948
+ * ungetc(byte)
949
+ *
950
+ * "Ungets" a character/byte. This rewinds the stream by 1 character and inserts
951
+ * the given character into that position. The next read will return the given
952
+ * character as the first one read
953
+ *
954
+ * reader = Bzip2::Reader.new Bzip2.compress('abc')
955
+ * reader.getc # => 97
956
+ * reader.ungetc 97 # => nil
957
+ * reader.getc # => 97
958
+ * reader.ungetc 42 # => nil
959
+ * reader.getc # => 42
960
+ * reader.getc # => 98
961
+ * reader.getc # => 99
962
+ * reader.ungetc 100 # => nil
963
+ * reader.getc # => 100
964
+ *
965
+ * @param [Integer] byte the byte to 'unget'
966
+ * @return [nil] always
967
+ */
968
+ static VALUE bz_reader_ungetc(VALUE obj, VALUE a) {
920
969
  struct bz_file *bzf;
921
970
  int c = NUM2INT(a);
922
971
 
923
972
  Get_BZ2(obj, bzf);
924
973
  if (!bzf->buf) {
925
- bz_raise(BZ_SEQUENCE_ERROR);
974
+ bz_raise(BZ_SEQUENCE_ERROR);
926
975
  }
927
976
  if (bzf->bzs.avail_out < bzf->buflen) {
928
- bzf->bzs.next_out -= 1;
929
- bzf->bzs.next_out[0] = c;
930
- bzf->bzs.avail_out += 1;
931
- }
932
- else {
933
- bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + 2);
934
- bzf->buf[bzf->buflen++] = c;
935
- bzf->buf[bzf->buflen] = '\0';
936
- bzf->bzs.next_out = bzf->buf;
937
- bzf->bzs.avail_out = bzf->buflen;
977
+ bzf->bzs.next_out -= 1;
978
+ bzf->bzs.next_out[0] = c;
979
+ bzf->bzs.avail_out += 1;
980
+ } else {
981
+ bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + 2);
982
+ bzf->buf[bzf->buflen++] = c;
983
+ bzf->buf[bzf->buflen] = '\0';
984
+ bzf->bzs.next_out = bzf->buf;
985
+ bzf->bzs.avail_out = bzf->buflen;
938
986
  }
939
987
  return Qnil;
940
988
  }
941
989
 
942
- static VALUE
943
- bz_reader_ungets(obj, a)
944
- VALUE obj, a;
945
- {
990
+ /*
991
+ * call-seq:
992
+ * ungets(str)
993
+ *
994
+ * Equivalently "unget" a string. When called on a string that was just read
995
+ * from the stream, this inserts the string back into the stream to br read
996
+ * again.
997
+ *
998
+ * When called with a string which hasn't been read from the stream, it does
999
+ * the same thing, and the next read line/data will start from the beginning
1000
+ * of the given data and the continue on with the rest of the stream.
1001
+ *
1002
+ * reader = Bzip2::Reader.new Bzip2.compress("a\nb")
1003
+ * reader.gets # => "a\n"
1004
+ * reader.ungets "a\n" # => nil
1005
+ * reader.gets # => "a\n"
1006
+ * reader.ungets "foo" # => nil
1007
+ * reader.gets # => "foob"
1008
+ *
1009
+ * @param [String] str the string to insert back into the stream
1010
+ * @return [nil] always
1011
+ */
1012
+ static VALUE bz_reader_ungets(VALUE obj, VALUE a) {
946
1013
  struct bz_file *bzf;
947
1014
 
948
1015
  Check_Type(a, T_STRING);
949
1016
  Get_BZ2(obj, bzf);
950
1017
  if (!bzf->buf) {
951
- bz_raise(BZ_SEQUENCE_ERROR);
1018
+ bz_raise(BZ_SEQUENCE_ERROR);
952
1019
  }
953
1020
  if ((bzf->bzs.avail_out + RSTRING_LEN(a)) < bzf->buflen) {
954
- bzf->bzs.next_out -= RSTRING_LEN(a);
955
- MEMCPY(bzf->bzs.next_out, RSTRING_PTR(a), char, RSTRING_LEN(a));
956
- bzf->bzs.avail_out += RSTRING_LEN(a);
957
- }
958
- else {
959
- bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + RSTRING_LEN(a) + 1);
960
- MEMCPY(bzf->buf + bzf->buflen, RSTRING_PTR(a), char,RSTRING_LEN(a));
961
- bzf->buflen += RSTRING_LEN(a);
962
- bzf->buf[bzf->buflen] = '\0';
963
- bzf->bzs.next_out = bzf->buf;
964
- bzf->bzs.avail_out = bzf->buflen;
1021
+ bzf->bzs.next_out -= RSTRING_LEN(a);
1022
+ MEMCPY(bzf->bzs.next_out, RSTRING_PTR(a), char, RSTRING_LEN(a));
1023
+ bzf->bzs.avail_out += RSTRING_LEN(a);
1024
+ } else {
1025
+ bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + RSTRING_LEN(a) + 1);
1026
+ MEMCPY(bzf->buf + bzf->buflen, RSTRING_PTR(a), char,RSTRING_LEN(a));
1027
+ bzf->buflen += RSTRING_LEN(a);
1028
+ bzf->buf[bzf->buflen] = '\0';
1029
+ bzf->bzs.next_out = bzf->buf;
1030
+ bzf->bzs.avail_out = bzf->buflen;
965
1031
  }
966
1032
  return Qnil;
967
1033
  }
968
1034
 
969
- VALUE
970
- bz_reader_gets(obj)
971
- VALUE obj;
972
- {
1035
+ VALUE bz_reader_gets(VALUE obj) {
973
1036
  struct bz_file *bzf;
974
1037
  VALUE str = Qnil;
975
1038
 
976
1039
  bzf = bz_get_bzf(obj);
977
1040
  if (bzf) {
978
- str = bz_read_until(bzf, "\n", 1, 0);
979
- if (!NIL_P(str)) {
980
- bzf->lineno++;
981
- OBJ_TAINT(str);
982
- }
1041
+ str = bz_read_until(bzf, "\n", 1, 0);
1042
+ if (!NIL_P(str)) {
1043
+ bzf->lineno++;
1044
+ OBJ_TAINT(str);
1045
+ }
983
1046
  }
984
1047
  return str;
985
1048
  }
986
1049
 
987
- static VALUE
988
- bz_reader_gets_internal(argc, argv, obj, td, init)
989
- int argc;
990
- VALUE obj, *argv;
991
- int *td, init;
992
- {
1050
+ static VALUE bz_reader_gets_internal(int argc, VALUE *argv, VALUE obj, int *td, int init) {
993
1051
  struct bz_file *bzf;
994
1052
  VALUE rs, res;
995
- char *rsptr;
1053
+ const char *rsptr;
996
1054
  int rslen, rspara, *td1;
997
1055
 
998
1056
  rs = rb_rs;
999
1057
  if (argc) {
1000
- rb_scan_args(argc, argv, "1", &rs);
1001
- if (!NIL_P(rs)) {
1002
- Check_Type(rs, T_STRING);
1003
- }
1058
+ rb_scan_args(argc, argv, "1", &rs);
1059
+ if (!NIL_P(rs)) {
1060
+ Check_Type(rs, T_STRING);
1061
+ }
1004
1062
  }
1005
1063
  if (NIL_P(rs)) {
1006
- return bz_reader_read(1, &rs, obj);
1064
+ return bz_reader_read(1, &rs, obj);
1007
1065
  }
1008
1066
  rslen = RSTRING_LEN(rs);
1009
1067
  if (rs == rb_default_rs || (rslen == 1 && RSTRING_PTR(rs)[0] == '\n')) {
1010
- return bz_reader_gets(obj);
1068
+ return bz_reader_gets(obj);
1011
1069
  }
1012
1070
 
1013
1071
  if (rslen == 0) {
1014
- rsptr = "\n\n";
1015
- rslen = 2;
1016
- rspara = 1;
1017
- }
1018
- else {
1019
- rsptr = RSTRING_PTR(rs);
1020
- rspara = 0;
1072
+ rsptr = "\n\n";
1073
+ rslen = 2;
1074
+ rspara = 1;
1075
+ } else {
1076
+ rsptr = RSTRING_PTR(rs);
1077
+ rspara = 0;
1021
1078
  }
1022
1079
 
1023
1080
  bzf = bz_get_bzf(obj);
1024
1081
  if (!bzf) {
1025
- return Qnil;
1082
+ return Qnil;
1026
1083
  }
1027
1084
  if (rspara) {
1028
- bz_read_while(bzf, '\n');
1085
+ bz_read_while(bzf, '\n');
1029
1086
  }
1030
1087
  td1 = 0;
1031
1088
  if (rslen != 1) {
1032
- if (init) {
1033
- int i;
1089
+ if (init) {
1090
+ int i;
1034
1091
 
1035
- for (i = 0; i < ASIZE; i++) {
1036
- td[i] = rslen + 1;
1037
- }
1038
- for (i = 0; i < rslen; i++) {
1039
- td[(int)*(rsptr + i)] = rslen - i;
1092
+ for (i = 0; i < ASIZE; i++) {
1093
+ td[i] = rslen + 1;
1094
+ }
1095
+ for (i = 0; i < rslen; i++) {
1096
+ td[(int)*(rsptr + i)] = rslen - i;
1097
+ }
1040
1098
  }
1041
- }
1042
- td1 = td;
1099
+ td1 = td;
1043
1100
  }
1044
1101
 
1045
1102
  res = bz_read_until(bzf, rsptr, rslen, td1);
1046
1103
  if (rspara) {
1047
- bz_read_while(bzf, '\n');
1104
+ bz_read_while(bzf, '\n');
1048
1105
  }
1049
1106
 
1050
1107
  if (!NIL_P(res)) {
1051
- bzf->lineno++;
1052
- OBJ_TAINT(res);
1108
+ bzf->lineno++;
1109
+ OBJ_TAINT(res);
1053
1110
  }
1054
1111
  return res;
1055
1112
  }
1056
1113
 
1057
- static VALUE
1058
- bz_reader_set_unused(obj, a)
1059
- VALUE obj, a;
1060
- {
1114
+ /*
1115
+ * Specs were missing for this method originally and playing around with it
1116
+ * gave some very odd results, so unless you know what you're doing, I wouldn't
1117
+ * mess around with this...
1118
+ */
1119
+ static VALUE bz_reader_set_unused(VALUE obj, VALUE a) {
1061
1120
  struct bz_file *bzf;
1062
1121
 
1063
1122
  Check_Type(a, T_STRING);
1064
1123
  Get_BZ2(obj, bzf);
1065
1124
  if (!bzf->in) {
1066
- bzf->in = rb_str_new(RSTRING_PTR(a), RSTRING_LEN(a));
1067
- }
1068
- else {
1069
- bzf->in = rb_str_cat(bzf->in, RSTRING_PTR(a), RSTRING_LEN(a));
1125
+ bzf->in = rb_str_new(RSTRING_PTR(a), RSTRING_LEN(a));
1126
+ } else {
1127
+ bzf->in = rb_str_cat(bzf->in, RSTRING_PTR(a), RSTRING_LEN(a));
1070
1128
  }
1071
1129
  bzf->bzs.next_in = RSTRING_PTR(bzf->in);
1072
1130
  bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
1073
1131
  return Qnil;
1074
1132
  }
1075
1133
 
1076
- static VALUE
1077
- bz_reader_getc(obj)
1078
- VALUE obj;
1079
- {
1134
+ /*
1135
+ * Reads one character from the stream, returning the byte read.
1136
+ *
1137
+ * reader = Bzip2::Reader.new Bzip2.compress('ab')
1138
+ * reader.getc # => 97
1139
+ * reader.getc # => 98
1140
+ * reader.getc # => nil
1141
+ *
1142
+ * @return [Integer, nil] the byte value of the character read or +nil+ if eoz
1143
+ * has been reached
1144
+ */
1145
+ static VALUE bz_reader_getc(VALUE obj) {
1080
1146
  VALUE str;
1081
1147
  VALUE len = INT2FIX(1);
1082
1148
 
1083
1149
  str = bz_reader_read(1, &len, obj);
1084
1150
  if (NIL_P(str) || RSTRING_LEN(str) == 0) {
1085
- return Qnil;
1151
+ return Qnil;
1086
1152
  }
1087
1153
  return INT2FIX(RSTRING_PTR(str)[0] & 0xff);
1088
1154
  }
1089
1155
 
1090
- static void
1091
- bz_eoz_error()
1092
- {
1156
+ static void bz_eoz_error() {
1093
1157
  rb_raise(bz_eEOZError, "End of Zip component reached");
1094
1158
  }
1095
1159
 
1096
- static VALUE
1097
- bz_reader_readchar(obj)
1098
- VALUE obj;
1099
- {
1160
+ /*
1161
+ * Performs the same as Bzip2::Reader#getc except Bzip2::EOZError is raised if
1162
+ * eoz has been readhed
1163
+ *
1164
+ * @raise [Bzip2::EOZError] if eoz has been reached
1165
+ */
1166
+ static VALUE bz_reader_readchar(VALUE obj) {
1100
1167
  VALUE res = bz_reader_getc(obj);
1101
1168
 
1102
1169
  if (NIL_P(res)) {
1103
- bz_eoz_error();
1170
+ bz_eoz_error();
1104
1171
  }
1105
1172
  return res;
1106
1173
  }
1107
1174
 
1108
- static VALUE
1109
- bz_reader_gets_m(argc, argv, obj)
1110
- int argc;
1111
- VALUE obj, *argv;
1112
- {
1175
+ /*
1176
+ * call-seq:
1177
+ * gets(sep = "\n")
1178
+ *
1179
+ * Reads a line from the stream until the separator is reached. This does not
1180
+ * throw an exception, but rather returns nil if an eoz/eof error occurs
1181
+ *
1182
+ * reader = Bzip2::Reader.new Bzip2.compress("a\nb")
1183
+ * reader.gets # => "a\n"
1184
+ * reader.gets # => "b"
1185
+ * reader.gets # => nil
1186
+ *
1187
+ * @return [String, nil] the read data or nil if eoz has been reached
1188
+ * @see Bzip2::Reader#readline
1189
+ */
1190
+ static VALUE bz_reader_gets_m(int argc, VALUE *argv, VALUE obj) {
1113
1191
  int td[ASIZE];
1114
1192
  VALUE str = bz_reader_gets_internal(argc, argv, obj, td, Qtrue);
1115
1193
 
1116
1194
  if (!NIL_P(str)) {
1117
- rb_lastline_set(str);
1195
+ rb_lastline_set(str);
1118
1196
  }
1119
1197
  return str;
1120
1198
  }
1121
1199
 
1122
- static VALUE
1123
- bz_reader_readline(argc, argv, obj)
1124
- int argc;
1125
- VALUE obj, *argv;
1126
- {
1200
+ /*
1201
+ * call-seq:
1202
+ * readline(sep = "\n")
1203
+ *
1204
+ * Reads one line from the stream and returns it (including the separator)
1205
+ *
1206
+ * reader = Bzip2::Reader.new Bzip2.compress("a\nb")
1207
+ * reader.readline # => "a\n"
1208
+ * reader.readline # => "b"
1209
+ * reader.readline # => raises Bzip2::EOZError
1210
+ *
1211
+ *
1212
+ * @param [String] sep the newline separator character
1213
+ * @return [String] the read line
1214
+ * @see Bzip2::Reader.readlines
1215
+ * @raise [Bzip2::EOZError] if the stream has reached its end
1216
+ */
1217
+ static VALUE bz_reader_readline(int argc, VALUE *argv, VALUE obj) {
1127
1218
  VALUE res = bz_reader_gets_m(argc, argv, obj);
1128
1219
 
1129
1220
  if (NIL_P(res)) {
1130
- bz_eoz_error();
1221
+ bz_eoz_error();
1131
1222
  }
1132
1223
  return res;
1133
1224
  }
1134
1225
 
1135
- static VALUE
1136
- bz_reader_readlines(argc, argv, obj)
1137
- int argc;
1138
- VALUE obj, *argv;
1139
- {
1226
+ /*
1227
+ * call-seq:
1228
+ * readlines(sep = "\n")
1229
+ *
1230
+ * Reads the lines of the files and returns the result as an array.
1231
+ *
1232
+ * If the stream has reached eoz, then an empty array is returned
1233
+ *
1234
+ * @param [String] sep the newline separator character
1235
+ * @return [Array] an array of lines read
1236
+ * @see Bzip2::Reader.readlines
1237
+ */
1238
+ static VALUE bz_reader_readlines(int argc, VALUE *argv, VALUE obj) {
1140
1239
  VALUE line, ary;
1141
1240
  int td[ASIZE], in;
1142
1241
 
1143
1242
  in = Qtrue;
1144
1243
  ary = rb_ary_new();
1145
1244
  while (!NIL_P(line = bz_reader_gets_internal(argc, argv, obj, td, in))) {
1146
- in = Qfalse;
1147
- rb_ary_push(ary, line);
1245
+ in = Qfalse;
1246
+ rb_ary_push(ary, line);
1148
1247
  }
1149
1248
  return ary;
1150
1249
  }
1151
1250
 
1152
- static VALUE
1153
- bz_reader_each_line(argc, argv, obj)
1154
- int argc;
1155
- VALUE obj, *argv;
1156
- {
1251
+ /*
1252
+ * call-seq:
1253
+ * each(sep = "\n", &block)
1254
+ *
1255
+ * Iterates over the lines of the stream.
1256
+ *
1257
+ * @param [String] sep the byte which separates lines
1258
+ * @yieldparam [String] line the next line of the file (including the separator
1259
+ * character)
1260
+ * @see Bzip2::Reader.foreach
1261
+ */
1262
+ static VALUE bz_reader_each_line(int argc, VALUE *argv, VALUE obj) {
1157
1263
  VALUE line;
1158
1264
  int td[ASIZE], in;
1159
1265
 
1160
1266
  in = Qtrue;
1161
1267
  while (!NIL_P(line = bz_reader_gets_internal(argc, argv, obj, td, in))) {
1162
- in = Qfalse;
1163
- rb_yield(line);
1268
+ in = Qfalse;
1269
+ rb_yield(line);
1164
1270
  }
1165
1271
  return obj;
1166
1272
  }
1167
1273
 
1168
- static VALUE
1169
- bz_reader_each_byte(obj)
1170
- VALUE obj;
1171
- {
1274
+ /*
1275
+ * call-seq:
1276
+ * each_byte(&block)
1277
+ *
1278
+ * Iterates over the decompressed bytes of the file.
1279
+ *
1280
+ * Bzip2::Writer.open('file'){ |f| f << 'asdf' }
1281
+ * reader = Bzip2::Reader.new File.open('file')
1282
+ * reader.each_byte{ |b| puts "#{b} #{b.chr}" }
1283
+ *
1284
+ * # Output:
1285
+ * # 97 a
1286
+ * # 115 s
1287
+ * # 100 d
1288
+ * # 102 f
1289
+ *
1290
+ * @yieldparam [Integer] byte the decompressed bytes of the file
1291
+ */
1292
+ static VALUE bz_reader_each_byte(VALUE obj) {
1172
1293
  int c;
1173
1294
 
1174
1295
  while ((c = bz_getc(obj)) != EOF) {
1175
- rb_yield(INT2FIX(c & 0xff));
1296
+ rb_yield(INT2FIX(c & 0xff));
1176
1297
  }
1177
1298
  return obj;
1178
1299
  }
1179
1300
 
1180
- static VALUE
1181
- bz_reader_unused(obj)
1182
- VALUE obj;
1183
- {
1301
+ /*
1302
+ * Specs were missing for this method originally and playing around with it
1303
+ * gave some very odd results, so unless you know what you're doing, I wouldn't
1304
+ * mess around with this...
1305
+ */
1306
+ static VALUE bz_reader_unused(VALUE obj) {
1184
1307
  struct bz_file *bzf;
1185
1308
  VALUE res;
1186
1309
 
1187
1310
  Get_BZ2(obj, bzf);
1188
1311
  if (!bzf->in || bzf->state != BZ_STREAM_END) {
1189
- return Qnil;
1312
+ return Qnil;
1190
1313
  }
1191
1314
  if (bzf->bzs.avail_in) {
1192
- res = rb_tainted_str_new(bzf->bzs.next_in, bzf->bzs.avail_in);
1193
- bzf->bzs.avail_in = 0;
1194
- }
1195
- else {
1196
- res = rb_tainted_str_new(0, 0);
1315
+ res = rb_tainted_str_new(bzf->bzs.next_in, bzf->bzs.avail_in);
1316
+ bzf->bzs.avail_in = 0;
1317
+ } else {
1318
+ res = rb_tainted_str_new(0, 0);
1197
1319
  }
1198
1320
  return res;
1199
1321
  }
1200
1322
 
1201
- static VALUE
1202
- bz_reader_eoz(obj)
1203
- VALUE obj;
1204
- {
1323
+ /*
1324
+ * Test whether the end of the bzip stream has been reached
1325
+ *
1326
+ * @return [Boolean] +true+ if the reader is at the end of the bz stream or
1327
+ * +false+ otherwise
1328
+ */
1329
+ static VALUE bz_reader_eoz(VALUE obj) {
1205
1330
  struct bz_file *bzf;
1206
1331
 
1207
1332
  Get_BZ2(obj, bzf);
1208
1333
  if (!bzf->in || !bzf->buf) {
1209
- return Qnil;
1334
+ return Qnil;
1210
1335
  }
1211
1336
  if (bzf->state == BZ_STREAM_END && !bzf->bzs.avail_out) {
1212
- return Qtrue;
1337
+ return Qtrue;
1213
1338
  }
1214
1339
  return Qfalse;
1215
1340
  }
1216
1341
 
1217
- static VALUE
1218
- bz_reader_eof(obj)
1219
- VALUE obj;
1220
- {
1342
+ /*
1343
+ * Test whether the bzip stream has reached its end (see Bzip2::Reader#eoz?)
1344
+ * and then tests that the undlerying IO has also reached an eof
1345
+ *
1346
+ * @return [Boolean] +true+ if the stream has reached or +false+ otherwise.
1347
+ */
1348
+ static VALUE bz_reader_eof(VALUE obj) {
1221
1349
  struct bz_file *bzf;
1222
1350
  VALUE res;
1223
1351
 
1224
1352
  res = bz_reader_eoz(obj);
1225
1353
  if (RTEST(res)) {
1226
- Get_BZ2(obj, bzf);
1227
- if (bzf->bzs.avail_in) {
1228
- res = Qfalse;
1229
- }
1230
- else {
1231
- res = bz_reader_getc(obj);
1232
- if (NIL_P(res)) {
1233
- res = Qtrue;
1234
- }
1235
- else {
1236
- bz_reader_ungetc(res);
1237
- res = Qfalse;
1354
+ Get_BZ2(obj, bzf);
1355
+ if (bzf->bzs.avail_in) {
1356
+ res = Qfalse;
1357
+ } else {
1358
+ res = bz_reader_getc(obj);
1359
+ if (NIL_P(res)) {
1360
+ res = Qtrue;
1361
+ } else {
1362
+ bz_reader_ungetc(obj, res);
1363
+ res = Qfalse;
1364
+ }
1238
1365
  }
1239
1366
  }
1240
- }
1241
1367
  return res;
1242
1368
  }
1243
1369
 
1244
- static VALUE
1245
- bz_reader_closed(obj)
1246
- VALUE obj;
1247
- {
1370
+ /*
1371
+ * Tests whether this reader has be closed.
1372
+ *
1373
+ * @return [Boolean] +true+ if it is or +false+ otherwise.
1374
+ */
1375
+ static VALUE bz_reader_closed(VALUE obj) {
1248
1376
  struct bz_file *bzf;
1249
1377
 
1250
1378
  Data_Get_Struct(obj, struct bz_file, bzf);
1251
1379
  return RTEST(bzf->io)?Qfalse:Qtrue;
1252
1380
  }
1253
1381
 
1254
- static VALUE
1255
- bz_reader_close(obj)
1256
- VALUE obj;
1257
- {
1382
+ /*
1383
+ * Closes this reader to disallow further reads.
1384
+ *
1385
+ * reader = Bzip2::Reader.new File.open('file')
1386
+ * reader.close
1387
+ *
1388
+ * reader.closed? # => true
1389
+ *
1390
+ * @return [File] the io with which the reader was created.
1391
+ * @raise [IOError] if the stream has already been closed
1392
+ */
1393
+ static VALUE bz_reader_close(VALUE obj) {
1258
1394
  struct bz_file *bzf;
1259
1395
  VALUE res;
1260
1396
 
1261
1397
  Get_BZ2(obj, bzf);
1262
1398
  if (bzf->buf) {
1263
- free(bzf->buf);
1264
- bzf->buf = 0;
1399
+ free(bzf->buf);
1400
+ bzf->buf = 0;
1265
1401
  }
1266
1402
  if (bzf->state == BZ_OK) {
1267
- BZ2_bzDecompressEnd(&(bzf->bzs));
1403
+ BZ2_bzDecompressEnd(&(bzf->bzs));
1268
1404
  }
1269
1405
  if (bzf->flags & BZ2_RB_CLOSE) {
1270
- int closed = 0;
1271
- if (rb_respond_to(bzf->io, id_closed)) {
1272
- VALUE iv = rb_funcall2(bzf->io, id_closed, 0, 0);
1273
- closed = RTEST(iv);
1274
- }
1275
- if (!closed && rb_respond_to(bzf->io, id_close)) {
1276
- rb_funcall2(bzf->io, id_close, 0, 0);
1277
- }
1406
+ int closed = 0;
1407
+ if (rb_respond_to(bzf->io, id_closed)) {
1408
+ VALUE iv = rb_funcall2(bzf->io, id_closed, 0, 0);
1409
+ closed = RTEST(iv);
1410
+ }
1411
+ if (!closed && rb_respond_to(bzf->io, id_close)) {
1412
+ rb_funcall2(bzf->io, id_close, 0, 0);
1413
+ }
1278
1414
  }
1279
1415
  if (bzf->flags & (BZ2_RB_CLOSE|BZ2_RB_INTERNAL)) {
1280
- res = Qnil;
1281
- }
1282
- else {
1283
- res = bzf->io;
1416
+ res = Qnil;
1417
+ } else {
1418
+ res = bzf->io;
1284
1419
  }
1285
1420
  bzf->io = 0;
1286
1421
  return res;
1287
1422
  }
1288
1423
 
1289
- static VALUE
1290
- bz_reader_finish(obj)
1291
- VALUE obj;
1292
- {
1424
+ /*
1425
+ * Originally undocument and had no sepcs. Appears to call Bzip2::Reader#read
1426
+ * and then mark the stream as finished, but this didn't work for me...
1427
+ */
1428
+ static VALUE bz_reader_finish(VALUE obj) {
1293
1429
  struct bz_file *bzf;
1294
1430
 
1295
1431
  Get_BZ2(obj, bzf);
1296
1432
  if (bzf->buf) {
1297
- rb_funcall2(obj, id_read, 0, 0);
1298
- free(bzf->buf);
1433
+ rb_funcall2(obj, id_read, 0, 0);
1434
+ free(bzf->buf);
1299
1435
  }
1300
1436
  bzf->buf = 0;
1301
1437
  bzf->state = BZ_OK;
1302
1438
  return Qnil;
1303
1439
  }
1304
1440
 
1305
- static VALUE
1306
- bz_reader_close_bang(obj)
1307
- VALUE obj;
1308
- {
1441
+ /*
1442
+ * Originally undocument and had no sepcs. Appears to work nearly the same
1443
+ * as Bzip2::Reader#close...
1444
+ */
1445
+ static VALUE bz_reader_close_bang(VALUE obj) {
1309
1446
  struct bz_file *bzf;
1310
1447
  int closed;
1311
1448
 
@@ -1313,12 +1450,12 @@ bz_reader_close_bang(obj)
1313
1450
  closed = bzf->flags & (BZ2_RB_CLOSE|BZ2_RB_INTERNAL);
1314
1451
  bz_reader_close(obj);
1315
1452
  if (!closed && rb_respond_to(bzf->io, id_close)) {
1316
- if (rb_respond_to(bzf->io, id_closed)) {
1317
- closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
1318
- }
1319
- if (!closed) {
1320
- rb_funcall2(bzf->io, id_close, 0, 0);
1321
- }
1453
+ if (rb_respond_to(bzf->io, id_closed)) {
1454
+ closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
1455
+ }
1456
+ if (!closed) {
1457
+ rb_funcall2(bzf->io, id_close, 0, 0);
1458
+ }
1322
1459
  }
1323
1460
  return Qnil;
1324
1461
  }
@@ -1329,98 +1466,158 @@ struct foreach_arg {
1329
1466
  VALUE obj;
1330
1467
  };
1331
1468
 
1332
- static VALUE
1333
- bz_reader_foreach_line(arg)
1334
- struct foreach_arg *arg;
1335
- {
1469
+ static VALUE bz_reader_foreach_line(struct foreach_arg *arg) {
1336
1470
  VALUE str;
1337
1471
  int td[ASIZE], in;
1338
1472
 
1339
1473
  in = Qtrue;
1340
- while (!NIL_P(str = bz_reader_gets_internal(arg->argc, &arg->sep,
1341
- arg->obj, td, in))) {
1342
- in = Qfalse;
1343
- rb_yield(str);
1474
+ while (!NIL_P(str = bz_reader_gets_internal(arg->argc, &arg->sep, arg->obj, td, in))) {
1475
+ in = Qfalse;
1476
+ rb_yield(str);
1344
1477
  }
1345
1478
  return Qnil;
1346
1479
  }
1347
1480
 
1348
- static VALUE
1349
- bz_reader_s_foreach(argc, argv, obj)
1350
- int argc;
1351
- VALUE obj, *argv;
1352
- {
1481
+ /*
1482
+ * call-seq:
1483
+ * foreach(filename, &block)
1484
+ *
1485
+ * Reads a bz2 compressed file and yields each line to the block
1486
+ *
1487
+ * Bzip2::Writer.open('file'){ |f| f << "a\n" << "b\n" << "c\n\nd" }
1488
+ * Bzip2::Reader.foreach('file'){ |l| p l }
1489
+ *
1490
+ * # Output:
1491
+ * # "a\n"
1492
+ * # "b\n"
1493
+ * # "c\n"
1494
+ * # "\n"
1495
+ * # "d"
1496
+ *
1497
+ * @param [String] filename the path to the file to open
1498
+ * @yieldparam [String] each line of the file
1499
+ */
1500
+ static VALUE bz_reader_s_foreach(int argc, VALUE *argv, VALUE obj) {
1353
1501
  VALUE fname, sep;
1354
1502
  struct foreach_arg arg;
1355
1503
  struct bz_file *bzf;
1356
1504
 
1357
1505
  if (!rb_block_given_p()) {
1358
- rb_raise(rb_eArgError, "call out of a block");
1506
+ rb_raise(rb_eArgError, "call out of a block");
1359
1507
  }
1360
1508
  rb_scan_args(argc, argv, "11", &fname, &sep);
1509
+ #ifdef SafeStringValue
1510
+ SafeStringValue(fname);
1511
+ #else
1361
1512
  Check_SafeStr(fname);
1513
+ #endif
1362
1514
  arg.argc = argc - 1;
1363
1515
  arg.sep = sep;
1364
1516
  arg.obj = rb_funcall2(rb_mKernel, id_open, 1, &fname);
1365
- if (NIL_P(arg.obj)) return Qnil;
1517
+ if (NIL_P(arg.obj)) {
1518
+ return Qnil;
1519
+ }
1366
1520
  arg.obj = rb_funcall2(obj, id_new, 1, &arg.obj);
1367
1521
  Data_Get_Struct(arg.obj, struct bz_file, bzf);
1368
1522
  bzf->flags |= BZ2_RB_CLOSE;
1369
1523
  return rb_ensure(bz_reader_foreach_line, (VALUE)&arg, bz_reader_close, arg.obj);
1370
1524
  }
1371
1525
 
1372
- static VALUE
1373
- bz_reader_i_readlines(arg)
1374
- struct foreach_arg *arg;
1375
- {
1526
+ static VALUE bz_reader_i_readlines(struct foreach_arg *arg) {
1376
1527
  VALUE str, res;
1377
1528
  int td[ASIZE], in;
1378
1529
 
1379
1530
  in = Qtrue;
1380
1531
  res = rb_ary_new();
1381
- while (!NIL_P(str = bz_reader_gets_internal(arg->argc, &arg->sep,
1382
- arg->obj, td, in))) {
1383
- in = Qfalse;
1384
- rb_ary_push(res, str);
1532
+ while (!NIL_P(str = bz_reader_gets_internal(arg->argc, &arg->sep, arg->obj, td, in))) {
1533
+ in = Qfalse;
1534
+ rb_ary_push(res, str);
1385
1535
  }
1386
1536
  return res;
1387
1537
  }
1388
1538
 
1389
- static VALUE
1390
- bz_reader_s_readlines(argc, argv, obj)
1391
- int argc;
1392
- VALUE obj, *argv;
1393
- {
1539
+ /*
1540
+ * call-seq:
1541
+ * readlines(filename, separator="\n")
1542
+ *
1543
+ * Opens the given bz2 compressed file for reading and decompresses the file,
1544
+ * returning an array of the lines of the file. A line is denoted by the
1545
+ * separator argument.
1546
+ *
1547
+ * Bzip2::Writer.open('file'){ |f| f << "a\n" << "b\n" << "c\n\nd" }
1548
+ *
1549
+ * Bzip2::Reader.readlines('file') # => ["a\n", "b\n", "c\n", "\n", "d"]
1550
+ * Bzip2::Reader.readlines('file', 'c') # => ["a\nb\nc", "\n\nd"]
1551
+ *
1552
+ * @param [String] filename the path to the file to read
1553
+ * @param [String] separator the character to denote a newline in the file
1554
+ * @see Bzip2::Reader#readlines
1555
+ * @return [Array] an array of lines for the file
1556
+ * @raise [Bzip2::Error] if the file is not a valid bz2 compressed file
1557
+ */
1558
+ static VALUE bz_reader_s_readlines(int argc, VALUE *argv, VALUE obj) {
1394
1559
  VALUE fname, sep;
1395
1560
  struct foreach_arg arg;
1396
1561
  struct bz_file *bzf;
1397
1562
 
1398
1563
  rb_scan_args(argc, argv, "11", &fname, &sep);
1564
+ #ifdef SafeStringValue
1565
+ SafeStringValue(fname);
1566
+ #else
1399
1567
  Check_SafeStr(fname);
1568
+ #endif
1400
1569
  arg.argc = argc - 1;
1401
1570
  arg.sep = sep;
1402
1571
  arg.obj = rb_funcall2(rb_mKernel, id_open, 1, &fname);
1403
- if (NIL_P(arg.obj)) return Qnil;
1572
+ if (NIL_P(arg.obj)) {
1573
+ return Qnil;
1574
+ }
1404
1575
  arg.obj = rb_funcall2(obj, id_new, 1, &arg.obj);
1405
1576
  Data_Get_Struct(arg.obj, struct bz_file, bzf);
1406
1577
  bzf->flags |= BZ2_RB_CLOSE;
1407
1578
  return rb_ensure(bz_reader_i_readlines, (VALUE)&arg, bz_reader_close, arg.obj);
1408
1579
  }
1409
1580
 
1410
- static VALUE
1411
- bz_reader_lineno(obj)
1412
- VALUE obj;
1413
- {
1581
+ /*
1582
+ * Returns the current line number that the stream is at. This number is based
1583
+ * on the newline separator being "\n"
1584
+ *
1585
+ * reader = Bzip2::Reader.new Bzip2.compress("a\nb")
1586
+ * reader.lineno # => 0
1587
+ * reader.readline # => "a\n"
1588
+ * reader.lineno # => 1
1589
+ * reader.readline # => "b"
1590
+ * reader.lineno # => 2
1591
+
1592
+ * @return [Integer] the current line number
1593
+ */
1594
+ static VALUE bz_reader_lineno(VALUE obj) {
1414
1595
  struct bz_file *bzf;
1415
1596
 
1416
1597
  Get_BZ2(obj, bzf);
1417
1598
  return INT2NUM(bzf->lineno);
1418
1599
  }
1419
1600
 
1420
- static VALUE
1421
- bz_reader_set_lineno(obj, lineno)
1422
- VALUE obj, lineno;
1423
- {
1601
+ /*
1602
+ * call-seq:
1603
+ * lineno=(num)
1604
+ *
1605
+ * Sets the internal line number count that this stream should be set at
1606
+ *
1607
+ * reader = Bzip2::Reader.new Bzip2.compress("a\nb")
1608
+ * reader.lineno # => 0
1609
+ * reader.readline # => "a\n"
1610
+ * reader.lineno # => 1
1611
+ * reader.lineno = 0
1612
+ * reader.readline # => "b"
1613
+ * reader.lineno # => 1
1614
+ *
1615
+ * @note This does not actually rewind or move the stream forward
1616
+ * @param [Integer] lineno the line number which the stream should consider
1617
+ * being set at
1618
+ * @return [Integer] the line number provided
1619
+ */
1620
+ static VALUE bz_reader_set_lineno(VALUE obj, VALUE lineno) {
1424
1621
  struct bz_file *bzf;
1425
1622
 
1426
1623
  Get_BZ2(obj, bzf);
@@ -1428,121 +1625,111 @@ bz_reader_set_lineno(obj, lineno)
1428
1625
  return lineno;
1429
1626
  }
1430
1627
 
1431
- static VALUE
1432
- bz_to_io(obj)
1433
- VALUE obj;
1434
- {
1628
+ /*
1629
+ * Returns the io stream underlying this stream. If the strem was constructed
1630
+ * with a file, that is returned. Otherwise, an empty string is returned.
1631
+ *
1632
+ * @return [File, String] similar to whatever the stream was constructed with
1633
+ * @raise [IOError] if the stream has been closed
1634
+ */
1635
+ static VALUE bz_to_io(VALUE obj) {
1435
1636
  struct bz_file *bzf;
1436
1637
 
1437
1638
  Get_BZ2(obj, bzf);
1438
1639
  return bzf->io;
1439
1640
  }
1440
1641
 
1441
- static VALUE
1442
- bz_str_read(argc, argv, obj)
1443
- int argc;
1444
- VALUE obj, *argv;
1445
- {
1642
+ static VALUE bz_str_read(int argc, VALUE *argv, VALUE obj) {
1446
1643
  struct bz_str *bzs;
1447
1644
  VALUE res, len;
1448
1645
  int count;
1449
-
1646
+
1450
1647
  Data_Get_Struct(obj, struct bz_str, bzs);
1451
1648
  rb_scan_args(argc, argv, "01", &len);
1452
1649
  if (NIL_P(len)) {
1453
- count = RSTRING_LEN(bzs->str);
1454
- }
1455
- else {
1456
- count = NUM2INT(len);
1457
- if (count < 0) {
1458
- rb_raise(rb_eArgError, "negative length %d given", count);
1459
- }
1650
+ count = RSTRING_LEN(bzs->str);
1651
+ } else {
1652
+ count = NUM2INT(len);
1653
+ if (count < 0) {
1654
+ rb_raise(rb_eArgError, "negative length %d given", count);
1655
+ }
1460
1656
  }
1461
1657
  if (!count || bzs->pos == -1) {
1462
- return Qnil;
1658
+ return Qnil;
1463
1659
  }
1464
1660
  if ((bzs->pos + count) >= RSTRING_LEN(bzs->str)) {
1465
- res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos,
1466
- RSTRING_LEN(bzs->str) - bzs->pos);
1467
- bzs->pos = -1;
1468
- }
1469
- else {
1470
- res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, count);
1471
- bzs->pos += count;
1661
+ res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos,
1662
+ RSTRING_LEN(bzs->str) - bzs->pos);
1663
+ bzs->pos = -1;
1664
+ } else {
1665
+ res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, count);
1666
+ bzs->pos += count;
1472
1667
  }
1473
1668
  return res;
1474
1669
  }
1475
1670
 
1476
- static VALUE
1477
- bz_uncompress(argc, argv, obj)
1478
- int argc;
1479
- VALUE obj, *argv;
1480
- {
1671
+ /*
1672
+ * call-seq:
1673
+ * uncompress(data)
1674
+ * Decompress a string of bz2 compressed data.
1675
+ *
1676
+ * Bzip2.uncompress Bzip2.compress('asdf') # => 'asdf'
1677
+ *
1678
+ * @param [String] data bz2 compressed data
1679
+ * @return [String] +data+ as uncompressed bz2 data
1680
+ * @raise [Bzip2::Error] if +data+ is not valid bz2 data
1681
+ */
1682
+ static VALUE bz_uncompress(int argc, VALUE *argv, VALUE obj) {
1481
1683
  VALUE bz2, nilv = Qnil;
1482
1684
 
1483
1685
  if (!argc) {
1484
- rb_raise(rb_eArgError, "need a String to Uncompress");
1686
+ rb_raise(rb_eArgError, "need a String to Uncompress");
1485
1687
  }
1486
1688
  argv[0] = rb_str_to_str(argv[0]);
1487
1689
  bz2 = rb_funcall2(bz_cReader, id_new, argc, argv);
1488
1690
  return bz_reader_read(1, &nilv, bz2);
1489
1691
  }
1490
1692
 
1491
- static VALUE
1492
- bz_s_new(argc, argv, obj)
1493
- int argc;
1494
- VALUE obj, *argv;
1495
- {
1693
+ /*
1694
+ * Internally allocates data,
1695
+ *
1696
+ * @see Bzip2::Writer#initialize
1697
+ * @see Bzip2::Reader#initialize
1698
+ * @private
1699
+ */
1700
+ static VALUE bz_s_new(int argc, VALUE *argv, VALUE obj) {
1496
1701
  VALUE res = rb_funcall2(obj, rb_intern("allocate"), 0, 0);
1497
1702
  rb_obj_call_init(res, argc, argv);
1498
1703
  return res;
1499
1704
  }
1500
1705
 
1501
- static VALUE
1502
- bz_proc_new(func, val)
1503
- VALUE (*func)(ANYARGS);
1504
- VALUE val;
1505
- {
1506
- VALUE tmp = Data_Wrap_Struct(rb_cData, 0, 0, 0);
1507
- rb_define_singleton_method(tmp, "tmp_proc", func, 1);
1508
- return rb_funcall2(rb_funcall(tmp, rb_intern("method"), 1,
1509
- ID2SYM(rb_intern("tmp_proc"))),
1510
- rb_intern("to_proc"), 0, 0);
1511
- }
1512
-
1513
- void Init_bzip2_ext()
1514
- {
1706
+ void Init_bzip2_ext() {
1515
1707
  VALUE bz_mBzip2;
1516
1708
 
1517
- if (rb_const_defined_at(rb_cObject, rb_intern("Bzip2"))) {
1518
- rb_raise(rb_eNameError, "module already defined");
1519
- }
1520
-
1521
1709
  bz_internal_ary = rb_ary_new();
1522
1710
  rb_global_variable(&bz_internal_ary);
1523
- rb_funcall(rb_const_get(rb_cObject, rb_intern("ObjectSpace")),
1524
- rb_intern("define_finalizer"), 2, bz_internal_ary,
1525
- bz_proc_new(bz_internal_finalize, 0));
1526
-
1527
- id_new = rb_intern("new");
1528
- id_write = rb_intern("write");
1529
- id_open = rb_intern("open");
1530
- id_flush = rb_intern("flush");
1531
- id_read = rb_intern("read");
1532
- id_close = rb_intern("close");
1711
+ rb_set_end_proc(bz_internal_finalize, Qnil);
1712
+
1713
+ id_new = rb_intern("new");
1714
+ id_write = rb_intern("write");
1715
+ id_open = rb_intern("open");
1716
+ id_flush = rb_intern("flush");
1717
+ id_read = rb_intern("read");
1718
+ id_close = rb_intern("close");
1533
1719
  id_closed = rb_intern("closed?");
1534
- id_str = rb_intern("to_str");
1535
-
1536
- bz_mBzip2 = rb_define_module("Bzip2");
1537
- bz_eConfigError = rb_define_class_under(bz_mBzip2, "ConfigError", rb_eFatal);
1538
- bz_eError = rb_define_class_under(bz_mBzip2, "Error", rb_eIOError);
1539
- bz_eEOZError = rb_define_class_under(bz_mBzip2, "EOZError", bz_eError);
1540
-
1541
- rb_define_module_function(bz_mBzip2, "compress", bz_compress, -1);
1542
- rb_define_module_function(bz_mBzip2, "uncompress", bz_uncompress, -1);
1543
- rb_define_module_function(bz_mBzip2, "decompress", bz_uncompress, -1);
1544
- rb_define_module_function(bz_mBzip2, "bzip2", bz_compress, -1);
1545
- rb_define_module_function(bz_mBzip2, "bunzip2", bz_uncompress, -1);
1720
+ id_str = rb_intern("to_str");
1721
+
1722
+ bz_mBzip2 = rb_define_module("Bzip2");
1723
+ bz_eError = rb_define_class_under(bz_mBzip2, "Error", rb_eIOError);
1724
+ bz_eEOZError = rb_define_class_under(bz_mBzip2, "EOZError", bz_eError);
1725
+
1726
+ VALUE bz_mBzip2Singleton = rb_singleton_class(bz_mBzip2);
1727
+ rb_define_singleton_method(bz_mBzip2, "compress", bz_compress, -1);
1728
+ rb_define_singleton_method(bz_mBzip2, "uncompress", bz_uncompress, -1);
1729
+ rb_define_alias(bz_mBzip2Singleton, "bzip2", "compress");
1730
+ rb_define_alias(bz_mBzip2Singleton, "decompress", "uncompress");
1731
+ rb_define_alias(bz_mBzip2Singleton, "bunzip2", "uncompress");
1732
+
1546
1733
  /*
1547
1734
  Writer
1548
1735
  */
@@ -1551,7 +1738,7 @@ void Init_bzip2_ext()
1551
1738
  rb_define_alloc_func(bz_cWriter, bz_writer_s_alloc);
1552
1739
  #else
1553
1740
  rb_define_singleton_method(bz_cWriter, "allocate", bz_writer_s_alloc, 0);
1554
- #endif
1741
+ #endif
1555
1742
  rb_define_singleton_method(bz_cWriter, "new", bz_s_new, -1);
1556
1743
  rb_define_singleton_method(bz_cWriter, "open", bz_writer_s_open, -1);
1557
1744
  rb_define_method(bz_cWriter, "initialize", bz_writer_init, -1);
@@ -1562,10 +1749,11 @@ void Init_bzip2_ext()
1562
1749
  rb_define_method(bz_cWriter, "printf", rb_io_printf, -1);
1563
1750
  rb_define_method(bz_cWriter, "<<", rb_io_addstr, 1);
1564
1751
  rb_define_method(bz_cWriter, "flush", bz_writer_flush, 0);
1565
- rb_define_method(bz_cWriter, "finish", bz_writer_flush, 0);
1566
1752
  rb_define_method(bz_cWriter, "close", bz_writer_close, 0);
1567
1753
  rb_define_method(bz_cWriter, "close!", bz_writer_close_bang, 0);
1568
1754
  rb_define_method(bz_cWriter, "to_io", bz_to_io, 0);
1755
+ rb_define_alias(bz_cWriter, "finish", "flush");
1756
+
1569
1757
  /*
1570
1758
  Reader
1571
1759
  */
@@ -1592,20 +1780,21 @@ void Init_bzip2_ext()
1592
1780
  rb_define_method(bz_cReader, "readline", bz_reader_readline, -1);
1593
1781
  rb_define_method(bz_cReader, "readlines", bz_reader_readlines, -1);
1594
1782
  rb_define_method(bz_cReader, "each", bz_reader_each_line, -1);
1595
- rb_define_method(bz_cReader, "each_line", bz_reader_each_line, -1);
1596
1783
  rb_define_method(bz_cReader, "each_byte", bz_reader_each_byte, 0);
1597
1784
  rb_define_method(bz_cReader, "close", bz_reader_close, 0);
1598
1785
  rb_define_method(bz_cReader, "close!", bz_reader_close_bang, 0);
1599
1786
  rb_define_method(bz_cReader, "finish", bz_reader_finish, 0);
1600
- rb_define_method(bz_cReader, "closed", bz_reader_closed, 0);
1601
1787
  rb_define_method(bz_cReader, "closed?", bz_reader_closed, 0);
1602
1788
  rb_define_method(bz_cReader, "eoz?", bz_reader_eoz, 0);
1603
- rb_define_method(bz_cReader, "eoz", bz_reader_eoz, 0);
1604
1789
  rb_define_method(bz_cReader, "eof?", bz_reader_eof, 0);
1605
- rb_define_method(bz_cReader, "eof", bz_reader_eof, 0);
1606
1790
  rb_define_method(bz_cReader, "lineno", bz_reader_lineno, 0);
1607
1791
  rb_define_method(bz_cReader, "lineno=", bz_reader_set_lineno, 1);
1608
1792
  rb_define_method(bz_cReader, "to_io", bz_to_io, 0);
1793
+ rb_define_alias(bz_cReader, "each_line", "each");
1794
+ rb_define_alias(bz_cReader, "closed", "closed?");
1795
+ rb_define_alias(bz_cReader, "eoz", "eoz?");
1796
+ rb_define_alias(bz_cReader, "eof", "eof?");
1797
+
1609
1798
  /*
1610
1799
  Internal
1611
1800
  */