Untitled

bz2 is an extension to use libbzip2 from ruby

### Module function

`bzip2(str, blocks = 9, work = 0)`
`compress(str, blocks = 9, work = 0)`

  Compress the String str

  blocks specifies the block size to be used for compression. It should be a value between 1 and 9 inclusive, and the actual block size used is 100000 x this value

  work controls how the compression phase behaves when presented with worst case, highly repetitive, input data.

  You should set this parameter carefully; too low, and many inputs will be handled by the fallback algorithm and so compress rather slowly, too high, and your average-to-worst case compression times can become very large.

  Allowable values range from 0 to 250 inclusive. 0 is a special case, equivalent to using the default value of 30.

  The default value of 30 gives reasonable behaviour over a wide range of circumstances.

`bunzip2(str, small = Qfalse)`
`uncompress(str, small = Qfalse)`

  Uncompress the String str

  If small is true, the library will use an alternative decompression algorithm which uses less memory but at the cost of decompressing more slowly

## BZ2::Writer

### Class methods

`allocate`
  allocate a new BZ2::Writer
`new(object = nil, mode = "w", blocks = 9, work = 0)`

  Create a new BZ2::Writer associated with object.

  object must respond to write, or must be nil in this case the compressed string is returned when flush is called

  See initialize for blocks and work

`open(filename, mode = "w", blocks = 9, work = 0) {|bz2| ... }`

  Call Kernel#open(filename), associate it a new BZ2::Writer and call the associated block if given.

  The bz2 object is closed at the end of the block

  See initialize for blocks and work

### Methods

`close`
  Terminate the compression.
`close!`
  Terminate the compression and close the associated object
`finish`
`flush`
  Flush the data and terminate the compression, the object can be re-used to store another compressed string
`initialize(object = nil, blocks = 9, work = 0)`

  If object is nil then the compression will be made in a String which is returned when close or flush is called

  Otherwise object must respond to write(str)

  blocks specifies the block size to be used for compression. It should be a value between 1 and 9 inclusive, and the actual block size used is 100000 x this value

  work controls how the compression phase behaves when presented with worst case, highly repetitive, input data.

  You should set this parameter carefully; too low, and many inputs will be handled by the fallback algorithm and so compress rather slowly, too high, and your average-to-worst case compression times can become very large.

  Allowable values range from 0 to 250 inclusive. 0 is a special case, equivalent to using the default value of 30.

  The default value of 30 gives reasonable behaviour over a wide range of circumstances.

`<<(object)`
  Writes object. object will be converted to a string using to_s
`print(object = $_, ...)`
  Writes the given object(s)
`printf(format, object = $_, ...)`
  Formats and writes the given object(s)
`putc(char)`
  Writes the given character
`puts(object, ...)`
  Writes the given objects
`to_io`
  return the associated object
`write(str)`
  Write the string str

## BZ2::Reader

    Included modules : Enumerable

### Class methods

`allocate`
  allocate a new BZ2::Reader
`foreach(filename, separator = $/) {|line| ... }`
  Uncompress the file and call the block for each line, where lines are separated by separator
`new(object, small = false)`

  Associate a new bz2 reader with object. object must respond to read

  See initialize for small

`open(filename, small = false) {|bz2| ... }`

  Call Kernel#open(filename), and associate it a new BZ2::Reader. The bz2 object is passed as an argument to the block.

  The object is closed at the end of the block

  See initialize for small

`readlines(filename, separator = $/)`
  Uncompress the file and reads the entire file as individual lines, and returns those lines in an array. Lines are separated by separator

### Methods

`initialize(object, small = false)`

  object must be a String which contains compressed data, or an object which respond to read(size)

  If small is true, the library will use an alternative decompression algorithm which uses less memory but at the cost of decompressing more slowly

`close`
  Terminate the uncompression and close the bz2
`close!`
  Terminate the uncompression, close the bz2 and the associated object
`closed?`
  Return true if the file is closed
`each(separator = $/) {|line| ... }`
`each_line(separator = $/) {|line| ... }`
  Execute the block for each line, where lines are separated by the optional separator
`eof`
  Return true at end of file
`eoz`
  "End Of Zip". Return true at the end of the zip component
`finish`
  Terminate the uncompression of the current zip component, and keep the bz2 active (to read another zip component)
`getc`
  Get the next 8-bit byte (0..255). Returns nil if called at end of file.
`gets(separator = $/)`
  Reads the next line; lines are separated by separator. Returns nil if called at end of file.
`lineno`
  Return the current line number
`lineno=(num)`
  Manually sets the current line number to the given value
`read(number)`
  Read at most number characters Returns nil if called at end of file
`readline(separator = $/)`
  Reads the next line; lines are separated by separator. Raise an error at end of file
`readlines(separator = $/)`
  Reads all of the lines, and returns them in anArray. Lines are separated by the optional separator
`to_io`
  return the associated object
`ungetc(char)`
  Push back one character
`ungets(str)`
  Push back the string
`unused`
  Return the String read by BZ2::Reader but not used in the uncompression
`unused=(str)`
  Initialize the uncompression with the String str

## Exceptions

### BZ2::ConfigError < Fatal

    Indicates that the library has been improperly compiled on your platform

### BZ2::Error < ::IOError

    Exception raised by BZ2

### BZ2::EOZError < BZ2::Error

    "End of Zip" exception : compressed file finishes before the logical
     end of stream is detected