ruby-lzws 1.0.0

data/lib/lzws/stream/reader_helpers.rb

@@ -0,0 +1,192 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "../validation"
+
+module LZWS
+  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
+        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 |file|
+            reader = new file, *args
+
+            begin
+              yield reader
+            ensure
+              reader.close
+            end
+          end
+        end
+      end
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+    end
+  end
+end

data/lib/lzws/stream/stat.rb

@@ -0,0 +1,78 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "forwardable"
+
+module LZWS
+  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

data/lib/lzws/stream/writer.rb

@@ -0,0 +1,145 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "abstract"
+require_relative "raw/compressor"
+require_relative "writer_helpers"
+
+module LZWS
+  module Stream
+    class Writer < Abstract
+      include WriterHelpers
+
+      def initialize(destination_io, options = {}, *args)
+        @options = options
+
+        super destination_io, *args
+      end
+
+      protected def create_raw_stream
+        Raw::Compressor.new @options
+      end
+
+      # -- synchronous --
+
+      def write(*objects)
+        write_remaining_buffer
+
+        bytes_written = 0
+
+        objects.each do |object|
+          source         = transcode object.to_s
+          bytes_written += raw_wrapper :write, source
+        end
+
+        @pos += bytes_written
+
+        bytes_written
+      end
+
+      def flush
+        finish :flush
+
+        @io.flush
+
+        self
+      end
+
+      def rewind
+        finish :close
+
+        super
+      end
+
+      def close
+        finish :close
+
+        super
+      end
+
+      protected def finish(method_name)
+        write_remaining_buffer
+
+        raw_wrapper method_name
+      end
+
+      protected def write_remaining_buffer
+        return nil if @buffer.bytesize == 0
+
+        @io.write @buffer
+
+        reset_buffer
+      end
+
+      protected def raw_wrapper(method_name, *args)
+        @raw_stream.send(method_name, *args) { |portion| @io.write portion }
+      end
+
+      # -- asynchronous --
+
+      def write_nonblock(object, *options)
+        return 0 unless write_remaining_buffer_nonblock(*options)
+
+        source         = transcode object.to_s
+        bytes_written  = raw_nonblock_wrapper :write, source
+        @pos          += bytes_written
+
+        bytes_written
+      end
+
+      def flush_nonblock(*options)
+        return false unless finish_nonblock :flush, *options
+
+        @io.flush
+
+        true
+      end
+
+      def rewind_nonblock(*options)
+        return false unless finish_nonblock :close, *options
+
+        method(:rewind).super_method.call
+
+        true
+      end
+
+      def close_nonblock(*options)
+        return false unless finish_nonblock :close, *options
+
+        method(:close).super_method.call
+
+        true
+      end
+
+      protected def finish_nonblock(method_name, *options)
+        return false unless write_remaining_buffer_nonblock(*options)
+
+        raw_nonblock_wrapper method_name
+
+        write_remaining_buffer_nonblock(*options)
+      end
+
+      protected def write_remaining_buffer_nonblock(*options)
+        return true if @buffer.bytesize == 0
+
+        bytes_written = @io.write_nonblock @buffer, *options
+        return false if bytes_written == 0
+
+        @buffer = @buffer.byteslice bytes_written, @buffer.bytesize - bytes_written
+
+        @buffer.bytesize == 0
+      end
+
+      protected def raw_nonblock_wrapper(method_name, *args)
+        @raw_stream.send(method_name, *args) { |portion| @buffer << portion }
+      end
+
+      # -- common --
+
+      protected def transcode(data)
+        data = data.encode @external_encoding, @transcode_options unless @external_encoding.nil?
+        data
+      end
+    end
+  end
+end

data/lib/lzws/stream/writer_helpers.rb

@@ -0,0 +1,93 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "../error"
+require_relative "../validation"
+
+module LZWS
+  module Stream
+    module WriterHelpers
+      def <<(object)
+        write object
+      end
+
+      def print(*objects)
+        if objects.empty?
+          write $LAST_READ_LINE unless $LAST_READ_LINE.nil?
+          return nil
+        end
+
+        objects.each do |object|
+          write object
+          write $OUTPUT_FIELD_SEPARATOR unless $OUTPUT_FIELD_SEPARATOR.nil?
+        end
+
+        write $OUTPUT_RECORD_SEPARATOR unless $OUTPUT_RECORD_SEPARATOR.nil?
+
+        nil
+      end
+
+      def printf(*args)
+        write sprintf(*args)
+
+        nil
+      end
+
+      def putc(object, encoding: ::Encoding::BINARY)
+        if object.is_a? ::Numeric
+          write object.chr(encoding)
+        elsif object.is_a? ::String
+          write object[0]
+        else
+          raise ValidateError, "invalid object: \"#{object}\" for putc"
+        end
+
+        object
+      end
+
+      def puts(*objects)
+        objects.each do |object|
+          if object.is_a? ::Array
+            puts(*object)
+            next
+          end
+
+          source  = object.to_s
+          newline = "\n".encode source.encoding
+
+          # Do not add newline if source ends with newline.
+          if source.end_with? newline
+            write source
+          else
+            write source + newline
+          end
+        end
+
+        nil
+      end
+
+      # -- etc --
+
+      module ClassMethods
+        def open(file_path, *args, &block)
+          Validation.validate_string file_path
+          Validation.validate_proc block
+
+          ::File.open file_path, "wb" do |file|
+            writer = new file, *args
+
+            begin
+              yield writer
+            ensure
+              writer.close
+            end
+          end
+        end
+      end
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+    end
+  end
+end

data/lib/lzws/string.rb

@@ -0,0 +1,27 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "lzws_ext"
+
+require_relative "option"
+require_relative "validation"
+
+module LZWS
+  module String
+    def self.compress(source, options = {})
+      Validation.validate_string source
+
+      options = Option.get_compressor_options options
+
+      LZWS._native_compress_string source, options
+    end
+
+    def self.decompress(source, options = {})
+      Validation.validate_string source
+
+      options = Option.get_decompressor_options options
+
+      LZWS._native_decompress_string source, options
+    end
+  end
+end

data/lib/lzws/validation.rb

@@ -0,0 +1,36 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "error"
+
+module LZWS
+  module Validation
+    def self.validate_bool(value)
+      raise ValidateError, "invalid bool" unless value.is_a?(::TrueClass) || value.is_a?(::FalseClass)
+    end
+
+    def self.validate_positive_integer(value)
+      raise ValidateError, "invalid positive integer" unless value.is_a?(::Integer) && value > 0
+    end
+
+    def self.validate_not_negative_integer(value)
+      raise ValidateError, "invalid not negative integer" unless value.is_a?(::Integer) && value >= 0
+    end
+
+    def self.validate_string(value)
+      raise ValidateError, "invalid string" unless value.is_a? ::String
+    end
+
+    def self.validate_io(value)
+      raise ValidateError, "invalid io" unless value.is_a? ::IO
+    end
+
+    def self.validate_hash(value)
+      raise ValidateError, "invalid hash" unless value.is_a? ::Hash
+    end
+
+    def self.validate_proc(value)
+      raise ValidateError, "invalid proc" unless value.is_a?(::Proc) || value.is_a?(::Method) || value.is_a?(::UnboundMethod)
+    end
+  end
+end

data/lib/lzws/version.rb

@@ -0,0 +1,6 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+module LZWS
+  VERSION = "1.0.0".freeze
+end

data/lib/lzws.rb

@@ -0,0 +1,4 @@
+require_relative "lzws/file"
+require_relative "lzws/stream/reader"
+require_relative "lzws/stream/writer"
+require_relative "lzws/string"