bzip2-ruby 0.2.6 → 0.2.7

data/ext/extconf.rb

@@ -3,6 +3,9 @@ require 'mkmf'
 dir_config('bz2')
 have_header('bzlib.h')
 
+$CFLAGS << ' -Wall -funroll-loops '
+# $CFLAGS << ' -O0 -ggdb -Wextra'
+
 if have_library("bz2", "BZ2_bzWriteOpen")
   if enable_config("shared", true)
      $static = nil
@@ -12,7 +15,7 @@ if have_library("bz2", "BZ2_bzWriteOpen")
     $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
   end
   
-  create_makefile("bzip2_ext")
+  create_makefile('bzip2_ext')
 else
   puts "libbz2 not found, maybe try manually specifying --with-bz2-dir to find it?"
 end

data/lib/bzip2-ruby.rb

@@ -0,0 +1 @@
+require 'bzip2'

data/lib/bzip2.rb

@@ -1,5 +1,13 @@
 require 'bzip2_ext'
+require 'bzip2/version'
 
+# This is the base module for the +bzip2-ruby+ gem. Beneath it are the classes
+# for writing and reading data from bzip2 compressed and uncompressed streams.
+#
+# For example usage, see the Bzip2::Reader or Bzip2::Writer or the
+# {README}[link:docs/file/README.rdoc]
+#
+# @see Bzip2::Writer
+# @see Bzip2::Reader
 module Bzip2
-  VERSION = "0.2.6"
-end
+end

data/lib/bzip2/internals.rb

@@ -0,0 +1,13 @@
+# This file is mostly here for documentation purposes, do not require this
+
+module Bzip2
+  class << self
+    alias :bzip2 :compress
+    alias :bunzip2 :uncompress
+    alias :decompress :uncompress
+  end
+
+  # @private
+  class InternalStr
+  end
+end

data/lib/bzip2/reader.rb

@@ -0,0 +1,27 @@
+# This file is mostly here for documentation purposes, do not require this
+
+#
+module Bzip2
+  # Bzip2::Reader is meant to read streams of bz2 compressed bytes. It behaves
+  # like an IO object with many similar methods. It also includes the Enumerable
+  # module and each element is a 'line' in the stream.
+  #
+  # It can both decompress files:
+  #
+  #     reader = Bzip2::Reader.open('file')
+  #     puts reader.read
+  #
+  #     reader = Bzip2::Reader.new File.open('file')
+  #     put reader.gets
+  #
+  # And it may just decompress raw strings
+  #
+  #     reader = Bzip2::Reader.new compressed_string
+  #     reader = Bzip2::Reader.new Bzip2.compress('compress-me')
+  class Reader
+    alias :each_line :each
+    alias :closed :closed?
+    alias :eoz :eoz?
+    alias :eof :eof?
+  end
+end

data/lib/bzip2/version.rb

@@ -0,0 +1,3 @@
+module Bzip2
+  VERSION = "0.2.7"
+end

data/lib/bzip2/writer.rb

@@ -0,0 +1,63 @@
+# This file is mostly here for documentation purposes, do not require this
+
+#
+module Bzip2
+  # A Bzip2::Writer represents a stream which compresses data written to it.
+  # It can be constructed with another IO object (a File) which data can be
+  # written to. Otherwise, data is all stored internally as a string and can
+  # be retrieved via the Bzip2::Writer#flush method
+  #
+  # It can both write to files:
+  #
+  #     writer = Bzip2::Writer.open('file')
+  #     writer << data
+  #     writer.close
+  #
+  #     Bzip2::Writer.open('file'){ |f| f << data }
+  #
+  #     writer = Bzip2::Writer.new File.open('file')
+  #
+  # And output data as a string
+  #
+  #     writer = Bzip2::Writer.new
+  #     writer << data
+  #     writer.flush # => data compressed via bz2
+  #
+  # @see Bzip2::Writer#initialize The initialize method for examples
+  class Writer
+
+    alias :finish :flush
+
+    # Append some data to this buffer, returning the buffer so this method can
+    # be chained
+    #
+    #   writer = Bzip2::Writer.new
+    #   writer << 'asdf' << 1 << obj << 'a'
+    #   writer.flush
+    #
+    # @param [#to_s] data anything responding to #to_s
+    # @see IO#<<
+    def << data
+    end
+
+    # Adds a number of strings to this buffer. A newline is also inserted into
+    # the buffer after each object
+    # @see IO#puts
+    def puts *objs
+    end
+
+    # Similar to Bzip2::Writer#puts except a newline is not appended after each
+    # object appended to this buffer
+    #
+    # @see IO#print
+    def print *objs
+    end
+
+    # Prints data to this buffer with the specified format.
+    #
+    # @see Kernel#sprintf
+    def printf format, *ojbs
+    end
+
+  end
+end

data/spec/reader_spec.rb

@@ -1,9 +1,8 @@
 # encoding: UTF-8
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
+require 'spec_helper'
 
-describe "Bzip2::Writer" do
-  before(:all) do
-    @sample = "08: This is a line\n"
+describe Bzip2::Writer do
+  before(:each) do
     @file = "_10lines_"
     @data = [
       "00: This is a line\n",
@@ -15,343 +14,248 @@ describe "Bzip2::Writer" do
       "06: This is a line\n",
       "07: This is a line\n",
       "08: This is a line\n",
-      "09: This is a line\n" 
+      "09: This is a line\n"
     ]
 
     open("|bzip2 > #{@file}", "w") do |f|
       @data.each { |l| f.puts l }
     end
   end
-  
-  after(:all) do
-    File.unlink(@file)
+
+  after(:each) do
+    File.delete(@file) if File.exists?(@file)
   end
 
-  it "should test_f_s_foreach" do
-    count = 0
-    Bzip2::Reader.foreach(@file) do |line|
-      num = line[0..1].to_i
-      count.should == num
-      count += 1
-    end
-    @data.size.should == count
+  it "iterate over each line of the file via the foreach method" do
+    lines = []
+    Bzip2::Reader.foreach(@file){ |line| lines << line }
+    lines.should == @data
 
-    count = 0
+    lines.clear
     Bzip2::Reader.foreach(@file, nil) do |file|
-      file.split(/\n/).each do |line|
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
-      end
+      file.split(/\n/).each{ |line| lines << line + "\n" }
     end
-    @data.size.should == count
+    lines.should == @data
 
     count = 0
     Bzip2::Reader.foreach(@file, ' ') do |thing|
       count += 1
     end
-    41.should == count
+    count.should == 41
   end
-  
-  it "should test_f_s_readlines" do
+
+  it "returns an array of the lines read via #readlines" do
     lines = Bzip2::Reader.readlines(@file)
-    @data.size.should == lines.size
+    lines.should == @data
 
     lines = Bzip2::Reader.readlines(@file, nil)
-    1.should == lines.size
-    (@sample.length * @data.size).should == lines[0].size
+    lines.should == [@data.join]
   end
 
-  it "should test_f_closed?" do
+  it "track when the stream has been closed" do
     f = Bzip2::Reader.open(@file)
-    f.closed?.should be_false
+    f.should_not be_closed
     f.close
-    f.closed?.should be_true
+    f.should be_closed
   end
 
-  it "should test_f_each" do
-    count = 0
-    Bzip2::Reader.open(@file) do |file|
-      file.each do |line|
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
+  shared_examples_for 'a line iterator' do |method|
+    it "iterates over the lines when using #each" do
+      Bzip2::Reader.open(@file) do |file|
+        list = []
+        file.send(method){ |l| list << l }
+        list.should == @data
       end
-      @data.size.should == count
-    end
 
-    count = 0
-    Bzip2::Reader.open(@file) do |file|
-      file.each(nil) do |contents|
-        contents.split(/\n/).each do |line|
-          num = line[0..1].to_i
-          count.should == num
-          count += 1
+      Bzip2::Reader.open(@file) do |file|
+        file.send(method, nil) do |contents|
+          contents.should == @data.join
         end
       end
-    end
-    @data.size.should == count
 
-    count = 0
-    Bzip2::Reader.open(@file) do |file|
-      file.each(' ') do |thing|
-        count += 1
+      count = 0
+      Bzip2::Reader.open(@file) do |file|
+        file.send(method, ' ') do |thing|
+          count += 1
+        end
       end
+      41.should == count
     end
-    41.should == count
   end
 
-  it "should test_f_each_byte" do
-    count = 0
-    data = @data.join
+  it_should_behave_like 'a line iterator', :each
+  it_should_behave_like 'a line iterator', :each_line
 
-    Bzip2::Reader.open(@file) do |file|
-      file.each_byte do |b|
-        data.getbyte(count).should == b
-        count += 1
-      end
-    end
-    (@sample.length * @data.size).should == count
-  end
+  it "iterates over the decompressed bytes via #each_byte" do
+    bytes = @data.join.bytes.to_a
 
-  it "should test_f_each_line" do
-    count = 0
     Bzip2::Reader.open(@file) do |file|
-      file.each_line do |line|
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
-      end
-      @data.size.should == count
-    end
-
-    count = 0
-    Bzip2::Reader.open(@file) do |file|
-      file.each_line(nil) do |contents|
-        contents.split(/\n/).each do |line|
-          num = line[0..1].to_i
-          count.should == num
-          count += 1
-        end
+      file.each_byte do |b|
+        b.should == bytes.shift
       end
     end
-    @data.size.should == count
 
-    count = 0
-    Bzip2::Reader.open(@file) do |file|
-      file.each_line(' ') do |thing|
-        count += 1
-      end
-    end
-    41.should == count
+    bytes.size.should == 0
   end
 
-  it "should test_f_eof" do
+  it "keeps track of when eof has been reached" do
     Bzip2::Reader.open(@file) do |file|
       @data.size.times do
-        (!file.eof).should be_true
-        (!file.eof?).should be_true
+        file.should_not be_eof
         file.gets
       end
-      file.eof.should be_true
-      file.eof?.should be_true
+
+      file.should be_eof
     end
   end
 
-  it "should test_f_getc" do
-    count = 0
-    data = @data.join
+  it "gets only one byte at a time via getc and doesn't raise an exception" do
+    bytes = @data.join.bytes.to_a
 
     Bzip2::Reader.open(@file) do |file|
-      while (ch = file.getc)
-        data.getbyte(count).should == ch
-        count += 1
+      while ch = file.getc
+        ch.should == bytes.shift
       end
+
       file.getc.should be_nil
     end
-    (@sample.length * @data.size).should == count
+
+    bytes.size.should == 0
   end
 
-  it "should test_f_gets" do
-    count = 0
+  it "reads an entire line via gets" do
     Bzip2::Reader.open(@file) do |file|
-      while (line = file.gets)
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
+      lines = []
+      while line = file.gets
+        lines << line
       end
+      lines.should == @data
+
       file.gets.should be_nil
-      @data.size.should == count
     end
 
-    count = 0
     Bzip2::Reader.open(@file) do |file|
-      while (line = file.gets("line\n"))
-        @data[count].should == line
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
+      lines = []
+      while line = file.gets("line\n")
+        lines << line
       end
+      lines.should == @data
+
       file.gets.should be_nil
-      @data.size.should == count
     end
 
-    count = 0
+    lines = ''
     Bzip2::Reader.open(@file) do |file|
-      while (contents = file.gets(nil))
-        contents.split(/\n/).each do |line|
-          num = line[0..1].to_i
-          count.should == num
-          count += 1
-        end
+      while contents = file.gets(nil)
+        lines << contents
       end
     end
-    @data.size.should == count
+    lines.should == @data.join
 
     count = 0
     Bzip2::Reader.open(@file) do |file|
-      while (thing = file.gets(' '))
-        count += 1
-      end
+      count += 1 while file.gets(' ')
     end
     41.should == count
   end
 
-  it "should test_f_read" do
+  it "reads the entire file or a specified length when using #read" do
     Bzip2::Reader.open(@file) do |file|
-      content = file.read
-      (@sample.length * @data.size).should == content.length
-      count = 0
-      content.split(/\n/).each do |line|
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
-      end
+      file.read.should == @data.join
     end
 
     Bzip2::Reader.open(@file) do |file|
-      "00: This is ".should == file.read(12)
-      "a line\n01: T".should == file.read(12)
+      file.read(12).should == "00: This is "
+      file.read(12).should == "a line\n01: T"
     end
   end
 
-  it "should test_f_readchar" do
+  it "reads one character and returns the byte value of the character read" do
     count = 0
     data = @data.join
     Bzip2::Reader.open(@file) do |file|
-      190.times do |count|
-        ch = file.readchar
-        data.getbyte(count).should == ch
-        count += 1
+      @data.join.bytes do |byte|
+        file.readchar.should == byte
       end
+
       lambda { file.readchar }.should raise_error(Bzip2::EOZError)
     end
   end
 
-  it "should test_f_readline" do
+  it "reads one line at a time and raises and exception when no more" do
     count = 0
     Bzip2::Reader.open(@file) do |file|
+      lines = []
       @data.size.times do |count|
-        line = file.readline
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
+        lines << file.readline
       end
+
+      lines.should == @data
       lambda { file.readline }.should raise_error(Bzip2::EOZError)
     end
 
-    count = 0
     Bzip2::Reader.open(@file) do |file|
-      contents = file.readline(nil)
-      contents.split(/\n/).each do |line|
-        num = line[0..1].to_i
-        count.should == num
-        count += 1
-      end
+      file.readline(nil).should == @data.join
+
       lambda { file.readline }.should raise_error(Bzip2::EOZError)
     end
-    @data.size.should == count
 
-    count = 0
     Bzip2::Reader.open(@file) do |file|
-      41.times do |count|
-        thing = file.readline(' ')
-        count += 1
-      end
+      41.times { |count| file.readline(' ') }
       lambda { file.readline }.should raise_error(Bzip2::EOZError)
     end
   end
 
-  it "should test_f_readlines" do
+  it "returns an array of lines in the file" do
     Bzip2::Reader.open(@file) do |file|
-      lines = file.readlines
-      @data.size.should == lines.size
+      file.readlines.should == @data
     end
 
     Bzip2::Reader.open(@file) do |file|
-      lines = file.readlines(nil)
-      1.should == lines.size
-      (@sample.length * @data.size).should == lines[0].size
+      file.readlines(nil).should == [@data.join]
     end
   end
 
-  # it "should test_f_ungetc" do
-  #   Bzip2::Reader.open(@file) do |file|
-  #     ?0.getbyte(0).should == file.getc
-  #     ?0.getbyte(0).should == file.getc
-  #     ?:.getbyte(0).should == file.getc
-  #     ?\s.getbyte(0).should == file.getc
-  #     file.ungetc(?:.to_i).should be_nil
-  #     ?:.getbyte(0).should == file.getc
-  #     1 while file.getc
-  #     file.ungetc(?A).should be_nil
-  #     ?A.should == file.getc
-  #   end
-  # end
-
-  it "should test_f_ungets" do
-    count = 0
+  it "rewinds the stream when #ungetc is called and returns that byte next" do
     Bzip2::Reader.open(@file) do |file|
-      @data[count].should == file.gets
-      (count + 1).should == file.lineno
-      file.ungets(@data[count]).should be_nil
-      @data[count].should == file.gets
-      count += 1
+      '0'.bytes.first.should == file.getc
+      '0'.bytes.first.should == file.getc
+      ':'.bytes.first.should == file.getc
+      ' '.bytes.first.should == file.getc
+
+      file.ungetc(':'.bytes.first).should be_nil
+      ':'.bytes.first.should == file.getc
+
+      file.read
+
+      file.ungetc('A'.bytes.first).should be_nil
+      'A'.bytes.first.should == file.getc
     end
   end
 
-  it "should test_s_readline" do
-    count = 0
-    string = IO.readlines(@file, nil)[0]
-    file = Bzip2::Reader.new(string)
-    @data.size.times do |count|
-      line = file.readline
-      num = line[0..1].to_i
-      count.should == num
-      count += 1
+  it "rewinds the stream when #ungets is called" do
+    Bzip2::Reader.open(@file) do |file|
+      @data[0].should == file.gets
+      1.should == file.lineno
+      file.ungets(@data[0]).should be_nil
+      @data[0].should == file.gets
     end
-    lambda { file.readline }.should raise_error(Bzip2::EOZError)
-    file.close
+  end
 
-    count = 0
+  it "reads entire lines via readline and throws an exception when there is" do
+    string = File.read(@file)
     file = Bzip2::Reader.new(string)
-    contents = file.readline(nil)
-    contents.split(/\n/).each do |line|
-      num = line[0..1].to_i
-      count.should == num
-      count += 1
+    lines = []
+    @data.size.times do |count|
+      lines << file.readline
     end
+    lines.should == @data
     lambda { file.readline }.should raise_error(Bzip2::EOZError)
-    @data.size.should == count
     file.close
 
-    count = 0
     file = Bzip2::Reader.new(string)
-    41.times do |count|
-      thing = file.readline(' ')
-      count += 1
-    end
+    file.readline(nil).should == @data.join
     lambda { file.readline }.should raise_error(Bzip2::EOZError)
     file.close
   end
-end
+end