ruby-brs 1.0.1

data/lib/brs/stream/raw/abstract.rb

@@ -0,0 +1,55 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "brs_ext"
+
+require_relative "../../error"
+require_relative "../../validation"
+
+module BRS
+  module Stream
+    module Raw
+      class Abstract
+        def initialize(native_stream)
+          @native_stream = native_stream
+          @is_closed     = false
+        end
+
+        # -- write --
+
+        def flush(&writer)
+          write_result(&writer)
+        end
+
+        protected def flush_destination_buffer(&writer)
+          result_bytesize = write_result(&writer)
+          raise NotEnoughDestinationError, "not enough destination" if result_bytesize == 0
+        end
+
+        protected def write_result(&_writer)
+          result = @native_stream.read_result
+          yield result
+
+          result.bytesize
+        end
+
+        # -- close --
+
+        protected def do_not_use_after_close
+          raise UsedAfterCloseError, "used after close" if closed?
+        end
+
+        def close(&writer)
+          write_result(&writer)
+
+          @native_stream.close
+          @is_closed = true
+        end
+
+        def closed?
+          @is_closed
+        end
+      end
+    end
+  end
+end

data/lib/brs/stream/raw/compressor.rb

@@ -0,0 +1,97 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "brs_ext"
+
+require_relative "abstract"
+require_relative "../../error"
+require_relative "../../option"
+require_relative "../../validation"
+
+module BRS
+  module Stream
+    module Raw
+      class Compressor < Abstract
+        BUFFER_LENGTH_NAMES = %i[destination_buffer_length].freeze
+
+        def initialize(options = {})
+          options       = Option.get_compressor_options options, BUFFER_LENGTH_NAMES
+          native_stream = NativeCompressor.new options
+
+          super native_stream
+        end
+
+        def write(source, &writer)
+          do_not_use_after_close
+
+          Validation.validate_string source
+          Validation.validate_proc writer
+
+          total_bytes_written = 0
+
+          loop do
+            bytes_written, need_more_destination  = @native_stream.write source
+            total_bytes_written                  += bytes_written
+
+            if need_more_destination
+              source = source.byteslice bytes_written, source.bytesize - bytes_written
+              flush_destination_buffer(&writer)
+              next
+            end
+
+            unless bytes_written == source.bytesize
+              # Compressor write should eat all provided "source" without remainder.
+              raise UnexpectedError, "unexpected error"
+            end
+
+            break
+          end
+
+          total_bytes_written
+        end
+
+        def flush(&writer)
+          do_not_use_after_close
+
+          Validation.validate_proc writer
+
+          loop do
+            need_more_destination = @native_stream.flush
+
+            if need_more_destination
+              flush_destination_buffer(&writer)
+              next
+            end
+
+            break
+          end
+
+          super
+
+          nil
+        end
+
+        def close(&writer)
+          return nil if closed?
+
+          Validation.validate_proc writer
+
+          loop do
+            need_more_destination = @native_stream.finish
+
+            if need_more_destination
+              flush_destination_buffer(&writer)
+              next
+            end
+
+            break
+          end
+
+          super
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/brs/stream/raw/decompressor.rb

@@ -0,0 +1,70 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "brs_ext"
+
+require_relative "abstract"
+require_relative "../../option"
+require_relative "../../validation"
+
+module BRS
+  module Stream
+    module Raw
+      class Decompressor < Abstract
+        BUFFER_LENGTH_NAMES = %i[destination_buffer_length].freeze
+
+        def initialize(options = {})
+          options       = Option.get_decompressor_options options, BUFFER_LENGTH_NAMES
+          native_stream = NativeDecompressor.new options
+
+          super native_stream
+        end
+
+        def read(source, &writer)
+          do_not_use_after_close
+
+          Validation.validate_string source
+          Validation.validate_proc writer
+
+          total_bytes_read = 0
+
+          loop do
+            bytes_read, need_more_destination  = @native_stream.read source
+            total_bytes_read                  += bytes_read
+
+            if need_more_destination
+              source = source.byteslice bytes_read, source.bytesize - bytes_read
+              flush_destination_buffer(&writer)
+              next
+            end
+
+            break
+          end
+
+          # Please remember that "total_bytes_read" can not be equal to "source.bytesize".
+          total_bytes_read
+        end
+
+        def flush(&writer)
+          do_not_use_after_close
+
+          Validation.validate_proc writer
+
+          super
+
+          nil
+        end
+
+        def close(&writer)
+          return nil if closed?
+
+          Validation.validate_proc writer
+
+          super
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/brs/stream/reader.rb

@@ -0,0 +1,166 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "abstract"
+require_relative "raw/decompressor"
+require_relative "reader_helpers"
+require_relative "../validation"
+
+module BRS
+  module Stream
+    class Reader < Abstract
+      include ReaderHelpers
+
+      attr_accessor :lineno
+
+      def initialize(source_io, options = {}, *args)
+        @options = options
+
+        super source_io, *args
+
+        initialize_source_buffer_length
+        reset_io_remainder
+
+        @lineno = 0
+      end
+
+      protected def initialize_source_buffer_length
+        source_buffer_length = @options[:source_buffer_length]
+        Validation.validate_not_negative_integer source_buffer_length unless source_buffer_length.nil?
+
+        source_buffer_length = Buffer::DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR \
+          if source_buffer_length == 0 || source_buffer_length.nil?
+
+        @source_buffer_length = source_buffer_length
+      end
+
+      protected def create_raw_stream
+        Raw::Decompressor.new @options
+      end
+
+      protected def reset_io_remainder
+        @io_remainder = ::String.new :encoding => ::Encoding::BINARY
+      end
+
+      # -- synchronous --
+
+      def read(bytes_to_read = nil, out_buffer = nil)
+        Validation.validate_not_negative_integer bytes_to_read unless bytes_to_read.nil?
+        Validation.validate_string out_buffer unless out_buffer.nil?
+
+        return ::String.new :encoding => ::Encoding::BINARY if bytes_to_read == 0
+
+        unless bytes_to_read.nil?
+          return nil if eof?
+
+          read_more_from_buffer until @buffer.bytesize >= bytes_to_read || @io.eof?
+
+          return read_bytes_from_buffer bytes_to_read, out_buffer
+        end
+
+        read_more_from_buffer until @io.eof?
+
+        result = @buffer
+        reset_buffer
+        @pos += result.bytesize
+
+        result.force_encoding @external_encoding unless @external_encoding.nil?
+        result = transcode_to_internal result
+        result = out_buffer.replace result unless out_buffer.nil?
+
+        result
+      end
+
+      protected def read_more_from_buffer
+        io_data = @io.read @source_buffer_length
+        append_io_data_to_buffer io_data
+      end
+
+      def readpartial(bytes_to_read = nil, out_buffer = nil)
+        raise ::EOFError if eof?
+
+        readpartial_from_buffer until @buffer.bytesize >= bytes_to_read || @io.eof?
+
+        read_bytes_from_buffer bytes_to_read, out_buffer
+      end
+
+      protected def readpartial_from_buffer
+        io_data = @io.readpartial @source_buffer_length
+        append_io_data_to_buffer io_data
+      end
+
+      def rewind
+        raw_wrapper :close
+
+        reset_io_remainder
+
+        super
+      end
+
+      def close
+        raw_wrapper :close
+
+        super
+      end
+
+      # -- asynchronous --
+
+      def read_nonblock(bytes_to_read, out_buffer = nil, *options)
+        raise ::EOFError if eof?
+
+        read_more_from_buffer_nonblock(*options) until @buffer.bytesize >= bytes_to_read || @io.eof?
+
+        read_bytes_from_buffer bytes_to_read, out_buffer
+      end
+
+      protected def read_more_from_buffer_nonblock(*options)
+        io_data = @io.read_nonblock @source_buffer_length, *options
+        append_io_data_to_buffer io_data
+      end
+
+      # -- common --
+
+      def eof?
+        @io.eof? && @buffer.bytesize == 0
+      end
+
+      protected def read_bytes_from_buffer(bytes_to_read, out_buffer)
+        bytes_read = [@buffer.bytesize, bytes_to_read].min
+
+        # Result uses buffer binary encoding.
+        result   = @buffer.byteslice 0, bytes_read
+        @buffer  = @buffer.byteslice bytes_read, @buffer.bytesize - bytes_read
+        @pos    += bytes_read
+
+        result = out_buffer.replace result unless out_buffer.nil?
+        result
+      end
+
+      protected def append_io_data_to_buffer(io_data)
+        io_portion    = @io_remainder + io_data
+        bytes_read    = raw_wrapper :read, io_portion
+        @io_remainder = io_portion.byteslice bytes_read, io_portion.bytesize - bytes_read
+
+        # We should just ignore case when "io.eof?" appears but "io_remainder" is not empty.
+        # Ancient compress implementations can write bytes from not initialized buffer parts to output.
+        raw_wrapper :flush if @io.eof?
+      end
+
+      protected def transcode_to_internal(data)
+        data = data.encode @internal_encoding, @transcode_options unless @internal_encoding.nil?
+        data
+      end
+
+      # We should be able to return data back to buffer.
+      # We won't use any transcode options because transcoded data should be backward compatible.
+      protected def transcode_to_external(data)
+        data = data.encode @external_encoding unless @external_encoding.nil?
+        data
+      end
+
+      protected def raw_wrapper(method_name, *args)
+        @raw_stream.send(method_name, *args) { |portion| @buffer << portion }
+      end
+    end
+  end
+end

data/lib/brs/stream/reader_helpers.rb

@@ -0,0 +1,192 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "../validation"
+
+module BRS
+  module Stream
+    module ReaderHelpers
+      def getbyte
+        read 1
+      end
+
+      def each_byte(&block)
+        each_string method(:getbyte), &block
+      end
+
+      def readbyte
+        readstring method(:getbyte)
+      end
+
+      def ungetbyte(byte)
+        Validation.validate_string byte
+
+        @buffer.prepend byte
+
+        nil
+      end
+
+      # -- char --
+
+      def getc
+        if @external_encoding.nil?
+          byte = getbyte
+          return nil if byte.nil?
+
+          return transcode_to_internal byte
+        end
+
+        char = ::String.new :encoding => ::Encoding::BINARY
+
+        # Read one byte until valid string will appear.
+        loop do
+          byte = getbyte
+          return nil if byte.nil?
+
+          char << byte
+
+          char.force_encoding @external_encoding
+          return transcode_to_internal char if char.valid_encoding?
+
+          char.force_encoding ::Encoding::BINARY
+        end
+      end
+
+      def readchar
+        readstring method(:getc)
+      end
+
+      def each_char(&block)
+        each_string method(:getc), &block
+      end
+
+      def ungetc(char)
+        ungetstring char
+      end
+
+      # -- lines --
+
+      def gets(separator = $OUTPUT_RECORD_SEPARATOR, limit = nil)
+        # Limit can be a first argument.
+        if separator.is_a? ::Numeric
+          limit     = separator
+          separator = $OUTPUT_RECORD_SEPARATOR
+        end
+
+        line_ending =
+          if separator.nil?
+            nil
+          else
+            Validation.validate_string separator
+            ::String.new separator, :encoding => target_encoding
+          end
+
+        Validation.validate_positive_integer limit unless limit.nil?
+
+        line = ::String.new :encoding => target_encoding
+
+        loop do
+          char = getc
+
+          if char.nil?
+            return nil if line.empty?
+
+            break
+          end
+
+          line << char
+
+          break if
+            (!line_ending.nil? && line.end_with?(line_ending)) ||
+            (!limit.nil? && line.length >= limit)
+        end
+
+        @lineno += 1
+
+        line
+      end
+
+      def readline
+        readstring method(:gets)
+      end
+
+      def readlines
+        lines = []
+        each_line { |line| lines << line }
+
+        lines
+      end
+
+      def each_line(&block)
+        each_string method(:gets), &block
+      end
+
+      alias each each_line
+
+      def ungetline(line)
+        ungetstring line
+
+        @lineno -= 1
+
+        nil
+      end
+
+      # -- common --
+
+      protected def readstring(each_proc)
+        string = each_proc.call
+        raise ::EOFError if string.nil?
+
+        string
+      end
+
+      protected def each_string(each_proc, &block)
+        return enum_for __method__ unless block.is_a? ::Proc
+
+        loop do
+          string = each_proc.call
+          break if string.nil?
+
+          yield string
+        end
+
+        nil
+      end
+
+      protected def ungetstring(string)
+        Validation.validate_string string
+
+        string = ::String.new string, :encoding => @internal_encoding unless @internal_encoding.nil?
+        string = transcode_to_external string unless @external_encoding.nil?
+
+        string.force_encoding ::Encoding::BINARY
+        @buffer.prepend string
+
+        nil
+      end
+
+      # -- etc --
+
+      module ClassMethods
+        def open(file_path, *args, &block)
+          Validation.validate_string file_path
+          Validation.validate_proc block
+
+          ::File.open file_path, "rb" do |io|
+            reader = new io, *args
+
+            begin
+              yield reader
+            ensure
+              reader.close
+            end
+          end
+        end
+      end
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+    end
+  end
+end

data/lib/brs/stream/stat.rb

@@ -0,0 +1,78 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "forwardable"
+
+module BRS
+  module Stream
+    class Stat
+      # Libraries like minitar tries to access stat to know whether stream is seekable.
+      # We need to mark stream as not directory, file, etc, because it is not seekable.
+
+      # User can use disabled delegates using :io reader.
+
+      extend ::Forwardable
+
+      METHODS_RETURNING_FALSE = %i[
+        blockdev?
+        chardev?
+        directory?
+        executable?
+        executable_real?
+        file?
+        grpowned?
+        owned?
+        pipe?
+        setgid?
+        setuid?
+        socket?
+        sticky?
+        symlink?
+        zero?
+      ]
+      .freeze
+
+      DELEGATES = %i[
+        <=>
+        atime
+        birthtime
+        blksize
+        blocks
+        ctime
+        dev
+        dev_major
+        dev_minor
+        ftype
+        gid
+        ino
+        inspect
+        mode
+        mtime
+        nlink
+        rdev
+        rdev_major
+        rdev_minor
+        readable?
+        readable_real?
+        size
+        size?
+        uid
+        world_readable?
+        world_writable?
+        writable?
+        writable_real?
+      ]
+      .freeze
+
+      def initialize(stat)
+        @stat = stat
+      end
+
+      METHODS_RETURNING_FALSE.each do |method_name|
+        define_method(method_name) { false }
+      end
+
+      def_delegators :@stat, *DELEGATES
+    end
+  end
+end