bzip2-ruby-rb20 0.2.7

data/ext/bzip2/writer.h

@@ -0,0 +1,22 @@
+#ifndef _RB_BZIP2_WRITER_H_
+#define _RB_BZIP2_WRITER_H_
+
+#include <ruby.h>
+#include "common.h"
+
+int bz_writer_internal_flush(struct bz_file *bzf);
+
+/* Instance methods */
+VALUE bz_writer_close(VALUE obj);
+VALUE bz_writer_close_bang(VALUE obj);
+VALUE bz_writer_closed(VALUE obj);
+VALUE bz_writer_flush(VALUE obj);
+VALUE bz_writer_init(int argc, VALUE *argv, VALUE obj);
+VALUE bz_writer_write(VALUE obj, VALUE a);
+VALUE bz_writer_putc(VALUE obj, VALUE a);
+
+/* Class methods */
+VALUE bz_writer_s_alloc(VALUE obj);
+VALUE bz_writer_s_open(int argc, VALUE *argv, VALUE obj);
+
+#endif

data/lib/bzip2.rb

@@ -0,0 +1,13 @@
+require 'bzip2/bzip2'
+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
+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,64 @@
+# 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
+    alias :closed :closed?
+
+    # 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

@@ -0,0 +1,261 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Bzip2::Writer do
+  before(:each) do
+    @file = "_10lines_"
+    @data = [
+      "00: This is a line\n",
+      "01: This is a line\n",
+      "02: This is a line\n",
+      "03: This is a line\n",
+      "04: This is a line\n",
+      "05: This is a line\n",
+      "06: This is a line\n",
+      "07: This is a line\n",
+      "08: 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(:each) do
+    File.delete(@file) if File.exists?(@file)
+  end
+
+  it "iterate over each line of the file via the foreach method" do
+    lines = []
+    Bzip2::Reader.foreach(@file){ |line| lines << line }
+    lines.should == @data
+
+    lines.clear
+    Bzip2::Reader.foreach(@file, nil) do |file|
+      file.split(/\n/).each{ |line| lines << line + "\n" }
+    end
+    lines.should == @data
+
+    count = 0
+    Bzip2::Reader.foreach(@file, ' ') do |thing|
+      count += 1
+    end
+    count.should == 41
+  end
+
+  it "returns an array of the lines read via #readlines" do
+    lines = Bzip2::Reader.readlines(@file)
+    lines.should == @data
+
+    lines = Bzip2::Reader.readlines(@file, nil)
+    lines.should == [@data.join]
+  end
+
+  it "track when the stream has been closed" do
+    f = Bzip2::Reader.open(@file)
+    f.should_not be_closed
+    f.close
+    f.should be_closed
+  end
+
+  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
+
+      Bzip2::Reader.open(@file) do |file|
+        file.send(method, nil) do |contents|
+          contents.should == @data.join
+        end
+      end
+
+      count = 0
+      Bzip2::Reader.open(@file) do |file|
+        file.send(method, ' ') do |thing|
+          count += 1
+        end
+      end
+      41.should == count
+    end
+  end
+
+  it_should_behave_like 'a line iterator', :each
+  it_should_behave_like 'a line iterator', :each_line
+
+  it "iterates over the decompressed bytes via #each_byte" do
+    bytes = @data.join.bytes.to_a
+
+    Bzip2::Reader.open(@file) do |file|
+      file.each_byte do |b|
+        b.should == bytes.shift
+      end
+    end
+
+    bytes.size.should == 0
+  end
+
+  it "keeps track of when eof has been reached" do
+    Bzip2::Reader.open(@file) do |file|
+      @data.size.times do
+        file.should_not be_eof
+        file.gets
+      end
+
+      file.should be_eof
+    end
+  end
+
+  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
+        ch.should == bytes.shift
+      end
+
+      file.getc.should be_nil
+    end
+
+    bytes.size.should == 0
+  end
+
+  it "reads an entire line via gets" do
+    Bzip2::Reader.open(@file) do |file|
+      lines = []
+      while line = file.gets
+        lines << line
+      end
+      lines.should == @data
+
+      file.gets.should be_nil
+    end
+
+    Bzip2::Reader.open(@file) do |file|
+      lines = []
+      while line = file.gets("line\n")
+        lines << line
+      end
+      lines.should == @data
+
+      file.gets.should be_nil
+    end
+
+    lines = ''
+    Bzip2::Reader.open(@file) do |file|
+      while contents = file.gets(nil)
+        lines << contents
+      end
+    end
+    lines.should == @data.join
+
+    count = 0
+    Bzip2::Reader.open(@file) do |file|
+      count += 1 while file.gets(' ')
+    end
+    41.should == count
+  end
+
+  it "reads the entire file or a specified length when using #read" do
+    Bzip2::Reader.open(@file) do |file|
+      file.read.should == @data.join
+    end
+
+    Bzip2::Reader.open(@file) do |file|
+      file.read(12).should == "00: This is "
+      file.read(12).should == "a line\n01: T"
+    end
+  end
+
+  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|
+      @data.join.bytes do |byte|
+        file.readchar.should == byte
+      end
+
+      lambda { file.readchar }.should raise_error(Bzip2::EOZError)
+    end
+  end
+
+  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|
+        lines << file.readline
+      end
+
+      lines.should == @data
+      lambda { file.readline }.should raise_error(Bzip2::EOZError)
+    end
+
+    Bzip2::Reader.open(@file) do |file|
+      file.readline(nil).should == @data.join
+
+      lambda { file.readline }.should raise_error(Bzip2::EOZError)
+    end
+
+    Bzip2::Reader.open(@file) do |file|
+      41.times { |count| file.readline(' ') }
+      lambda { file.readline }.should raise_error(Bzip2::EOZError)
+    end
+  end
+
+  it "returns an array of lines in the file" do
+    Bzip2::Reader.open(@file) do |file|
+      file.readlines.should == @data
+    end
+
+    Bzip2::Reader.open(@file) do |file|
+      file.readlines(nil).should == [@data.join]
+    end
+  end
+
+  it "rewinds the stream when #ungetc is called and returns that byte next" do
+    Bzip2::Reader.open(@file) do |file|
+      '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 "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
+  end
+
+  it "reads entire lines via readline and throws an exception when there is" do
+    string = File.read(@file)
+    file = Bzip2::Reader.new(string)
+    lines = []
+    @data.size.times do |count|
+      lines << file.readline
+    end
+    lines.should == @data
+    lambda { file.readline }.should raise_error(Bzip2::EOZError)
+    file.close
+
+    file = Bzip2::Reader.new(string)
+    file.readline(nil).should == @data.join
+    lambda { file.readline }.should raise_error(Bzip2::EOZError)
+    file.close
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+require 'bundler/setup'
+
+require 'rspec/core'
+require 'bzip2'
+
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+# back-port 1.9 method so the tests will pass in 1.8 as well
+if RUBY_VERSION.include?("1.8")
+  class String
+    def getbyte(idx)
+      self[idx]
+    end
+  end
+end

data/spec/writer_spec.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Bzip2::Writer do
+  let(:file){ File.expand_path('../_10lines_', __FILE__) }
+
+  class Dummy
+    def to_s
+      "dummy"
+    end
+  end
+
+  after(:each) do
+    File.delete(file) if File.exists?(file)
+  end
+
+  it "performs like IO#<< when using the #<< method" do
+    Bzip2::Writer.open(file, "w") do |file|
+      file << 1 << "\n" << Dummy.new << "\n" << "cat\n"
+    end
+    expected = [ "1\n", "dummy\n", "cat\n"]
+    actual   = []
+    Bzip2::Reader.foreach(file){ |line| actual.push line }
+    actual.should == expected
+  end
+
+  it "doesn't immediately flush the data when written to" do
+    io = File.new(file, "w")
+    bz2 = Bzip2::Writer.new(io)
+    bz2 << 1 << "\n" << Dummy.new << "\n" << "cat\n"
+    bz = Bzip2::Reader.new(file)
+    lambda { bz.gets }.should raise_error(Bzip2::Error)
+    bz = Bzip2::Reader.open(file)
+    lambda { bz.gets }.should raise_error(Bzip2::Error)
+    io.close
+    lambda { Bzip2::Reader.new(io) }.should raise_error(IOError)
+  end
+
+  it "behaves the same as IO#print when using #print" do
+    Bzip2::Writer.open(file) do |file|
+      file.print "foo\n" * 4096, "\n" * 4096,
+                 "bar" * 4096, "\n" * 4096, "zot\n" * 1024
+    end
+
+    Bzip2::Reader.open(file) do |file|
+      file.gets('').should == "foo\n" * 4096 + "\n"
+      file.gets('').should == "bar" * 4096 + "\n\n"
+      file.gets('').should == "zot\n" * 1024
+    end
+  end
+
+  it "respects specific global variables like IO#print does via #print" do
+    Bzip2::Writer.open(file) do |file|
+      file.print "hello"
+      file.print 1,2
+      $_ = "wombat\n"
+      file.print
+      $\ = ":"
+      $, = ","
+      file.print 3, 4
+      file.print 5, 6
+      $\ = nil
+      file.print "\n"
+      $, = nil
+    end
+
+    Bzip2::Reader.open(file) do |file|
+      file.gets(nil).should == "hello12wombat\n3,4:5,6:\n"
+    end
+  end
+
+  it "only writes one byte via the #putc method" do
+    Bzip2::Writer.open(file, "wb") do |file|
+      file.putc "A"
+      0.upto(255) { |ch| file.putc ch }
+    end
+
+    Bzip2::Reader.open(file, "rb") do |file|
+      file.getc.should == 'A'.bytes.first
+      0.upto(255) { |ch| file.getc.should == ch }
+    end
+  end
+
+  it "behaves the same as IO#puts when using #puts" do
+    Bzip2::Writer.open(file, "w") do |file|
+      file.puts "line 1", "line 2"
+      file.puts [ Dummy.new, 4 ]
+    end
+
+    Bzip2::Reader.open(file) do |file|
+      file.gets.should == "line 1\n"
+      file.gets.should == "line 2\n"
+      file.gets.should == "dummy\n"
+      file.gets.should == "4\n"
+    end
+  end
+
+  it "writes data successfully to a file and returns the length of the data" do
+    Bzip2::Writer.open(file, "w") do |file|
+      file.write('*' * 10).should == 10
+      file.write('!' * 5).should == 5
+      file.write('').should == 0
+      file.write(1).should == 1
+      file.write(2.30000).should == 3
+      file.write("\n").should == 1
+    end
+
+    Bzip2::Reader.open(file) do |file|
+      file.gets.should == "**********!!!!!12.3\n"
+    end
+  end
+
+  it "returns the compressed data when no constructor argument is specified" do
+    file = Bzip2::Writer.new
+    file << ('*' * 10) << ('!' * 5) << '' << 1 << 2.3000 << "\n"
+    Bzip2::bunzip2(file.flush).should == "**********!!!!!12.3\n"
+  end
+
+  it "compresses data via the #bzip2 shortcut" do
+    data = ["**********!!!!!12.3\n"]
+    data << "foo\n"*4096 + "\n"*4096 + "bar"*4096 + "\n"*4096 + "zot\n"*1024
+
+    data.each do |test|
+      Bzip2::bunzip2(Bzip2::bzip2(test)).should == test
+    end
+  end
+
+  it "correctly reports when a writer is closed" do
+    writer = Bzip2::Writer.open(file, 'w')
+    writer.should_not be_closed
+    writer.close
+    writer.should be_closed
+  end
+end