Class: Lutaml::Store::Compression

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/store/compression.rb

Constant Summary collapse

SUPPORTED_ALGORITHMS = 
%w[gzip deflate bzip2 lz4 zstd].freeze

Class Method Summary collapse

Class Method Details

.compress(data, algorithm = "gzip", level = 6) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/lutaml/store/compression.rb', line 11

def self.compress(data, algorithm = "gzip", level = 6)
  case algorithm.to_s.downcase
  when "gzip"
    compress_gzip(data, level)
  when "deflate"
    compress_deflate(data, level)
  when "bzip2"
    compress_bzip2(data, level)
  when "lz4"
    compress_lz4(data)
  when "zstd"
    compress_zstd(data, level)
  else
    raise ArgumentError,
          "Unsupported compression algorithm: #{algorithm}. Supported: #{SUPPORTED_ALGORITHMS.join(", ")}"
  end
end

.compress_bzip2(data, level) ⇒ Object 



94
95
96
97
98
99
 
# File 'lib/lutaml/store/compression.rb', line 94

def self.compress_bzip2(data, level)
  require "bzip2-ffi"
  Bzip2::FFI.compress(data, level)
rescue LoadError
  raise ArgumentError, "bzip2-ffi gem is required for bzip2 compression"
end

.compress_deflate(data, level) ⇒ Object 



86
87
88
 
# File 'lib/lutaml/store/compression.rb', line 86

def self.compress_deflate(data, level)
  Zlib::Deflate.deflate(data, level)
end

.compress_gzip(data, level) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/lutaml/store/compression.rb', line 70

def self.compress_gzip(data, level)
  io = StringIO.new
  gz = Zlib::GzipWriter.new(io, level)
  gz.write(data)
  gz.close
  io.string
end

.compress_lz4(data) ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/lutaml/store/compression.rb', line 108

def self.compress_lz4(data)
  require "lz4-ruby"
  LZ4.compress(data)
rescue LoadError
  raise ArgumentError, "lz4-ruby gem is required for LZ4 compression"
end

.compress_zstd(data, level) ⇒ Object 



122
123
124
125
126
127
 
# File 'lib/lutaml/store/compression.rb', line 122

def self.compress_zstd(data, level)
  require "zstd-ruby"
  Zstd.compress(data, level: level)
rescue LoadError
  raise ArgumentError, "zstd-ruby gem is required for Zstd compression"
end

.decompress(data, algorithm = "gzip") ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/lutaml/store/compression.rb', line 29

def self.decompress(data, algorithm = "gzip")
  case algorithm.to_s.downcase
  when "gzip"
    decompress_gzip(data)
  when "deflate"
    decompress_deflate(data)
  when "bzip2"
    decompress_bzip2(data)
  when "lz4"
    decompress_lz4(data)
  when "zstd"
    decompress_zstd(data)
  else
    raise ArgumentError,
          "Unsupported compression algorithm: #{algorithm}. Supported: #{SUPPORTED_ALGORITHMS.join(", ")}"
  end
end

.decompress_bzip2(data) ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/lutaml/store/compression.rb', line 101

def self.decompress_bzip2(data)
  require "bzip2-ffi"
  Bzip2::FFI.decompress(data)
rescue LoadError
  raise ArgumentError, "bzip2-ffi gem is required for bzip2 compression"
end

.decompress_deflate(data) ⇒ Object 



90
91
92
 
# File 'lib/lutaml/store/compression.rb', line 90

def self.decompress_deflate(data)
  Zlib::Inflate.inflate(data)
end

.decompress_gzip(data) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/lutaml/store/compression.rb', line 78

def self.decompress_gzip(data)
  io = StringIO.new(data)
  gz = Zlib::GzipReader.new(io)
  result = gz.read
  gz.close
  result
end

.decompress_lz4(data) ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/lutaml/store/compression.rb', line 115

def self.decompress_lz4(data)
  require "lz4-ruby"
  LZ4.decompress(data)
rescue LoadError
  raise ArgumentError, "lz4-ruby gem is required for LZ4 compression"
end

.decompress_zstd(data) ⇒ Object 



129
130
131
132
133
134
 
# File 'lib/lutaml/store/compression.rb', line 129

def self.decompress_zstd(data)
  require "zstd-ruby"
  Zstd.decompress(data)
rescue LoadError
  raise ArgumentError, "zstd-ruby gem is required for Zstd compression"
end

.detect_algorithm(data) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/lutaml/store/compression.rb', line 47

def self.detect_algorithm(data)
  return nil unless data.is_a?(String)

  # Force binary encoding for magic number detection
  binary_data = data.dup.force_encoding("ASCII-8BIT")

  # Define magic numbers as binary strings
  gzip_magic = "\x1f\x8b".b
  deflate_magic = "\x78".b
  bzip2_magic = "BZ".b
  lz4_magic = "\x04\"M\x18".b
  zstd_magic = "\x28\xb5\x2f\xfd".b

  # Check magic numbers
  return "gzip" if binary_data.start_with?(gzip_magic)
  return "deflate" if binary_data.start_with?(deflate_magic)
  return "bzip2" if binary_data.start_with?(bzip2_magic)
  return "lz4" if binary_data.start_with?(lz4_magic)
  return "zstd" if binary_data.start_with?(zstd_magic)

  nil # No compression detected
end