lzo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5cf3131e88d5a3d3b9032d47c6341ea283901300
+  data.tar.gz: 9ce3f056b7dc3592b899ab8be6b90508c6670298
+SHA512:
+  metadata.gz: 8b7e18948dceae6587733c0ce3184964df2c4b58e019fd963428feac19077566c388d07691c7e4a93ae122e41ec80944d0028b75027e16e02e0231b0dcb045a2
+  data.tar.gz: 70c9389aaba4a5ba0cce57195695a50bff91f510ce98712c4ea06732880e8e870e3873a0062718708973ee6c1165f31bb6f157e572bf32b65a84c4bb325a929c

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+.DS_Store
+target

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,20 @@
+AllCops:
+  DisplayCopNames: true
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 15
+
+Style/SpaceBeforeBlockBraces:
+  Enabled: false
+
+Style/SpaceInsideBlockBraces:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/SingleLineBlockParams:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+2.3

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lzo.gemspec
+gemspec

data/README.md

@@ -0,0 +1,46 @@
+# LZO Ruby gem
+
+Wikipedia:
+
+> Lempel–Ziv–Oberhumer (LZO) is a lossless data compression algorithm that is focused on decompression speed.
+
+It's an alternative to Gzip, essentially. This gem exists because the previous 
+Ruby LZO gem ([`lzoruby`][lzoruby]) hasn't been updated for 5 years and doesn't 
+support LZOP (as generated by the `lzop` utility) or JRuby. We use the 
+[`ffi`][ffi] gem to provide VM-agnostic bindings to the LZO library.
+
+[lzoruby]: https://rubygems.org/gems/lzoruby
+[ffi]: https://rubygems.org/gems/ffi
+
+## Installation
+
+The LZO library is **not** bundled with this gem. It must be installed beforehand.
+Here's how you can do that on various popular OSes:
+
+* OS X: `brew install lzo`
+* Ubuntu: `apt-get install liblzo2-2` (`liblzo2-dev` works fine too)
+* Fedora: `yum install lzo` (or `lzo-devel`)
+
+Then the bog-standard `gem install lzo` - you know the drill.
+
+## Usage
+
+```ruby
+LZO.decompress(string_or_io) # returns String
+LZO.compress(string_or_io) # returns String
+
+file = File.open('/path/to/file.lzo', 'rb')
+reader = LZO::LzopDecompressor.new file
+reader.name # => "file.txt"
+reader.mode # => 0100644
+reader.mtime # => 2016-02-03 14:29:36 +1100
+reader.method # => :M_LZO1X_1
+reader.level # => 5
+reader.read(10) # => "The quick "
+
+output = File.open('/path/to/output.lzo', 'wb')
+writer = LZO::LzopCompressor.new output, name: 'output.txt', mode: 0100644, mtime: Time.now
+writer.write "first chunk of data"
+writer.write "second chunk of data"
+writer.close
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/TODO.md

@@ -0,0 +1,7 @@
+- Set up Travis CI for MRI versions, JRuby, Rubinius
+- Look into RDoc doc generation
+- Investigate "unlocked" FFI functionality
+- Consider bundling pre-compiled binaries
+- 100% code coverage
+- Document LZOP format, maybe?
+- Profile for hotspots

data/lib/lzo.rb

@@ -0,0 +1,48 @@
+require 'ffi'
+
+require 'lzo/raw'
+require 'lzo/ffi'
+require 'lzo/lzop'
+require 'lzo/version'
+require 'lzo/multi_io'
+
+module LZO
+  class << self
+    def compress(input, lzop: false)
+      io = input.respond_to?(:read) ? input : StringIO.new(input)
+
+      if lzop
+        output_io = StringIO.new ''.force_encoding 'BINARY'
+        compressor = LzopCompressor.new output_io, name: '', mode: 0100644, mtime: Time.now
+
+        until io.eof?
+          bytes = io.read 2**20 # 1MB chunks
+          compressor.write bytes
+        end
+
+        compressor.close
+        output_io.string
+      else
+        Raw.compress io
+      end
+    end
+
+    def decompress(input)
+      io = input.respond_to?(:read) ? input : StringIO.new(input)
+
+      magic = LZOP::Header::MAGIC
+      start = io.read magic.length
+      multi_io = MultiIO.new [StringIO.new(start), io]
+
+      if start == magic
+        LzopDecompressor.new(multi_io).read
+      else
+        Raw.decompress multi_io
+      end
+    end
+
+    def library_version
+      FFI.lzo_version
+    end
+  end
+end

data/lib/lzo/ffi.rb

@@ -0,0 +1,47 @@
+module LZO
+  module FFI
+    extend ::FFI::Library
+    ffi_lib 'lzo2'
+
+    # TODO: all "uint64" refs should check platform bitness
+    WORKMEM_SIZE_32 = 65_536
+    WORKMEM_SIZE_64 = 131_072
+
+    enum :lzo_error_code, [
+      :LZO_E_INTERNAL_ERROR, -99,
+      :LZO_E_OUTPUT_NOT_CONSUMED, -12,
+      :LZO_E_INVALID_ALIGNMENT,
+      :LZO_E_INVALID_ARGUMENT,
+      :LZO_E_NOT_YET_IMPLEMENTED,
+      :LZO_E_INPUT_NOT_CONSUMED,
+      :LZO_E_EOF_NOT_FOUND,
+      :LZO_E_LOOKBEHIND_OVERRUN,
+      :LZO_E_OUTPUT_OVERRUN,
+      :LZO_E_INPUT_OVERRUN,
+      :LZO_E_NOT_COMPRESSIBLE,
+      :LZO_E_OUT_OF_MEMORY,
+      :LZO_E_ERROR,
+      :LZO_E_OK
+    ]
+
+    attach_function :lzo1x_1_compress, [
+      :buffer_in, # input buffer
+      :uint, # input buffer length
+      :buffer_out, # output buffer
+      :pointer, # pointer to output buffer length
+      :buffer_inout # work mem
+    ], :lzo_error_code
+
+    attach_function :lzo1x_decompress_safe, [
+      :buffer_in, # input buffer
+      :uint, # input buffer length
+      :buffer_out, # output buffer
+      :pointer, # pointer to output buffer length
+      :pointer # work mem (always NULL)
+    ], :lzo_error_code
+
+    attach_function :lzo_adler32, [:uint, :buffer_in, :uint], :uint
+    attach_function :lzo_crc32, [:uint, :buffer_in, :uint], :uint
+    attach_function :lzo_version, [], :uint
+  end
+end

data/lib/lzo/lzop.rb

@@ -0,0 +1,13 @@
+require 'bindata'
+
+require 'lzo/lzop/lzop_decompressor'
+require 'lzo/lzop/lzop_compressor'
+require 'lzo/lzop/header_flags'
+require 'lzo/lzop/lzo_method'
+require 'lzo/lzop/header'
+require 'lzo/lzop/block'
+
+module LZO
+  module LZOP
+  end
+end

data/lib/lzo/lzop/block.rb

@@ -0,0 +1,47 @@
+module LZO
+  module LZOP
+    class Block < BinData::Record
+      mandatory_parameter :flags
+      hide :block
+      endian :big
+      virtual :flags_ary, value: :flags # TODO: is this necessary?
+
+      uint32 :decompressed_length, assert: -> { value > 0 }
+      uint32 :compressed_length, value: -> { block.length }
+      uint32 :decompressed_checksum, onlyif: -> { flags.include?(:F_ADLER32_D) || flags.include?(:F_CRC32_D) }
+      uint32 :compressed_checksum, onlyif: -> { flags.include?(:F_ADLER32_C) || flags.include?(:F_CRC32_C) }
+      string :block, read_length: :compressed_length
+
+      def body(validate: true)
+        # TODO: spec for raising error when data is invalid
+        raise 'Invalid data' unless !validate || valid?
+        str = block.force_encoding 'BINARY'
+
+        if compressed?
+          io = StringIO.new str
+          Raw.decompress io
+        else
+          str
+        end
+      end
+
+      def compressed?
+        compressed_length.to_i < decompressed_length.to_i
+      end
+
+      def valid?
+        fa = flags_ary
+        is_adler = fa.include?(:F_ADLER32_D) || fa.include?(:F_ADLER32_C)
+        is_compressed = fa.include?(:F_ADLER32_C) || fa.include?(:F_CRC32_C)
+
+        checksum_method = is_adler ? Raw.method(:adler32) : Raw.method(:crc32)
+        checksum_body = is_compressed ? block.to_s : body(validate: false)
+
+        expected_checksum = is_compressed ? compressed_checksum.to_i : decompressed_checksum.to_i
+        calculated_checksum = checksum_method.call(checksum_body)
+
+        calculated_checksum == expected_checksum
+      end
+    end
+  end
+end

data/lib/lzo/lzop/header.rb

@@ -0,0 +1,32 @@
+module LZO
+  module LZOP
+    class Header < BinData::Record
+      MAGIC = "\x89\x4C\x5A\x4F\x00\x0D\x0A\x1A\x0A".force_encoding('BINARY')
+      endian :big
+
+      string :magic, read_length: 9, asserted_value: MAGIC
+
+      struct :checksummable do
+        uint16 :version
+        uint16 :lib_version
+        uint16 :version_needed, onlyif: -> { version >= 0x0940 }
+        LzoMethod :lzo_method
+        uint8 :level, onlyif: -> { version >= 0x940 }
+        HeaderFlags :flags
+        uint32 :filter, onlyif: -> { flags.include? :F_H_FILTER }
+        uint32 :mode
+        uint32 :mtime_low
+        uint32 :mtime_high, onlyif: -> { version >= 0x0940 }
+        uint8  :name_length, value: -> { name.length }
+        string :name, read_length: :name_length
+      end
+
+      uint32 :checksum, asserted_value: -> { Raw.adler32(checksummable.to_binary_s) }
+      struct :extra, onlyif: -> { checksummable.flags.include? :F_H_EXTRA_FIELD } do
+        uint32 :extra_length
+        string :extra_field, length: :extra_length
+        uint32 :extra_checksum
+      end
+    end
+  end
+end

data/lib/lzo/lzop/header_flags.rb

@@ -0,0 +1,48 @@
+module LZO
+  module LZOP
+    class HeaderFlags < BinData::Primitive
+      uint32be :flags
+
+      # rubocop:disable Metrics/MethodLength
+      def map
+        {
+          (1 << 0) => :F_ADLER32_D,
+          (1 << 1) => :F_ADLER32_C,
+          (1 << 2) => :F_STDIN,
+          (1 << 3) => :F_STDOUT,
+          (1 << 4) => :F_NAME_DEFAULT,
+          (1 << 5) => :F_DOSISH,
+          (1 << 6) => :F_H_EXTRA_FIELD,
+          (1 << 7) => :F_H_GMTDIFF,
+          (1 << 8) => :F_CRC32_D,
+          (1 << 9) => :F_CRC32_C,
+          (1 << 10) => :F_MULTIPART,
+          (1 << 11) => :F_H_FILTER,
+          (1 << 12) => :F_H_CRC32,
+          (1 << 13) => :F_H_PATH
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def get
+        ary = [flags.to_i]
+        map.each do |k, v|
+          ary << v if k & flags.to_i > 0
+        end
+        ary
+      end
+
+      def set(v)
+        tmp = 0
+        v.each do |f|
+          if f.is_a?(Symbol)
+            tmp |= map.invert[f]
+          else
+            tmp |= f
+          end
+        end
+        self.flags = tmp
+      end
+    end
+  end
+end

data/lib/lzo/lzop/lzo_method.rb

@@ -0,0 +1,19 @@
+module LZO
+  module LZOP
+    class LzoMethod < BinData::Primitive
+      uint8be :val
+
+      def map
+        { M_LZO1X_1: 1, M_LZO1X_1_15: 2, M_LZO1X_999: 3 }
+      end
+
+      def get
+        map.invert[val.to_i]
+      end
+
+      def set(v)
+        self.val = map[v]
+      end
+    end
+  end
+end

data/lib/lzo/lzop/lzop_compressor.rb

@@ -0,0 +1,57 @@
+module LZO
+  class LzopCompressor
+    def initialize(io, name:, mode:, mtime:)
+      @io = io
+      @name = name
+      @mode = mode
+      @mtime = mtime
+    end
+
+    def write(bytes)
+      write_header_once!
+
+      block = LZOP::Block.new flags: [:F_ADLER32_D]
+
+      checksum = Raw.adler32 bytes
+      compressed = Raw.compress StringIO.new bytes
+
+      if compressed.length >= bytes.length
+        block.block = bytes
+      else
+        block.block = compressed
+      end
+
+      # NOTE: compressed_length is set by bindata
+      block.decompressed_checksum = checksum
+      block.decompressed_length = bytes.length
+
+      io.write block.to_binary_s
+    end
+
+    def close
+      eof_marker = [0].pack 'N'
+      io.write eof_marker
+      io.close
+    end
+
+    private
+    attr_reader :io, :name, :mode, :mtime
+
+    def write_header_once!
+      @header ||= begin
+        header = LZOP::Header.new
+        fields = header.checksummable
+        fields.version = 0x0940
+        fields.lib_version = LZO.library_version
+        fields.version_needed = 0x0940
+        fields.lzo_method = :M_LZO1X_1
+        fields.level = 1
+        fields.flags = [:F_ADLER32_D]
+        fields.mode = mode
+        fields.mtime_low = mtime.to_i
+        fields.name = name
+        io.write header.to_binary_s
+      end
+    end
+  end
+end

data/lib/lzo/lzop/lzop_decompressor.rb

@@ -0,0 +1,81 @@
+module LZO
+  class LzopDecompressor
+    def initialize(io)
+      @io = io
+    end
+
+    def name
+      header.checksummable.name.to_s
+    end
+
+    def mode
+      header.checksummable.mode.to_i
+    end
+
+    def mtime
+      Time.at header.checksummable.mtime_low
+    end
+
+    def method
+      header.checksummable.lzo_method.get
+    end
+
+    def level
+      header.checksummable.level.to_i
+    end
+
+    def read(nbytes = nil)
+      @enum ||= enum_for :yield_blocks, io, header
+      @leftover ||= ''.force_encoding 'BINARY'
+
+      output = StringIO.new @leftover.dup
+      @leftover = ''.force_encoding 'BINARY'
+
+      output.seek 0, ::IO::SEEK_END
+
+      while nbytes.nil? || output.length < nbytes
+        begin
+          block = @enum.next
+        rescue StopIteration
+          break
+        end
+
+        bytes = block.body
+        output.write bytes
+      end
+
+      if nbytes && nbytes < output.length
+        output.seek nbytes, ::IO::SEEK_SET
+        @leftover = output.read
+      end
+
+      output.rewind
+      output.read nbytes
+    end
+
+    def eof?
+      io.eof? && @leftover.length == 0
+    end
+
+    private
+
+    attr_reader :io
+
+    def header
+      @header ||= LZOP::Header.read io
+    end
+
+    def yield_blocks(io, header)
+      loop do
+        # TODO: there's gotta be a better way than a validity error?
+        begin
+          block = LZOP::Block.read(io, flags: header.checksummable.flags)
+          yield block
+        rescue BinData::ValidityError
+          # this "exception" is expected: last block of the stream
+          break
+        end
+      end
+    end
+  end
+end

data/lib/lzo/multi_io.rb

@@ -0,0 +1,28 @@
+module LZO
+  # TODO: surely there's a better way to do this that i'm not aware of
+  class MultiIO
+    def initialize(ios)
+      @ios = ios
+    end
+
+    def read(nbytes = nil)
+      output = StringIO.new ''.force_encoding('BINARY')
+
+      while nbytes.nil? || output.length < nbytes
+        io = @ios.first
+        break if io.nil?
+        read_len = (nbytes - output.length) if nbytes
+        bytes = io.read read_len
+        @ios.shift if io.eof?
+        output.write bytes
+      end
+
+      output.rewind
+      output.read
+    end
+
+    def eof?
+      @ios.length == 0
+    end
+  end
+end

data/lib/lzo/raw.rb

@@ -0,0 +1,76 @@
+module LZO
+  module Raw
+    class << self
+      def compress(io)
+        str = ''
+        str << io.read until io.eof?
+
+        buf_len = str.bytesize
+        buf = ::FFI::MemoryPointer.new :char, buf_len
+        buf.put_bytes 0, str
+
+        out_len = output_length_for_input str
+        out_len_buf = ::FFI::MemoryPointer.new :size_t, 1
+        out_len_buf.put_uint64 0, out_len
+
+        out_buf = ::FFI::MemoryPointer.new :char, out_len
+
+        work_mem_buf = ::FFI::MemoryPointer.new :char, FFI::WORKMEM_SIZE_64
+
+        ret_code = FFI.lzo1x_1_compress buf, buf_len, out_buf, out_len_buf, work_mem_buf
+        raise "Unexpected error code: #{ret_code}" if ret_code != :LZO_E_OK # apparently never fails?
+
+        out_len = out_len_buf.read_uint64
+        out_buf.read_bytes out_len
+      end
+
+      def decompress(io)
+        str = ''
+        str << io.read until io.eof?
+
+        buf_len = str.bytesize
+        buf = ::FFI::MemoryPointer.new :char, buf_len
+        buf.put_bytes 0, str
+
+        # TODO: how can we realloc? this is wasteful
+        out_len = 512
+        begin
+          out_len *= 2
+          out_len_buf = ::FFI::MemoryPointer.new :size_t, 1
+          out_len_buf.put_uint64 0, out_len
+          out_buf = ::FFI::MemoryPointer.new :char, out_len
+
+          ret_code = FFI.lzo1x_decompress_safe buf, buf_len, out_buf, out_len_buf, nil
+        end while ret_code == :LZO_E_OUTPUT_OVERRUN
+
+        if ret_code == :LZO_E_OK
+          out_len = out_len_buf.read_uint64
+          out_buf.read_bytes out_len
+        else
+          raise "Error: #{ret_code}" # TODO: do something?
+        end
+      end
+
+      def output_length_for_input(input)
+        inlen = input.length
+        inlen + (inlen / 16) + 64 + 3 # worst case
+      end
+
+      def adler32(input)
+        buf_len = input.bytesize
+        buf = ::FFI::MemoryPointer.new :char, buf_len
+        buf.put_bytes 0, input
+
+        FFI.lzo_adler32 1, buf, buf_len
+      end
+
+      def crc32(input)
+        buf_len = input.bytesize
+        buf = ::FFI::MemoryPointer.new :char, buf_len
+        buf.put_bytes 0, input
+
+        FFI.lzo_crc32 0, buf, buf_len
+      end
+    end
+  end
+end

data/lib/lzo/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module LZO
+  VERSION = '0.1.0'.freeze
+end

data/lzo.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lzo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lzo'
+  spec.version       = LZO::VERSION
+  spec.authors       = ['Aidan Steele']
+  spec.email         = ['aidan@awsteele.com']
+
+  spec.summary       = 'LZO bindings for all Rubies + LZOP streaming'
+  spec.homepage      = 'https://github.com/aidansteele/lzo'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject {|f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) {|f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ffi', '~> 1'
+  spec.add_dependency 'bindata', '~> 2.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rspec_junit_formatter'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'pry-rescue'
+  spec.add_development_dependency 'pry-stack_explorer'
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: lzo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aidan Steele
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- aidan@awsteele.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- TODO.md
+- lib/lzo.rb
+- lib/lzo/ffi.rb
+- lib/lzo/lzop.rb
+- lib/lzo/lzop/block.rb
+- lib/lzo/lzop/header.rb
+- lib/lzo/lzop/header_flags.rb
+- lib/lzo/lzop/lzo_method.rb
+- lib/lzo/lzop/lzop_compressor.rb
+- lib/lzo/lzop/lzop_decompressor.rb
+- lib/lzo/multi_io.rb
+- lib/lzo/raw.rb
+- lib/lzo/version.rb
+- lzo.gemspec
+homepage: https://github.com/aidansteele/lzo
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: LZO bindings for all Rubies + LZOP streaming
+test_files: []