lz_string 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 536eca3d25c94ce1558bd881c8f09dfa5dab331a7d3c3da19a5166681ad2ac41
+  data.tar.gz: 86d3a24237c3e1654b9b3c29bf7978435e68cf4caa6a22a66b04472ac222b3df
+SHA512:
+  metadata.gz: 311b8e802592b7c364c43f031c89b6fa104b76637c2679d6a0d7f8955ffd40e63e55d48543e9f371f64a38e23e6bdce9d1a7b3985057b10a8717ca699b89cdcb
+  data.tar.gz: d1e2f28b4c9ed85483254ed7d7f8f90cdb438f112b115e0f893be9a91986714990805acd1ba0a2126bf92e79a60b19660ac98c5e953903cd3c678d6511e822a6

data/README.md

@@ -0,0 +1,2 @@
+# lz-string
+Ruby implementation of LZ-String compression algorithm

data/lib/lz_string/base.rb

@@ -0,0 +1,397 @@
+module LZString
+  # Base compression class.
+  class Base
+    # @param uncompressed      [String]
+    # @param bits_per_char     [Integer]
+    # @param get_char_from_int [Integer]
+    def self.compress(uncompressed, bits_per_char, get_char_from_int)
+      return "" if uncompressed.nil?
+
+      i, value, ii = nil
+      context_dictionary = {}
+      context_dictionary_to_create = {}
+      context_c = ""
+      context_wc = ""
+      context_w = ""
+      # Compensate for the first entry which should not count
+      context_enlarge_in = 2
+      context_dict_size = 3
+      context_num_bits = 2
+      context_data = []
+      context_data_val = 0
+      context_data_position = 0
+
+      for ii in 0...uncompressed.length do
+        context_c = uncompressed[ii]
+
+        if (!context_dictionary.has_key?(context_c))
+          context_dictionary[context_c] = context_dict_size
+          context_dictionary_to_create[context_c] = true
+          context_dict_size += 1
+        end
+
+        context_wc = context_w + context_c
+        if (context_dictionary.has_key?(context_wc))
+          context_w = context_wc
+        else
+          if (context_dictionary_to_create.has_key?(context_w))
+            if (context_w[0].ord < 256)
+              for i in 0...context_num_bits do
+                context_data_val = (context_data_val << 1)
+                if (context_data_position == bits_per_char - 1)
+                  context_data_position = 0
+                  context_data.push(get_char_from_int[context_data_val])
+                  context_data_val = 0
+                else
+                  context_data_position += 1
+                end
+              end
+
+              value = context_w[0].ord
+              for i in 0...8 do
+                context_data_val = (context_data_val << 1) | (value & 1)
+                if (context_data_position == bits_per_char - 1)
+                  context_data_position = 0
+                  context_data.push(get_char_from_int[context_data_val])
+                  context_data_val = 0
+                else
+                  context_data_position += 1
+                end
+                value = value >> 1
+              end
+            else
+              value = 1
+              for i in 0...context_num_bits do
+                context_data_val = (context_data_val << 1) | value
+                if (context_data_position == bits_per_char-1)
+                  context_data_position = 0
+                  context_data.push(get_char_from_int[context_data_val])
+                  context_data_val = 0
+                else
+                  context_data_position += 1
+                end
+                value = 0
+              end
+              value = context_w[0].ord
+              for i in 0...16 do
+                context_data_val = (context_data_val << 1) | (value & 1)
+                if (context_data_position == bits_per_char - 1)
+                  context_data_position = 0
+                  context_data.push(get_char_from_int[context_data_val])
+                  context_data_val = 0
+                else
+                  context_data_position += 1
+                end
+                value = value >> 1
+              end
+            end
+            context_enlarge_in -= 1
+            if (context_enlarge_in == 0)
+              context_enlarge_in = 2**context_num_bits
+              context_num_bits += 1
+            end
+            context_dictionary_to_create.delete(context_w)
+          else
+            value = context_dictionary[context_w]
+            for i in 0...context_num_bits do
+              context_data_val = (context_data_val << 1) | (value & 1)
+              if (context_data_position == bits_per_char - 1)
+                context_data_position = 0
+                context_data.push(get_char_from_int[context_data_val])
+                context_data_val = 0
+              else
+                context_data_position += 1
+              end
+              value = value >> 1
+            end
+          end
+
+          context_enlarge_in -= 1
+
+          if (context_enlarge_in == 0)
+            context_enlarge_in = 2**context_num_bits
+            context_num_bits += 1
+          end
+
+          # Add wc to the dictionary.
+          context_dictionary[context_wc] = context_dict_size
+          context_dict_size += 1
+          context_w = context_c.to_s
+        end
+      end
+
+      # Output the code for w.
+      if (context_w != "")
+        if (context_dictionary_to_create.has_key?(context_w))
+          if (context_w[0].ord < 256)
+            for i in 0...context_num_bits do
+              context_data_val = (context_data_val << 1)
+              if (context_data_position == bits_per_char-1)
+                context_data_position = 0
+                context_data.push(get_char_from_int[context_data_val])
+                context_data_val = 0
+              else
+                context_data_position += 1
+              end
+            end
+            value = context_w[0].ord
+            for i in 0...8 do
+              context_data_val = (context_data_val << 1) | (value & 1)
+              if (context_data_position == bits_per_char-1)
+                context_data_position = 0
+                context_data.push(get_char_from_int[context_data_val])
+                context_data_val = 0
+              else
+                context_data_position += 1
+              end
+              value = value >> 1
+            end
+          else
+            value = 1
+            for i in 0...context_num_bits do
+              context_data_val = (context_data_val << 1) | value
+              if (context_data_position == bits_per_char-1)
+                context_data_position = 0
+                context_data.push(get_char_from_int[context_data_val])
+                context_data_val = 0
+              else
+                context_data_position += 1
+              end
+              value = 0
+            end
+            value = context_w[0].ord
+            for i in 0...16 do
+              context_data_val = (context_data_val << 1) | (value & 1)
+              if (context_data_position == bits_per_char-1)
+                context_data_position = 0
+                context_data.push(get_char_from_int[context_data_val])
+                context_data_val = 0
+              else
+                context_data_position += 1
+              end
+              value = value >> 1
+            end
+          end
+          context_enlarge_in -= 1
+          if (context_enlarge_in == 0)
+            context_enlarge_in = 2**context_num_bits
+            context_num_bits += 1
+          end
+          context_dictionary_to_create.delete(context_w)
+        else
+          value = context_dictionary[context_w]
+          for i in 0...context_num_bits
+            context_data_val = (context_data_val << 1) | (value & 1)
+            if (context_data_position == bits_per_char-1)
+              context_data_position = 0
+              context_data.push(get_char_from_int[context_data_val])
+              context_data_val = 0
+            else
+              context_data_position += 1
+            end
+            value = value >> 1
+          end
+        end
+
+        context_enlarge_in -= 1
+        if (context_enlarge_in == 0)
+          context_enlarge_in = 2**context_num_bits
+          context_num_bits += 1
+        end
+      end
+
+      # Mark the end of the stream
+      value = 2
+      for i in 0...context_num_bits do
+        context_data_val = (context_data_val << 1) | (value & 1)
+        if (context_data_position == bits_per_char - 1)
+          context_data_position = 0
+          context_data.push(get_char_from_int[context_data_val])
+          context_data_val = 0
+        else
+          context_data_position += 1
+        end
+        value = value >> 1
+      end
+
+      # Flush the last char
+      while (true)
+        context_data_val = (context_data_val << 1)
+        if (context_data_position == bits_per_char-1)
+          context_data.push(get_char_from_int[context_data_val])
+          break
+        else
+          context_data_position += 1
+        end
+      end
+
+      return context_data.join("")
+    end
+
+    # @param length         [Integer]
+    # @param reset_value    [Integer]
+    # @param get_next_value [Proc]
+    def self.decompress(length, reset_value, get_next_value, encoding = "ASCII-8BIT")
+      dictionary = [0, 1, 2]
+      enlarge_in = 4
+      dict_size = 4
+      num_bits = 3
+      entry = ""
+      result = []
+      data = {
+        val: get_next_value[(0)],
+        position: reset_value,
+        index: 1
+      }
+      bits = 0
+      maxpower = 2**2
+      power = 1
+      i, w, resb, c = nil
+
+      while (power != maxpower)
+        resb = data[:val] & data[:position]
+        data[:position] >>= 1
+        if (data[:position] == 0)
+          data[:position] = reset_value
+          data[:val] = get_next_value[data[:index]]
+          data[:index] += 1
+        end
+        bits |= (resb > 0 ? 1 : 0) * power
+        power <<= 1
+      end
+
+      case(n = bits)
+      when 0
+        bits = 0
+        maxpower = 2**8
+        power = 1
+        while power != maxpower
+          resb = data[:val] & data[:position]
+          data[:position] >>= 1
+          if (data[:position] == 0)
+            data[:position] = reset_value
+            data[:val] = get_next_value[data[:index]]
+            data[:index] += 1
+          end
+          bits |= (resb > 0 ? 1 : 0) * power
+          power <<= 1
+        end
+        c = bits.chr(encoding)
+      when 1
+        bits = 0
+        maxpower = 2*16
+        power = 1
+        while (power != maxpower)
+          resb = data[:val] & data[:position]
+          data[:position] >>= 1
+          if (data[:position] == 0)
+              data[:position] = reset_value
+              data[:val] = get_next_value[data[:index]]
+              data[:index] += 1
+          end
+          bits |= (resb > 0 ? 1 : 0) * power
+          power <<= 1
+        end
+        c = bits.chr(encoding)
+      when 2
+        ""
+      end
+
+      dictionary[3] = c
+      w = c
+      result << c
+
+      while(true)
+        return "" if (data[:index] > length)
+
+        bits = 0
+        maxpower = 2**num_bits
+        power = 1
+        while (power != maxpower)
+          resb = data[:val] & data[:position]
+          data[:position] >>= 1
+          if (data[:position] == 0)
+            data[:position] = reset_value
+            data[:val] = get_next_value[data[:index]]
+            data[:index] += 1
+          end
+          bits |= (resb > 0 ? 1 : 0) * power
+          power <<= 1
+        end
+
+        case(c = bits)
+        when 0
+          bits = 0
+          maxpower = 2**8
+          power = 1
+          while (power != maxpower)
+            resb = data[:val] & data[:position]
+            data[:position] >>= 1
+            if (data[:position] == 0)
+              data[:position] = reset_value
+              data[:val] = get_next_value[data[:index]]
+              data[:index] += 1
+            end
+            bits |= (resb > 0 ? 1 : 0) * power
+            power <<= 1
+          end
+
+          dictionary[dict_size] = bits.chr(encoding)
+          dict_size += 1
+          c = dict_size - 1
+          enlarge_in -= 1
+        when 1
+          bits = 0
+          maxpower = 2**16
+          power = 1
+          while (power != maxpower)
+            resb = data[:val] & data[:position]
+            data[:position] >>= 1
+            if (data[:position] == 0)
+              data[:position] = reset_value
+              data[:val] = get_next_value[data[:index]]
+              data[:index] += 1
+            end
+            bits |= (resb > 0 ? 1 : 0) * power
+            power <<= 1
+          end
+          dictionary[dict_size] = bits.chr(encoding)
+          dict_size += 1
+          c = dict_size - 1
+          enlarge_in -= 1
+        when 2
+          return result.join("")
+        end
+
+        if (enlarge_in == 0)
+          enlarge_in = 2**num_bits
+          num_bits += 1
+        end
+
+        if (dictionary[c])
+          entry = dictionary[c]
+        else
+          if (c === dict_size)
+              entry = w + w[0]
+          else
+            return nil
+          end
+        end
+
+        result << entry
+
+        # Add w+entry[0] to the dictionary.
+        dictionary[dict_size] = w + entry[0]
+        dict_size += 1
+        enlarge_in -= 1
+
+        w = entry
+
+        if (enlarge_in == 0)
+          enlarge_in = 2**num_bits
+          num_bits += 1
+        end
+      end
+    end
+  end
+end

data/lib/lz_string/base64.rb

@@ -0,0 +1,51 @@
+module LZString
+  # Base64 compressing algorithm.
+  class Base64
+    # Base64 alphabet.
+    KEY_STR_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+
+    # @param input [String]
+    def self.compress(input)
+      return "" if input.nil?
+
+      res = LZString::Base.compress(input, 6, lambda { |a| KEY_STR_BASE64[a] })
+
+      # To produce valid Base64
+      case (res.length % 4)
+      when 0 then res
+      when 1 then res + "==="
+      when 2 then res + "=="
+      when 3 then res + "="
+      end
+    end
+
+    # @param compressed [String]
+    def self.decompress(compressed)
+      return "" if compressed.nil?
+      return nil if compressed == ""
+
+      LZString::Base.decompress(
+        compressed.length,
+        32,
+        lambda { |index| get_base_value(KEY_STR_BASE64, compressed[index]) }
+      )
+    end
+
+    # @param alphabet  [String]
+    # @param character [String]
+    def self.get_base_value(alphabet, character)
+      base_reverse_dic = {}
+
+      if (!base_reverse_dic[alphabet])
+        base_reverse_dic[alphabet] = {}
+        for i in 0...alphabet.length do
+          base_reverse_dic[alphabet][alphabet[i]] = i
+        end
+      end
+
+      base_reverse_dic[alphabet][character]
+    end
+
+    private_class_method :get_base_value
+  end
+end

data/lib/lz_string/utf16.rb

@@ -0,0 +1,24 @@
+module LZString
+  # UTF16 compressing algorithm.
+  class UTF16
+    # @param input [String]
+    def self.compress(input)
+      return "" if (input == nil)
+
+      LZString::Base.compress(input, 15, lambda { |a| (a + 32).chr("UTF-8") }) + " "
+    end
+
+    # @param compressed [String]
+    def self.decompress(compressed)
+      return "" if (compressed == nil)
+      return nil if (compressed == "")
+
+      LZString::Base.decompress(
+        compressed.length,
+        16384,
+        lambda { |index| compressed[index].ord - 32 },
+        "UTF-8"
+      )
+    end
+  end
+end

data/lib/lz_string/version.rb

@@ -0,0 +1,4 @@
+module LZString
+  # :nodoc:
+  VERSION = "0.1.0"
+end

data/lib/lz_string.rb

@@ -0,0 +1,23 @@
+require "pry"
+require "lz_string/base"
+require "lz_string/base64"
+require "lz_string/utf16"
+require "lz_string/version"
+
+# LZ-based compression algorithm.
+module LZString
+  # @param input [String]
+  def self.compress(input)
+    return "" if input.nil?
+
+    LZString::Base.compress(input, 16, lambda { |a| a.chr("UTF-8") })
+  end
+
+  # @param compressed [String]
+  def self.decompress(compressed)
+    return "" if compressed.nil?
+    return nil if compressed == ""
+
+    LZString::Base.decompress(compressed.length, 32768, lambda { |index| compressed[index].ord })
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: lz_string
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Altivi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-05 00:00:00.000000000 Z
+dependencies: []
+description: Ruby implementation of LZ-String compression algorithm
+email:
+- altivi.prog@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/lz_string.rb
+- lib/lz_string/base.rb
+- lib/lz_string/base64.rb
+- lib/lz_string/utf16.rb
+- lib/lz_string/version.rb
+homepage: https://github.com/Altivi/lz-string
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of LZ-String compression algorithm
+test_files: []