burli 0.1.0-x86_64-linux-musl

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 831df44e5e07a682f46a0bcdd05a9c93973aa1eb9f72ae117311cc48a248bd62
+  data.tar.gz: fe328038e234a18058950753246707c2214f95b2d39b00100298cf15d841046e
+SHA512:
+  metadata.gz: 241173318f68c9bf4fd2207bc44871afb1b95d9084b7469054ab5b0bc8905244e18ac45cf3e3defd76fe3786b740bcfbaa71e22aab8517ca83bd52c63d543219
+  data.tar.gz: eaafeec370a7b911196ba9c0ae2a8e50f9a22ff0566ce114e407776d07d0d01ac6e8a86da2a51f52994a62366d76e5b05a7f51a8d5a8c71d0b3e08a865b1979c

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-28
+
+- Add the `burli` gem, with the API of the `brotli` gem: `Burli.deflate`,
+  `Burli.inflate`, `Burli::Compressor`, `Burli::Decompressor` with
+  `output_buffer_limit:`, `can_accept_more_data`, and `unused_data`,
+  `Burli::Writer`, `Burli::Reader`, and `Burli::Error`. Qualities 6 to 11 run
+  as 5. Raw dictionaries work for decompression.

data/README.md

@@ -0,0 +1,29 @@
+# burli
+
+Brotli compression and decompression for Ruby, built on
+[burli](https://github.com/paddor/burli), a Brotli codec in safe Rust. The
+API matches the `brotli` gem:
+
+```ruby
+require "burli"
+
+compressed = Burli.deflate(data)
+Burli.inflate(compressed) == data # => true
+```
+
+Code written for the `brotli` gem can switch with `Brotli = Burli`.
+`Burli::Compressor`, `Burli::Decompressor` (with `output_buffer_limit:`),
+`Burli::Writer`, and `Burli::Reader` work as in `brotli`. Calls release the
+GVL while they encode or decode.
+
+Differences from `brotli`:
+
+- Qualities 6 to 11 run as 5, and the default quality is 5.
+- `dictionary:` works for decompression only. Compression with it raises
+  `ArgumentError`.
+- `Burli.inflate` raises on data after the stream. `Burli::Decompressor`
+  keeps such data in `#unused_data`, as in `brotli`.
+- Error messages differ, and `Burli.version` returns the gem version.
+
+Gems come precompiled for Linux (glibc and musl), macOS, and Windows. Other
+platforms build from source with Rust 1.89 or later.

data/lib/burli/reader.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Burli
+  # Decompresses a stream read from an IO.
+  class Reader
+    # Compressed bytes read from the IO at a time, and the least decoded
+    # output each step asks for.
+    CHUNK_SIZE = 16 * 1024
+
+    # @param io [#read, #readpartial] where the compressed stream comes from
+    # @param options [Hash, nil] +dictionary+, as for {Burli.inflate}
+    def initialize(io, options = nil, **kwargs)
+      raise ArgumentError, "io should not be nil" if io.nil?
+
+      @io = io
+      @decompressor = Decompressor.new(Hash(options).merge(kwargs))
+      @buffer = "".b
+      @closed = false
+    end
+
+    # Reads +length+ decoded bytes, or all of them without +length+.
+    # @return [String, nil] nil at the end of the stream when +length+ is given
+    def read(length = nil, outbuf = nil)
+      ensure_open
+      if length.nil?
+        step(nil) until @decompressor.finished?
+        return output(outbuf, @buffer.bytesize)
+      end
+
+      length = Integer(length)
+      raise ArgumentError, "negative length #{length} given" if length.negative?
+      return output(outbuf, 0) if length.zero?
+
+      step(length - @buffer.bytesize) while @buffer.bytesize < length && !@decompressor.finished?
+      if @buffer.empty?
+        outbuf&.clear
+        return nil
+      end
+      output(outbuf, length)
+    end
+
+    # Reads at most +maxlen+ decoded bytes, waiting only until some arrive.
+    # @raise [EOFError] at the end of the stream
+    def readpartial(maxlen, outbuf = nil)
+      ensure_open
+      maxlen = Integer(maxlen)
+      raise ArgumentError, "max length must be positive" unless maxlen.positive?
+
+      step(maxlen) while @buffer.empty? && !@decompressor.finished?
+      if @buffer.empty?
+        outbuf&.clear
+        raise EOFError, "end of file reached"
+      end
+      output(outbuf, maxlen)
+    end
+
+    def eof?
+      ensure_open
+      step(1) while @buffer.empty? && !@decompressor.finished?
+      @buffer.empty?
+    end
+
+    # Closes the IO.
+    # @return [IO] the IO
+    def close
+      return @io if @closed
+
+      begin
+        @io.close if @io.respond_to?(:close)
+      ensure
+        @closed = true
+        @buffer.clear
+      end
+      @io
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def ensure_open
+      raise Error, "Reader is closed" if @closed
+    end
+
+    # Decodes into the buffer, at least +wanted+ bytes per step unless the
+    # input ends first. Reads input only when the decompressor takes it.
+    def step(wanted)
+      input = "".b
+      if @decompressor.can_accept_more_data
+        input = read_input
+        raise Error, "unexpected end of compressed stream" if input.nil? || input.empty?
+      end
+      limit = wanted && [wanted, CHUNK_SIZE].max
+      @buffer << @decompressor.process(input, output_buffer_limit: limit)
+    end
+
+    def read_input
+      return @io.read(CHUNK_SIZE) unless @io.respond_to?(:readpartial)
+
+      @io.readpartial(CHUNK_SIZE)
+    rescue EOFError
+      nil
+    end
+
+    # Takes up to +length+ bytes from the buffer.
+    def output(outbuf, length)
+      data = length >= @buffer.bytesize ? @buffer : @buffer.byteslice(0, length)
+      @buffer = length >= @buffer.bytesize ? "".b : @buffer.byteslice(length..)
+      return data unless outbuf
+
+      outbuf.replace(data)
+    end
+  end
+end

data/lib/burli/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Burli
+  # The gem version.
+  VERSION = "0.1.0"
+end

data/lib/burli/writer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Burli
+  # Compresses what is written to it into an IO.
+  class Writer
+    # @param io [#write] where the compressed stream goes
+    # @param options [Hash, nil] +mode+, +quality+, +lgwin+, and +lgblock+, as
+    #   for {Burli.deflate}
+    def initialize(io, options = nil, **kwargs)
+      raise ArgumentError, "io should not be nil" if io.nil?
+
+      @io = io
+      @compressor = Compressor.new(Hash(options).merge(kwargs))
+      @closed = false
+    end
+
+    # Compresses +data+ and writes the output produced so far.
+    # @return [Integer] the bytes of +data+
+    def write(data)
+      ensure_open
+      data = String.try_convert(data) || raise(TypeError, "no implicit conversion of #{data.class} into String")
+      put(@compressor.process(data))
+      data.bytesize
+    end
+
+    # Writes output that decodes to all data so far, and flushes the IO.
+    # @return [self]
+    def flush
+      ensure_open
+      put(@compressor.flush)
+      @io.flush if @io.respond_to?(:flush)
+      self
+    end
+
+    # Ends the stream without closing the IO.
+    # @return [IO] the IO
+    def finish
+      ensure_open
+      put(@compressor.finish)
+      @io
+    end
+
+    # Ends the stream and closes the IO.
+    # @return [IO] the IO
+    def close
+      return @io if @closed
+
+      begin
+        finish
+      ensure
+        @closed = true
+        @io.close if @io.respond_to?(:close)
+      end
+      @io
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def ensure_open
+      raise Error, "Writer is closed" if @closed
+    end
+
+    def put(output)
+      @io.write(output) unless output.empty?
+    end
+  end
+end

data/lib/burli.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "burli/version"
+
+# Precompiled gems hold one extension per Ruby minor version.
+begin
+  require_relative "burli/#{RUBY_VERSION[/\A\d+\.\d+/]}/burli_native"
+rescue LoadError
+  require_relative "burli/burli_native"
+end
+
+# Memory-safe Brotli compression and decompression, with the API of the
+# brotli gem. Existing code can switch with:
+#
+#   Brotli = Burli
+#
+# Qualities 6 to 11 run as 5.
+module Burli
+  # Checks options, with the messages of the brotli gem, for the native
+  # methods.
+  module Options
+    MODES = {generic: 0, text: 1, font: 2}.freeze
+
+    module_function
+
+    def merge(options, kwargs)
+      Hash(options).merge(kwargs)
+    end
+
+    # @return [Array(Integer, Integer, Integer, Integer)] mode, quality,
+    #   lgwin, and lgblock
+    def encoder(options)
+      unless options[:dictionary].nil?
+        raise ArgumentError, "burli does not support dictionaries for compression"
+      end
+
+      mode = options[:mode].nil? ? 0 : MODES.fetch(options[:mode]) { raise ArgumentError, "invalid mode" }
+      [
+        mode,
+        integer(options[:quality], 5, "invalid quality value. Should be 0 to 11.") { (0..11).cover?(_1) },
+        integer(options[:lgwin], 22, "invalid lgwin value. Should be 10 to 24.") { (10..24).cover?(_1) },
+        integer(options[:lgblock], 0, "invalid lgblock value. Should be 0 or 16 to 24.") do
+          _1.zero? || (16..24).cover?(_1)
+        end
+      ]
+    end
+
+    def integer(value, default, message)
+      return default if value.nil?
+      raise ArgumentError, message unless value.is_a?(Integer) && yield(value)
+
+      value
+    end
+
+    # @return [String, nil] raw dictionary bytes
+    def dictionary(options)
+      options[:dictionary]
+    end
+
+    # @return [Integer] the limit, or 0 for none
+    def output_buffer_limit(options)
+      limit = options[:output_buffer_limit]
+      return 0 if limit.nil?
+      raise TypeError, "output_buffer_limit must be an Integer" unless limit.is_a?(Integer)
+      raise ArgumentError, "output_buffer_limit must be positive" unless limit.positive?
+
+      limit
+    end
+  end
+  private_constant :Options
+
+  private_class_method :_native_deflate, :_native_inflate
+
+  class << self
+    # Compresses +string+.
+    # @param options [Hash, nil] +mode+ (+:generic+, +:text+, or +:font+),
+    #   +quality+ (0 to 11), +lgwin+ (10 to 24), and +lgblock+ (0 or 16 to 24)
+    # @return [String] the Brotli stream
+    # @raise [ArgumentError] for invalid options
+    def deflate(string, options = nil, **kwargs)
+      raise ArgumentError, "input should not be nil" if string.nil?
+
+      _native_deflate(string, *Options.encoder(Options.merge(options, kwargs)))
+    end
+
+    # Decompresses a whole Brotli stream, from a String or an IO.
+    # @param options [Hash, nil] +dictionary+, a raw dictionary
+    # @return [String]
+    # @raise [Error] for malformed or truncated streams, and for data after
+    #   the end of the stream
+    def inflate(string, options = nil, **kwargs)
+      string = string.read if string.respond_to?(:read)
+      _native_inflate(string, Options.dictionary(Options.merge(options, kwargs)))
+    end
+
+    # @return [String] the gem version
+    def version
+      VERSION
+    end
+  end
+
+  # Compresses a stream in pieces.
+  class Compressor
+    private_class_method :_native_new
+
+    # @param options [Hash, nil] as for {Burli.deflate}
+    def self.new(options = nil, **kwargs)
+      _native_new(*Options.encoder(Options.merge(options, kwargs)))
+    end
+  end
+
+  # Decompresses a stream in pieces.
+  class Decompressor
+    private_class_method :_native_new
+    private :_native_process
+
+    # @param options [Hash, nil] +dictionary+, a raw dictionary
+    def self.new(options = nil, **kwargs)
+      _native_new(Options.dictionary(Options.merge(options, kwargs)))
+    end
+
+    # Decompresses +input+, returning the output produced so far. With
+    # +output_buffer_limit+, returns at most that many bytes; then call with
+    # empty input until {#can_accept_more_data} is true before passing more.
+    # @raise [Error] for malformed streams, and for input while output is
+    #   pending or after the end of the stream
+    def process(input, options = nil, **kwargs)
+      _native_process(input, Options.output_buffer_limit(Options.merge(options, kwargs)))
+    end
+
+    alias_method :is_finished, :finished?
+    alias_method :can_accept_more_data?, :can_accept_more_data
+  end
+end
+
+require_relative "burli/reader"
+require_relative "burli/writer"

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: burli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: x86_64-linux-musl
+authors:
+- Patrik Wenger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-10-28 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- paddor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/burli.rb
+- lib/burli/3.3/burli_native.so
+- lib/burli/3.4/burli_native.so
+- lib/burli/4.0/burli_native.so
+- lib/burli/reader.rb
+- lib/burli/version.rb
+- lib/burli/writer.rb
+homepage: https://github.com/paddor/burli/tree/main/bindings/ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/paddor/burli/tree/main/bindings/ruby
+  changelog_uri: https://github.com/paddor/burli/tree/main/bindings/ruby/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Memory-safe Brotli compression in Rust, with the API of the brotli gem
+test_files: []