omnizip 0.3.1

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/benchmark/README.md

@@ -0,0 +1,260 @@
+# Omnizip Benchmark Suite
+
+Comprehensive benchmark suite comparing omnizip performance against native
+7-Zip.
+
+## Purpose
+
+This benchmark suite provides:
+
+* Performance comparison between omnizip (Ruby) and 7-Zip (C)
+* Compression ratio analysis for each algorithm
+* Filter effectiveness measurements
+* Baseline for future optimization work
+
+## Requirements
+
+* Ruby 2.7 or higher
+* 7-Zip CLI tool (`7z` or `7za`) installed (optional but recommended)
+* Omnizip gem dependencies installed (`bundle install`)
+
+## Installation
+
+Install 7-Zip for comparisons:
+
+```bash
+# macOS
+brew install p7zip
+
+# Ubuntu/Debian
+sudo apt-get install p7zip-full
+
+# Windows
+# Download from https://www.7-zip.org/
+```
+
+## Running Benchmarks
+
+### Quick Start
+
+Run all benchmarks:
+
+```bash
+ruby benchmark/run_benchmarks.rb
+```
+
+Run quick benchmarks (1 size, 1 data type):
+
+```bash
+ruby benchmark/run_benchmarks.rb --quick
+```
+
+### Options
+
+* `-v`, `--verbose` - Enable verbose output
+* `-q`, `--quick` - Run quick benchmarks (faster, less coverage)
+* `--compression-only` - Run only compression algorithm benchmarks
+* `--filters-only` - Run only filter benchmarks
+* `--output=FILE` - Save results to JSON file
+* `-h`, `--help` - Show help message
+
+### Examples
+
+```bash
+# Verbose output with JSON results
+ruby benchmark/run_benchmarks.rb --verbose --output=results.json
+
+# Quick compression-only benchmark
+ruby benchmark/run_benchmarks.rb --quick --compression-only
+
+# Full benchmark with results saved
+ruby benchmark/run_benchmarks.rb --output=benchmark/results/full.json
+```
+
+## What Gets Benchmarked
+
+### Compression Algorithms
+
+* **LZMA** - Lempel-Ziv-Markov chain algorithm
+* **LZMA2** - Improved LZMA with better multithreading
+* **PPMd7** - Prediction by partial matching
+* **BZip2** - Burrows-Wheeler transform compression
+
+### Filters
+
+* **BCJ x86** - Branch/Call/Jump filter for x86 executables
+* **Delta** - Delta encoding for gradual data
+
+### Data Types
+
+* **Text** - Lorem ipsum text data
+* **Source Code** - Ruby source code
+* **Repetitive** - Highly compressible repetitive patterns
+* **Random** - Incompressible random data
+
+### Test Sizes
+
+* 1KB (1,024 bytes)
+* 10KB (10,240 bytes)
+* 100KB (102,400 bytes)
+
+## Interpreting Results
+
+### Compression Ratio
+
+```
+Compression Ratio = Original Size / Compressed Size
+```
+
+Higher is better. Example: 3.0x means data compressed to 1/3 original size.
+
+### Size Difference
+
+Shows how much larger/smaller omnizip output is compared to 7-Zip:
+
+* Positive % = omnizip produces larger files
+* Negative % = omnizip produces smaller files (better)
+
+Expect omnizip to be within 10-20% of 7-Zip size.
+
+### Speed Ratio
+
+```
+Speed Ratio = Omnizip Time / 7-Zip Time
+```
+
+Shows how many times slower omnizip is compared to 7-Zip.
+
+* Expected: 5-20x slower (Ruby vs C is normal)
+* < 10x = Good performance for Ruby implementation
+* > 20x = May need optimization
+
+## Expected Performance Characteristics
+
+### Compression Ratios
+
+Omnizip should achieve similar compression ratios to 7-Zip (within 10-20%)
+because both implement the same algorithms. Differences come from:
+
+* Parameter tuning differences
+* Implementation details
+* Ruby vs C precision differences
+
+### Speed
+
+Ruby implementations are typically 5-20x slower than C implementations:
+
+* **5-10x slower** = Excellent for Ruby
+* **10-15x slower** = Good for Ruby
+* **15-20x slower** = Acceptable for Ruby
+* **> 20x slower** = May indicate optimization opportunities
+
+### Algorithm-Specific Notes
+
+* **LZMA/LZMA2**: Most complex, expect larger speed differences
+* **BZip2**: Simpler algorithm, may have better speed ratios
+* **PPMd7**: Memory-intensive, speed depends on implementation details
+
+## Architecture
+
+The benchmark suite follows object-oriented architecture:
+
+```
+benchmark/
+├── models/              # Data models
+│   ├── benchmark_result.rb      # Single benchmark result
+│   └── comparison_result.rb     # Omnizip vs 7-Zip comparison
+├── test_data.rb                 # Test data generator
+├── compression_bench.rb         # Algorithm benchmarks
+├── filter_bench.rb              # Filter benchmarks
+├── benchmark_suite.rb           # Main orchestrator
+├── reporter.rb                  # Results formatting
+└── run_benchmarks.rb            # Executable runner
+```
+
+## Output Format
+
+### Console Output
+
+```
+================================================================================
+OMNIZIP vs 7-ZIP BENCHMARK RESULTS
+================================================================================
+
+--------------------------------------------------------------------------------
+Test: lzma_text
+--------------------------------------------------------------------------------
+Metric                         Omnizip           7-Zip
+--------------------------------------------------------------------------------
+Input Size                       10.0KB           10.0KB
+Compressed Size                   3.5KB            3.2KB
+Compression Ratio                 2.86             3.13
+Compression Time                2.500s           0.150s
+
+--------------------------------------------------------------------------------
+Comparison:
+--------------------------------------------------------------------------------
+  Size difference: +300 bytes (+9.4%)
+  Speed ratio: 16.7x slower
+```
+
+### JSON Output
+
+```json
+{
+  "timestamp": "2025-10-26T12:00:00Z",
+  "results": [
+    {
+      "test_name": "lzma_text",
+      "omnizip": {
+        "algorithm": "lzma",
+        "input_size": 10240,
+        "compressed_size": 3584,
+        "compression_ratio": 2.86,
+        "compression_time": 2.5
+      },
+      "seven_zip": { ... },
+      "comparison": {
+        "size_difference_bytes": 300,
+        "size_difference_percentage": 9.4,
+        "compression_speed_ratio": 16.7
+      }
+    }
+  ]
+}
+```
+
+## Troubleshooting
+
+### 7-Zip Not Found
+
+If 7-Zip is not installed, benchmarks will still run but comparisons will show
+"7-Zip not available". Install 7-Zip for full comparisons.
+
+### Slow Benchmarks
+
+Use `--quick` flag for faster results with less coverage, or run specific
+benchmark types with `--compression-only` or `--filters-only`.
+
+### Memory Issues
+
+Large test files (100KB+) with complex algorithms may use significant memory.
+Reduce test sizes in `benchmark_suite.rb` if needed.
+
+## Future Enhancements
+
+* Add decompression benchmarks
+* Test larger file sizes (1MB, 10MB)
+* Add multi-threaded benchmarks
+* Compare memory usage
+* Add visualization/charts
+
+## Contributing
+
+When adding new benchmarks:
+
+1. Follow object-oriented design patterns
+2. Use model classes for data representation
+3. Maintain separation of concerns
+4. Add documentation for new features
+5. Run `bundle exec rubocop` before committing

data/benchmark/benchmark_suite.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "test_data"
+require_relative "compression_bench"
+require_relative "filter_bench"
+require_relative "reporter"
+
+module Benchmark
+  # Main orchestrator for running all benchmarks
+  class BenchmarkSuite
+    TEST_SIZES = [1024, 10_240, 102_400].freeze # 1KB, 10KB, 100KB
+    DATA_TYPES = %w[text source_code repetitive random].freeze
+
+    attr_reader :verbose, :results
+
+    def initialize(verbose: false, quick: false)
+      @verbose = verbose
+      @quick = quick
+      @test_data = TestData.new
+      @compression_bench = CompressionBench.new(verbose: verbose)
+      @filter_bench = FilterBench.new(verbose: verbose)
+      @results = []
+    end
+
+    def run_all
+      puts "Starting Omnizip vs 7-Zip benchmark suite..."
+      puts "7-Zip available: #{@compression_bench.seven_zip_available?}"
+
+      generate_test_data
+      run_compression_benchmarks
+      run_filter_benchmarks
+      cleanup_test_data
+
+      self
+    end
+
+    def run_compression_only
+      puts "Running compression benchmarks only..."
+      generate_test_data
+      run_compression_benchmarks
+      cleanup_test_data
+      self
+    end
+
+    def run_filters_only
+      puts "Running filter benchmarks only..."
+      generate_test_data
+      run_filter_benchmarks
+      cleanup_test_data
+      self
+    end
+
+    def report
+      Reporter.new(@results).print_summary
+    end
+
+    def save_results(filename)
+      Reporter.new(@results).save_to_file(filename)
+    end
+
+    private
+
+    def generate_test_data
+      puts "\nGenerating test data..." if verbose
+
+      sizes = @quick ? [TEST_SIZES.first] : TEST_SIZES
+      types = @quick ? [DATA_TYPES.first] : DATA_TYPES
+
+      sizes.each do |size|
+        types.each do |type|
+          @test_data.public_send("generate_#{type}", size,
+                                 filename: "#{type}_#{size}.dat")
+        end
+      end
+    end
+
+    def run_compression_benchmarks
+      puts "\nRunning compression benchmarks..." if verbose
+
+      sizes = @quick ? [TEST_SIZES.first] : TEST_SIZES
+      types = @quick ? [DATA_TYPES.first] : DATA_TYPES
+      algos = @quick ? ["lzma"] : CompressionBench::ALGORITHMS
+
+      algos.each do |algorithm|
+        sizes.each do |size|
+          types.each do |type|
+            filename = "#{type}_#{size}.dat"
+            filepath = File.join(@test_data.data_dir, filename)
+
+            result = @compression_bench.benchmark_algorithm(
+              algorithm, filepath, type
+            )
+            @results << result
+          end
+        end
+      end
+    end
+
+    def run_filter_benchmarks
+      puts "\nRunning filter benchmarks..." if verbose
+
+      return if @quick
+
+      sizes = [TEST_SIZES[1]]
+      types = %w[source_code]
+
+      FilterBench::FILTERS.each do |filter|
+        sizes.each do |size|
+          types.each do |type|
+            filename = "#{type}_#{size}.dat"
+            filepath = File.join(@test_data.data_dir, filename)
+
+            result = @filter_bench.benchmark_filter(filter, filepath, type)
+            @results << result
+          end
+        end
+      end
+    end
+
+    def cleanup_test_data
+      puts "\nCleaning up test data..." if verbose
+      @test_data.cleanup
+    end
+  end
+end

data/benchmark/compression_bench.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "tempfile"
+require "fileutils"
+require_relative "models/benchmark_result"
+require_relative "models/comparison_result"
+
+module Benchmark
+  # Benchmarks compression algorithms against native 7-Zip
+  class CompressionBench
+    ALGORITHMS = %w[lzma lzma2 ppmd7 bzip2].freeze
+    ITERATIONS = 3
+
+    attr_reader :verbose
+
+    def initialize(verbose: false)
+      @verbose = verbose
+      @seven_zip_available = check_seven_zip_availability
+    end
+
+    def seven_zip_available?
+      @seven_zip_available
+    end
+
+    def benchmark_algorithm(algorithm, input_file, input_type)
+      puts "Benchmarking #{algorithm} on #{input_type}..." if verbose
+
+      omnizip_result = benchmark_omnizip(algorithm, input_file, input_type)
+      seven_zip_result = if seven_zip_available?
+                           benchmark_seven_zip(algorithm, input_file,
+                                               input_type)
+                         else
+                           create_unavailable_result(algorithm, input_file,
+                                                     input_type)
+                         end
+
+      Models::ComparisonResult.new(
+        test_name: "#{algorithm}_#{input_type}",
+        omnizip_result: omnizip_result,
+        seven_zip_result: seven_zip_result,
+      )
+    end
+
+    private
+
+    def check_seven_zip_availability
+      system("which 7z > /dev/null 2>&1") ||
+        system("which 7za > /dev/null 2>&1")
+    end
+
+    def get_7z_command
+      @get_7z_command ||= if system("which 7z > /dev/null 2>&1")
+                            "7z"
+                          elsif system("which 7za > /dev/null 2>&1")
+                            "7za"
+                          end
+    end
+
+    def benchmark_omnizip(algorithm, input_file, input_type)
+      input_size = File.size(input_file)
+      compressed_file = create_temp_file(".7z")
+
+      begin
+        time = measure_time do
+          compress_with_omnizip(algorithm, input_file, compressed_file)
+        end
+
+        compressed_size = if File.exist?(compressed_file)
+                            File.size(compressed_file)
+                          end
+
+        Models::BenchmarkResult.new(
+          algorithm: algorithm,
+          input_size: input_size,
+          input_type: input_type,
+          compressed_size: compressed_size,
+          compression_time: time,
+        )
+      rescue StandardError => e
+        Models::BenchmarkResult.new(
+          algorithm: algorithm,
+          input_size: input_size,
+          input_type: input_type,
+          error: e.message,
+        )
+      ensure
+        FileUtils.rm_f(compressed_file)
+      end
+    end
+
+    def benchmark_seven_zip(algorithm, input_file, input_type)
+      input_size = File.size(input_file)
+      compressed_file = create_temp_file(".7z")
+
+      begin
+        time = measure_time do
+          compress_with_7z(algorithm, input_file, compressed_file)
+        end
+
+        compressed_size = if File.exist?(compressed_file)
+                            File.size(compressed_file)
+                          end
+
+        Models::BenchmarkResult.new(
+          algorithm: algorithm,
+          input_size: input_size,
+          input_type: input_type,
+          compressed_size: compressed_size,
+          compression_time: time,
+        )
+      rescue StandardError => e
+        Models::BenchmarkResult.new(
+          algorithm: algorithm,
+          input_size: input_size,
+          input_type: input_type,
+          error: e.message,
+        )
+      ensure
+        FileUtils.rm_f(compressed_file)
+      end
+    end
+
+    def create_unavailable_result(algorithm, input_file, input_type)
+      Models::BenchmarkResult.new(
+        algorithm: algorithm,
+        input_size: File.size(input_file),
+        input_type: input_type,
+        error: "7-Zip not available",
+      )
+    end
+
+    def compress_with_omnizip(algorithm, input_file, output_file)
+      require_relative "../lib/omnizip"
+
+      algo_class = case algorithm
+                   when "lzma" then Omnizip::Algorithms::LZMA
+                   when "lzma2" then Omnizip::Algorithms::LZMA2
+                   when "ppmd7" then Omnizip::Algorithms::PPMd7
+                   when "bzip2" then Omnizip::Algorithms::BZip2
+                   else raise "Unknown algorithm: #{algorithm}"
+                   end
+
+      input = File.binread(input_file)
+      compressed = algo_class.compress(input)
+      File.binwrite(output_file, compressed)
+    end
+
+    def compress_with_7z(algorithm, input_file, output_file)
+      method_flag = case algorithm
+                    when "lzma" then "LZMA"
+                    when "lzma2" then "LZMA2"
+                    when "ppmd7" then "PPMd"
+                    when "bzip2" then "BZip2"
+                    else raise "Unknown algorithm: #{algorithm}"
+                    end
+
+      cmd = "#{get_7z_command} a -m0=#{method_flag} -mx=5 #{output_file} " \
+            "#{input_file} > /dev/null 2>&1"
+      success = system(cmd)
+      raise "7z compression failed" unless success
+    end
+
+    def measure_time(&block)
+      times = []
+      ITERATIONS.times do
+        time = ::Benchmark.realtime(&block)
+        times << time
+      end
+      times.sum / times.size
+    end
+
+    def create_temp_file(extension)
+      temp = Tempfile.new(["benchmark", extension])
+      path = temp.path
+      temp.close
+      temp.unlink
+      path
+    end
+  end
+end