RubyGems - jekyll-minifier - Versions diffs - 0.1.10 → 0.2.1 - Mend

jekyll-minifier 0.1.10 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

checksums.yaml +4 -4
data/.dockerignore +8 -0
data/.github/FUNDING.yml +3 -0
data/CLAUDE.md +96 -0
data/COVERAGE_ANALYSIS.md +228 -0
data/Dockerfile +30 -0
data/FINAL_TEST_REPORT.md +164 -0
data/README.md +17 -12
data/SECURITY.md +155 -0
data/SECURITY_FIX_SUMMARY.md +141 -0
data/VALIDATION_FEATURES.md +254 -0
data/cody-mcp.db +0 -0
data/docker-compose.yml +42 -0
data/example_config.yml +127 -0
data/issue48-basic/_config.yml +7 -0
data/issue48-basic/_layouts/default.html +23 -0
data/issue48-basic/assets/css/style.css +10 -0
data/issue48-basic/assets/js/script.js +9 -0
data/issue48-basic/index.html +5 -0
data/jekyll-minifier.gemspec +9 -9
data/lib/jekyll-minifier/version.rb +1 -1
data/lib/jekyll-minifier.rb +1169 -126
data/spec/caching_performance_spec.rb +238 -0
data/spec/compressor_cache_spec.rb +326 -0
data/spec/coverage_enhancement_spec.rb +391 -0
data/spec/enhanced_css_spec.rb +277 -0
data/spec/environment_validation_spec.rb +84 -0
data/spec/fixtures/_config.yml +2 -2
data/spec/fixtures/assets/data.json +25 -0
data/spec/fixtures/assets/js/script.js +21 -0
data/spec/input_validation_spec.rb +514 -0
data/spec/jekyll-minifier_enhanced_spec.rb +211 -0
data/spec/jekyll-minifier_spec.rb +61 -0
data/spec/performance_spec.rb +232 -0
data/spec/security_redos_spec.rb +306 -0
data/spec/security_validation_spec.rb +253 -0
metadata +73 -19

data/spec/caching_performance_spec.rb ADDED Viewed

@@ -0,0 +1,238 @@
+require 'spec_helper'
+require 'benchmark'
+describe "Jekyll::Minifier Caching Performance" do
+  let(:config) { Jekyll::Minifier::CompressionConfig.new({}) }
+  let(:factory) { Jekyll::Minifier::CompressorFactory }
+  let(:cache) { Jekyll::Minifier::CompressorCache }
+  before(:each) do
+    cache.clear_all
+  end
+  after(:all) do
+    Jekyll::Minifier::CompressorCache.clear_all
+  end
+  describe "compressor creation performance" do
+    it "demonstrates significant performance improvement with caching" do
+      iterations = 50
+      # Benchmark without caching (clear cache each time)
+      time_without_caching = Benchmark.realtime do
+        iterations.times do
+          cache.clear_all
+          factory.create_css_compressor(config)
+          factory.create_js_compressor(config)
+          factory.create_html_compressor(config)
+        end
+      end
+      # Benchmark with caching
+      cache.clear_all
+      time_with_caching = Benchmark.realtime do
+        iterations.times do
+          factory.create_css_compressor(config)
+          factory.create_js_compressor(config)
+          factory.create_html_compressor(config)
+        end
+      end
+      puts "\nCaching Performance Results:"
+      puts "Without caching: #{(time_without_caching * 1000).round(2)}ms (#{(time_without_caching * 1000 / iterations).round(2)}ms per iteration)"
+      puts "With caching: #{(time_with_caching * 1000).round(2)}ms (#{(time_with_caching * 1000 / iterations).round(2)}ms per iteration)"
+      improvement_ratio = time_without_caching / time_with_caching
+      puts "Performance improvement: #{improvement_ratio.round(2)}x faster"
+      # Cache should show high hit ratio
+      stats = cache.stats
+      puts "Cache hit ratio: #{(cache.hit_ratio * 100).round(1)}%"
+      puts "Cache statistics: #{stats}"
+      # Verify significant performance improvement
+      expect(improvement_ratio).to be > 2.0, "Caching should provide at least 2x performance improvement"
+      expect(cache.hit_ratio).to be > 0.8, "Cache hit ratio should be above 80%"
+    end
+    it "shows memory efficiency with reasonable cache size" do
+      # Create many different configurations
+      20.times do |i|
+        test_config = Jekyll::Minifier::CompressionConfig.new({
+          'jekyll-minifier' => {
+            'terser_args' => { 'compress' => (i % 2 == 0), 'mangle' => (i % 3 == 0) }
+          }
+        })
+        factory.create_css_compressor(test_config)
+        factory.create_js_compressor(test_config)
+        factory.create_html_compressor(test_config)
+      end
+      sizes = cache.cache_sizes
+      puts "\nMemory Efficiency Results:"
+      puts "Cache sizes: #{sizes}"
+      # Verify cache size limits are respected
+      expect(sizes[:css]).to be <= Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE
+      expect(sizes[:js]).to be <= Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE
+      expect(sizes[:html]).to be <= Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE
+      expect(sizes[:total]).to be <= Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE * 3
+    end
+    it "demonstrates compression performance with cached compressors" do
+      css_content = "body { color: red; background-color: blue; margin: 10px; padding: 5px; }"
+      js_content = "function test() { var message = 'hello world'; console.log(message); return message; }"
+      html_content = "<html><head><title>Test</title></head><body><h1>Test</h1><p>Content</p></body></html>"
+      iterations = 30
+      # Benchmark compression performance with fresh compressors
+      cache.clear_all
+      time_without_cache = Benchmark.realtime do
+        iterations.times do
+          cache.clear_all
+          factory.compress_css(css_content, config, "test.css")
+          factory.compress_js(js_content, config, "test.js")
+        end
+      end
+      # Benchmark compression performance with cached compressors
+      cache.clear_all
+      time_with_cache = Benchmark.realtime do
+        iterations.times do
+          factory.compress_css(css_content, config, "test.css")
+          factory.compress_js(js_content, config, "test.js")
+        end
+      end
+      puts "\nCompression Performance Results:"
+      puts "Without cache: #{(time_without_cache * 1000).round(2)}ms"
+      puts "With cache: #{(time_with_cache * 1000).round(2)}ms"
+      improvement_ratio = time_without_cache / time_with_cache
+      puts "Compression improvement: #{improvement_ratio.round(2)}x faster"
+      # Verify compression performance improvement
+      expect(improvement_ratio).to be > 1.5, "Caching should improve compression performance by at least 50%"
+    end
+    it "maintains thread safety under concurrent load" do
+      threads = []
+      errors = []
+      iterations_per_thread = 10
+      thread_count = 5
+      cache.clear_all
+      # Create multiple threads performing compression
+      thread_count.times do |t|
+        threads << Thread.new do
+          begin
+            iterations_per_thread.times do |i|
+              config_data = {
+                'jekyll-minifier' => {
+                  'terser_args' => { 'compress' => ((t + i) % 2 == 0) }
+                }
+              }
+              test_config = Jekyll::Minifier::CompressionConfig.new(config_data)
+              compressor = factory.create_js_compressor(test_config)
+              result = compressor.compile("function test() { return true; }")
+              Thread.current[:results] = (Thread.current[:results] || []) << result
+            end
+          rescue => e
+            errors << e
+          end
+        end
+      end
+      # Wait for completion
+      threads.each(&:join)
+      # Verify no errors occurred
+      expect(errors).to be_empty, "No thread safety errors should occur: #{errors.inspect}"
+      # Verify all threads got results
+      total_results = threads.sum { |t| (t[:results] || []).length }
+      expect(total_results).to eq(thread_count * iterations_per_thread)
+      puts "\nThread Safety Results:"
+      puts "Threads: #{thread_count}, Iterations per thread: #{iterations_per_thread}"
+      puts "Total operations: #{total_results}"
+      puts "Errors: #{errors.length}"
+      puts "Final cache stats: #{cache.stats}"
+    end
+  end
+  describe "cache behavior validation" do
+    it "properly limits cache size and demonstrates eviction capability" do
+      max_size = Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE
+      # Test cache size limiting by creating configurations we know will be different
+      # Use direct cache interface to verify behavior
+      test_objects = []
+      (1..(max_size + 3)).each do |i|
+        cache_key = "test_key_#{i}"
+        obj = cache.get_or_create(:css, cache_key) { "test_object_#{i}" }
+        test_objects << obj
+      end
+      puts "\nDirect Cache Test Results:"
+      puts "Created #{test_objects.length} objects"
+      puts "Cache sizes: #{cache.cache_sizes}"
+      puts "Cache stats: #{cache.stats}"
+      # Verify cache respects size limits
+      expect(cache.cache_sizes[:css]).to eq(max_size)
+      expect(cache.stats[:evictions]).to be > 0
+      expect(test_objects.length).to eq(max_size + 3)
+      # Test that early entries were evicted
+      first_key_result = cache.get_or_create(:css, "test_key_1") { "recreated_object_1" }
+      expect(first_key_result).to eq("recreated_object_1") # Should be recreated, not cached
+      puts "LRU Eviction confirmed: first entry was evicted and recreated"
+    end
+    it "correctly identifies cache hits vs misses" do
+      config1 = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => { 'terser_args' => { 'compress' => true } }
+      })
+      config2 = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => { 'terser_args' => { 'compress' => false } }
+      })
+      cache.clear_all
+      # First access - should be miss
+      factory.create_js_compressor(config1)
+      stats1 = cache.stats
+      # Second access same config - should be hit
+      factory.create_js_compressor(config1)
+      stats2 = cache.stats
+      # Third access different config - should be miss
+      factory.create_js_compressor(config2)
+      stats3 = cache.stats
+      # Fourth access first config - should be hit
+      factory.create_js_compressor(config1)
+      stats4 = cache.stats
+      puts "\nCache Hit/Miss Tracking:"
+      puts "After 1st call (config1): hits=#{stats1[:hits]}, misses=#{stats1[:misses]}"
+      puts "After 2nd call (config1): hits=#{stats2[:hits]}, misses=#{stats2[:misses]}"
+      puts "After 3rd call (config2): hits=#{stats3[:hits]}, misses=#{stats3[:misses]}"
+      puts "After 4th call (config1): hits=#{stats4[:hits]}, misses=#{stats4[:misses]}"
+      expect(stats1[:misses]).to eq(1)
+      expect(stats1[:hits]).to eq(0)
+      expect(stats2[:hits]).to eq(1)
+      expect(stats3[:misses]).to eq(2)
+      expect(stats4[:hits]).to eq(2)
+    end
+  end
+end

data/spec/compressor_cache_spec.rb ADDED Viewed

@@ -0,0 +1,326 @@
+require 'spec_helper'
+describe "Jekyll::Minifier::CompressorCache" do
+  let(:cache) { Jekyll::Minifier::CompressorCache }
+  before(:each) do
+    # Clear cache before each test
+    cache.clear_all
+  end
+  after(:all) do
+    # Clean up after all tests
+    Jekyll::Minifier::CompressorCache.clear_all
+  end
+  describe "cache key generation" do
+    it "generates consistent keys for identical configurations" do
+      config1 = { terser_args: { compress: true, mangle: false } }
+      config2 = { terser_args: { compress: true, mangle: false } }
+      key1 = cache.generate_cache_key(config1)
+      key2 = cache.generate_cache_key(config2)
+      expect(key1).to eq(key2)
+      expect(key1).to be_a(String)
+      expect(key1.length).to eq(17) # SHA256 truncated to 16 chars + null terminator handling
+    end
+    it "generates different keys for different configurations" do
+      config1 = { terser_args: { compress: true, mangle: false } }
+      config2 = { terser_args: { compress: false, mangle: true } }
+      key1 = cache.generate_cache_key(config1)
+      key2 = cache.generate_cache_key(config2)
+      expect(key1).not_to eq(key2)
+    end
+    it "handles nil and empty configurations" do
+      expect(cache.generate_cache_key(nil)).to eq('default')
+      expect(cache.generate_cache_key({})).to eq('default')
+    end
+  end
+  describe "caching functionality" do
+    it "caches and retrieves compressor objects" do
+      call_count = 0
+      # First call should create new object
+      obj1 = cache.get_or_create(:js, "test_key") do
+        call_count += 1
+        "mock_compressor_#{call_count}"
+      end
+      # Second call should retrieve cached object
+      obj2 = cache.get_or_create(:js, "test_key") do
+        call_count += 1
+        "mock_compressor_#{call_count}"
+      end
+      expect(obj1).to eq(obj2)
+      expect(call_count).to eq(1) # Factory block called only once
+      expect(obj1).to eq("mock_compressor_1")
+    end
+    it "maintains separate caches for different types" do
+      css_obj = cache.get_or_create(:css, "key1") { "css_compressor" }
+      js_obj = cache.get_or_create(:js, "key1") { "js_compressor" }
+      html_obj = cache.get_or_create(:html, "key1") { "html_compressor" }
+      expect(css_obj).to eq("css_compressor")
+      expect(js_obj).to eq("js_compressor")
+      expect(html_obj).to eq("html_compressor")
+      # Each should be independent
+      expect(css_obj).not_to eq(js_obj)
+      expect(js_obj).not_to eq(html_obj)
+    end
+    it "implements LRU eviction when cache is full" do
+      # Fill cache to capacity
+      (1..Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE).each do |i|
+        cache.get_or_create(:js, "key_#{i}") { "compressor_#{i}" }
+      end
+      expect(cache.cache_sizes[:js]).to eq(Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE)
+      # Add one more - should evict oldest
+      cache.get_or_create(:js, "new_key") { "new_compressor" }
+      expect(cache.cache_sizes[:js]).to eq(Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE)
+      expect(cache.stats[:evictions]).to eq(1)
+      # First key should be evicted
+      call_count = 0
+      cache.get_or_create(:js, "key_1") do
+        call_count += 1
+        "recreated_compressor"
+      end
+      expect(call_count).to eq(1) # Had to recreate
+    end
+  end
+  describe "statistics tracking" do
+    it "tracks cache hits and misses" do
+      initial_stats = cache.stats
+      expect(initial_stats[:hits]).to eq(0)
+      expect(initial_stats[:misses]).to eq(0)
+      # First access - should be miss
+      cache.get_or_create(:css, "test") { "compressor" }
+      stats_after_miss = cache.stats
+      expect(stats_after_miss[:misses]).to eq(1)
+      expect(stats_after_miss[:hits]).to eq(0)
+      # Second access - should be hit
+      cache.get_or_create(:css, "test") { "compressor" }
+      stats_after_hit = cache.stats
+      expect(stats_after_hit[:misses]).to eq(1)
+      expect(stats_after_hit[:hits]).to eq(1)
+    end
+    it "calculates hit ratio correctly" do
+      expect(cache.hit_ratio).to eq(0.0) # No operations yet
+      # One miss
+      cache.get_or_create(:css, "test1") { "comp1" }
+      expect(cache.hit_ratio).to eq(0.0)
+      # One hit
+      cache.get_or_create(:css, "test1") { "comp1" }
+      expect(cache.hit_ratio).to eq(0.5)
+      # Another hit
+      cache.get_or_create(:css, "test1") { "comp1" }
+      expect(cache.hit_ratio).to be_within(0.01).of(0.67)
+    end
+  end
+  describe "thread safety" do
+    it "handles concurrent access safely" do
+      threads = []
+      results = {}
+      # Create multiple threads accessing cache concurrently
+      10.times do |i|
+        threads << Thread.new do
+          key = "concurrent_key_#{i % 3}" # Use some duplicate keys
+          result = cache.get_or_create(:js, key) { "compressor_#{key}" }
+          Thread.current[:result] = result
+        end
+      end
+      # Wait for all threads to complete
+      threads.each(&:join)
+      # Collect results
+      threads.each_with_index do |thread, i|
+        results[i] = thread[:result]
+      end
+      # Verify no race conditions occurred
+      expect(results.values.uniq.length).to eq(3) # Should have 3 unique compressors
+      expect(cache.cache_sizes[:js]).to eq(3)
+    end
+  end
+  describe "memory management" do
+    it "limits cache size appropriately" do
+      # Add more than max cache size
+      (1..(Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE + 5)).each do |i|
+        cache.get_or_create(:css, "key_#{i}") { "compressor_#{i}" }
+      end
+      sizes = cache.cache_sizes
+      expect(sizes[:css]).to eq(Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE)
+      expect(sizes[:js]).to eq(0)
+      expect(sizes[:html]).to eq(0)
+      expect(sizes[:total]).to eq(Jekyll::Minifier::CompressorCache::MAX_CACHE_SIZE)
+    end
+    it "clears all caches completely" do
+      # Add some data to each cache
+      cache.get_or_create(:css, "css_key") { "css_comp" }
+      cache.get_or_create(:js, "js_key") { "js_comp" }
+      cache.get_or_create(:html, "html_key") { "html_comp" }
+      expect(cache.cache_sizes[:total]).to eq(3)
+      cache.clear_all
+      expect(cache.cache_sizes[:total]).to eq(0)
+      expect(cache.stats[:hits]).to eq(0)
+      expect(cache.stats[:misses]).to eq(0)
+      expect(cache.stats[:evictions]).to eq(0)
+    end
+  end
+end
+describe "Jekyll::Minifier::CompressorFactory with Caching" do
+  let(:config) { Jekyll::Minifier::CompressionConfig.new({}) }
+  let(:factory) { Jekyll::Minifier::CompressorFactory }
+  let(:cache) { Jekyll::Minifier::CompressorCache }
+  before(:each) do
+    cache.clear_all
+  end
+  after(:all) do
+    Jekyll::Minifier::CompressorCache.clear_all
+  end
+  describe "CSS compressor caching" do
+    it "caches CSS compressors based on configuration" do
+      initial_stats = cache.stats
+      # First call should create new compressor
+      comp1 = factory.create_css_compressor(config)
+      stats_after_first = cache.stats
+      expect(stats_after_first[:misses]).to eq(initial_stats[:misses] + 1)
+      # Second call with same config should return cached compressor
+      comp2 = factory.create_css_compressor(config)
+      stats_after_second = cache.stats
+      expect(stats_after_second[:hits]).to eq(initial_stats[:hits] + 1)
+      # Should be the same object
+      expect(comp1).to be(comp2)
+    end
+    it "creates different compressors for different configurations" do
+      config1 = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => { 'css_enhanced_mode' => false }
+      })
+      config2 = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => {
+          'css_enhanced_mode' => true,
+          'css_merge_duplicate_selectors' => true
+        }
+      })
+      comp1 = factory.create_css_compressor(config1)
+      comp2 = factory.create_css_compressor(config2)
+      # Should be different objects for different configurations
+      expect(comp1).not_to be(comp2)
+    end
+  end
+  describe "JavaScript compressor caching" do
+    it "caches JS compressors based on Terser configuration" do
+      initial_stats = cache.stats
+      comp1 = factory.create_js_compressor(config)
+      stats_after_first = cache.stats
+      expect(stats_after_first[:misses]).to be > initial_stats[:misses]
+      comp2 = factory.create_js_compressor(config)
+      stats_after_second = cache.stats
+      expect(stats_after_second[:hits]).to be > initial_stats[:hits]
+      expect(comp1).to be(comp2)
+    end
+    it "creates different compressors for different Terser configurations" do
+      config1 = Jekyll::Minifier::CompressionConfig.new({})
+      config2 = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => {
+          'terser_args' => { 'compress' => false, 'mangle' => false }
+        }
+      })
+      comp1 = factory.create_js_compressor(config1)
+      comp2 = factory.create_js_compressor(config2)
+      expect(comp1).not_to be(comp2)
+    end
+  end
+  describe "HTML compressor caching" do
+    it "caches HTML compressors based on full configuration" do
+      initial_stats = cache.stats
+      comp1 = factory.create_html_compressor(config)
+      comp2 = factory.create_html_compressor(config)
+      final_stats = cache.stats
+      expect(final_stats[:hits]).to be > initial_stats[:hits]
+      expect(comp1).to be(comp2)
+    end
+  end
+  describe "integration with compression methods" do
+    it "benefits from caching in CSS compression" do
+      css_content = "body { color: red; background-color: blue; }"
+      cache.clear_all
+      initial_stats = cache.stats
+      # First compression
+      result1 = factory.compress_css(css_content, config, "test1.css")
+      # Second compression
+      result2 = factory.compress_css(css_content, config, "test2.css")
+      final_stats = cache.stats
+      expect(final_stats[:hits]).to be > initial_stats[:hits]
+      expect(result1).to eq(result2) # Same compression result
+    end
+    it "benefits from caching in JS compression" do
+      js_content = "function test() { return 'hello world'; }"
+      cache.clear_all
+      initial_stats = cache.stats
+      result1 = factory.compress_js(js_content, config, "test1.js")
+      result2 = factory.compress_js(js_content, config, "test2.js")
+      final_stats = cache.stats
+      expect(final_stats[:hits]).to be > initial_stats[:hits]
+      expect(result1).to eq(result2)
+    end
+  end
+end