jekyll-minifier 0.1.10 → 0.2.1

data/spec/coverage_enhancement_spec.rb

@@ -0,0 +1,391 @@
+require 'spec_helper'
+
+describe "Jekyll Minifier - Coverage Enhancement Tests" do
+  let(:overrides) { Hash.new }
+  let(:config) do
+    Jekyll.configuration(Jekyll::Utils.deep_merge_hashes({
+      "full_rebuild" => true,
+      "source"      => source_dir,
+      "destination" => dest_dir,
+      "show_drafts" => true,
+      "url"         => "http://example.org",
+      "name"       => "My awesome site",
+      "jekyll-minifier" => {
+        "compress_html" => true,
+        "compress_css" => true,
+        "compress_javascript" => true,
+        "compress_json" => true
+      }
+    }, overrides))
+  end
+  let(:site) { Jekyll::Site.new(config) }
+
+  before(:each) do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with('JEKYLL_ENV').and_return('production')
+  end
+
+  describe "Configuration Edge Cases" do
+    context "missing configuration" do
+      let(:overrides) { { "jekyll-minifier" => nil } }
+
+      it "handles missing jekyll-minifier configuration gracefully" do
+        expect { site.process }.not_to raise_error
+        expect(File.exist?(dest_dir("assets/css/style.css"))).to be true
+      end
+    end
+
+    context "empty configuration" do
+      let(:overrides) { { "jekyll-minifier" => {} } }
+
+      it "handles empty jekyll-minifier configuration" do
+        expect { site.process }.not_to raise_error
+        expect(File.exist?(dest_dir("assets/css/style.css"))).to be true
+      end
+    end
+
+    context "disabled compression options" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "compress_css" => false,
+            "compress_javascript" => false,
+            "compress_json" => false
+          }
+        }
+      end
+
+      it "respects disabled compression settings" do
+        site.process
+        
+        # When compression is disabled, files should still be processed but not heavily compressed
+        expect(File.exist?(dest_dir("assets/css/style.css"))).to be true
+        expect(File.exist?(dest_dir("assets/js/script.js"))).to be true
+        
+        # Verify CSS compression is disabled by checking if it's still readable/formatted
+        if File.exist?(dest_dir("assets/css/style.css"))
+          processed_css = File.read(dest_dir("assets/css/style.css"))
+          expect(processed_css.length).to be > 0
+          
+          # When disabled, CSS might still be processed but should be more readable
+          # Note: The actual behavior may depend on HTML compressor settings
+        end
+
+        # Verify JS compression is disabled
+        if File.exist?(dest_dir("assets/js/script.js"))
+          processed_js = File.read(dest_dir("assets/js/script.js"))
+          expect(processed_js.length).to be > 0
+        end
+      end
+    end
+
+    context "preserve patterns configuration" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "preserve_patterns" => ["<!-- PRESERVE -->.*?<!-- /PRESERVE -->"]
+          }
+        }
+      end
+
+      it "supports preserve patterns in HTML" do
+        # This would require a test fixture with preserve patterns
+        expect { site.process }.not_to raise_error
+      end
+    end
+
+    context "PHP preservation" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "preserve_php" => true
+          }
+        }
+      end
+
+      it "configures PHP preservation patterns" do
+        expect { site.process }.not_to raise_error
+        # PHP pattern should be added to preserve_patterns
+      end
+    end
+
+    context "HTML compression options" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "remove_comments" => false,
+            "remove_multi_spaces" => true,
+            "remove_intertag_spaces" => true,
+            "simple_doctype" => true,
+            "preserve_line_breaks" => false
+          }
+        }
+      end
+
+      it "respects individual HTML compression options" do
+        site.process
+        
+        html_content = File.read(dest_dir("index.html"))
+        
+        # Verify doctype simplification if enabled
+        expect(html_content).to include("<!DOCTYPE html>")
+        
+        # The exact behavior depends on the HTML content and options
+        expect(html_content.length).to be > 0
+      end
+    end
+  end
+
+  describe "Error Handling Scenarios" do
+    context "file system errors" do
+      it "handles read-only destination directory" do
+        # This would require mocking file system permissions
+        # For now, we verify the basic error doesn't crash the build
+        expect { site.process }.not_to raise_error
+      end
+    end
+
+    context "malformed content" do
+      # These tests would require fixtures with malformed content
+      # Skipping for now as they require specific test files
+      
+      it "handles empty CSS files gracefully" do
+        # Would need an empty CSS file in fixtures
+        expect { site.process }.not_to raise_error
+      end
+
+      it "handles empty JavaScript files gracefully" do
+        # Would need an empty JS file in fixtures  
+        expect { site.process }.not_to raise_error
+      end
+    end
+
+    context "terser compilation errors" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "terser_args" => {
+              "mangle" => true,
+              "compress" => { "drop_console" => true }
+            }
+          }
+        }
+      end
+
+      it "handles valid terser options without errors" do
+        # Valid options should work fine
+        expect { site.process }.not_to raise_error
+        expect(File.exist?(dest_dir("assets/js/script.js"))).to be true
+        
+        # Verify the JS was minified with the specified options
+        js_content = File.read(dest_dir("assets/js/script.js"))
+        expect(js_content.length).to be > 0
+      end
+    end
+  end
+
+  describe "File Type Edge Cases" do
+    context "minified files" do
+      it "skips processing of already minified JavaScript files" do
+        # This would require a .min.js file in fixtures
+        # The file should be copied as-is, not re-minified
+        expect { site.process }.not_to raise_error
+      end
+
+      it "skips processing of already minified CSS files" do
+        # This would require a .min.css file in fixtures
+        # The file should be copied as-is, not re-minified  
+        expect { site.process }.not_to raise_error
+      end
+    end
+
+    context "XML files" do
+      it "processes XML files through HTML compression" do
+        # XML files should use the HTML compressor
+        if File.exist?(dest_dir("atom.xml"))
+          xml_content = File.read(dest_dir("atom.xml"))
+          expect(xml_content.length).to be > 0
+          
+          # Should be compressed (single line)
+          expect(xml_content.lines.count).to be <= 2
+        end
+      end
+    end
+  end
+
+  describe "Exclusion Pattern Testing" do
+    context "with file exclusions" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "exclude" => ["assets/css/style.css"]
+          }
+        }
+      end
+
+      it "excludes specified files from minification" do
+        site.process
+        
+        # The excluded file should exist but may not be heavily minified
+        if File.exist?(dest_dir("assets/css/style.css"))
+          css_content = File.read(dest_dir("assets/css/style.css"))
+          expect(css_content.length).to be > 0
+        end
+      end
+    end
+
+    context "with glob pattern exclusions" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "exclude" => ["assets/**/*.css", "*.json"]
+          }
+        }
+      end
+
+      it "supports glob patterns in exclusions" do
+        expect { site.process }.not_to raise_error
+        
+        # Files matching patterns should be excluded from minification
+        expect(File.exist?(dest_dir("assets/css/style.css"))).to be true
+      end
+    end
+  end
+
+  describe "Environment Variations" do
+    context "non-production environments" do
+      before(:each) do
+        allow(ENV).to receive(:[]).with('JEKYLL_ENV').and_return('development')
+      end
+
+      it "disables all minification in development" do
+        site.process
+        
+        # Files should be processed but not minified
+        if File.exist?(dest_dir("assets/css/style.css"))
+          css_content = File.read(dest_dir("assets/css/style.css"))
+          expect(css_content.length).to be > 0
+        end
+      end
+    end
+
+    context "staging environment" do
+      before(:each) do
+        allow(ENV).to receive(:[]).with('JEKYLL_ENV').and_return('staging')
+      end
+
+      it "disables minification in non-production environments" do
+        expect { site.process }.not_to raise_error
+        
+        # Should not minify in staging
+        if File.exist?(dest_dir("assets/js/script.js"))
+          js_content = File.read(dest_dir("assets/js/script.js"))
+          expect(js_content.length).to be > 0
+        end
+      end
+    end
+  end
+
+  describe "Backward Compatibility Edge Cases" do
+    context "legacy uglifier configuration" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "uglifier_args" => {
+              "harmony" => true,
+              "mangle" => true,
+              "compress" => { "drop_console" => true }
+            }
+          }
+        }
+      end
+
+      it "filters out unsupported uglifier options" do
+        expect { site.process }.not_to raise_error
+        
+        # harmony should be filtered out, other options should work
+        expect(File.exist?(dest_dir("assets/js/script.js"))).to be true
+      end
+    end
+
+    context "mixed configuration" do
+      let(:overrides) do
+        {
+          "jekyll-minifier" => {
+            "terser_args" => { "mangle" => true },
+            "uglifier_args" => { "harmony" => true }
+          }
+        }
+      end
+
+      it "prioritizes terser_args over uglifier_args" do
+        expect { site.process }.not_to raise_error
+        
+        # terser_args should take precedence
+        expect(File.exist?(dest_dir("assets/js/script.js"))).to be true
+      end
+    end
+  end
+
+  describe "Performance and Memory" do
+    it "processes multiple files without memory issues" do
+      # This test verifies that processing doesn't cause memory leaks
+      expect { site.process }.not_to raise_error
+      
+      # All expected files should be created
+      expect(File.exist?(dest_dir("index.html"))).to be true
+      expect(File.exist?(dest_dir("assets/css/style.css"))).to be true
+      expect(File.exist?(dest_dir("assets/js/script.js"))).to be true
+      expect(File.exist?(dest_dir("atom.xml"))).to be true
+    end
+
+    it "maintains reasonable processing time" do
+      start_time = Time.now
+      site.process
+      end_time = Time.now
+      
+      processing_time = end_time - start_time
+      expect(processing_time).to be < 10.0, "Site processing should complete within 10 seconds"
+    end
+  end
+
+  describe "Integration with Jekyll Core" do
+    it "properly integrates with Jekyll Document class" do
+      site.process
+      
+      # Documents should be processed and minified
+      site.documents.each do |doc|
+        dest_path = doc.destination(dest_dir)
+        if File.exist?(dest_path)
+          content = File.read(dest_path)
+          expect(content.length).to be > 0
+        end
+      end
+    end
+
+    it "properly integrates with Jekyll Page class" do
+      site.process
+      
+      # Pages should be processed and minified
+      site.pages.each do |page|
+        dest_path = page.destination(dest_dir)
+        if File.exist?(dest_path)
+          content = File.read(dest_path)
+          expect(content.length).to be > 0
+        end
+      end
+    end
+
+    it "properly integrates with Jekyll StaticFile class" do
+      site.process
+      
+      # Static files should be processed appropriately
+      site.static_files.each do |static_file|
+        dest_path = static_file.destination(dest_dir)
+        if File.exist?(dest_path)
+          expect(File.size(dest_path)).to be > 0
+        end
+      end
+    end
+  end
+end

data/spec/enhanced_css_spec.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+describe "Jekyll Minifier - Enhanced CSS Compression Features" do
+  let(:site) { Jekyll::Site.new(Jekyll.configuration(test_config)) }
+  
+  let(:test_config) do
+    {
+      'source' => File.join(File.dirname(__FILE__), 'fixtures'),
+      'destination' => File.join(File.dirname(__FILE__), 'fixtures/_site'),
+      'jekyll-minifier' => base_minifier_config
+    }
+  end
+  
+  let(:base_minifier_config) do
+    {
+      'compress_css' => true,
+      'compress_javascript' => true,
+      'compress_json' => true
+    }
+  end
+
+  before(:each) do
+    # Set production environment for all tests
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with('JEKYLL_ENV').and_return('production')
+    
+    # Clean up any existing files
+    if Dir.exist?(File.join(File.dirname(__FILE__), 'fixtures/_site'))
+      FileUtils.rm_rf(File.join(File.dirname(__FILE__), 'fixtures/_site'))
+    end
+  end
+
+  describe "Enhanced CSS Configuration" do
+    context "with enhanced mode disabled (default)" do
+      it "uses standard CSS compression by default" do
+        config = Jekyll::Minifier::CompressionConfig.new(site.config)
+        
+        expect(config.css_enhanced_mode?).to be false
+        expect(config.css_enhanced_options).to be nil
+      end
+      
+      it "maintains backward compatibility with existing CSS compression" do
+        site.process
+        
+        css_file = File.join(site.dest, 'assets/css/style.css')
+        expect(File.exist?(css_file)).to be true
+        
+        content = File.read(css_file)
+        expect(content.length).to be > 0
+        expect(content).not_to include('/* Comment */')  # Comments should be removed
+      end
+    end
+
+    context "with enhanced mode enabled" do
+      let(:enhanced_config) do
+        base_minifier_config.merge({
+          'css_enhanced_mode' => true,
+          'css_merge_duplicate_selectors' => true,
+          'css_optimize_shorthand_properties' => true,
+          'css_advanced_color_optimization' => true,
+          'css_preserve_ie_hacks' => true,
+          'css_compress_variables' => true
+        })
+      end
+      
+      let(:test_config) do
+        {
+          'source' => File.join(File.dirname(__FILE__), 'fixtures'),
+          'destination' => File.join(File.dirname(__FILE__), 'fixtures/_site'),
+          'jekyll-minifier' => enhanced_config
+        }
+      end
+
+      it "enables enhanced CSS compression options" do
+        config = Jekyll::Minifier::CompressionConfig.new(site.config)
+        
+        expect(config.css_enhanced_mode?).to be true
+        expect(config.css_merge_duplicate_selectors?).to be true
+        expect(config.css_optimize_shorthand_properties?).to be true
+        expect(config.css_advanced_color_optimization?).to be true
+        expect(config.css_preserve_ie_hacks?).to be true
+        expect(config.css_compress_variables?).to be true
+      end
+      
+      it "generates proper enhanced options hash" do
+        config = Jekyll::Minifier::CompressionConfig.new(site.config)
+        options = config.css_enhanced_options
+        
+        expect(options).to be_a(Hash)
+        expect(options[:merge_duplicate_selectors]).to be true
+        expect(options[:optimize_shorthand_properties]).to be true
+        expect(options[:advanced_color_optimization]).to be true
+        expect(options[:preserve_ie_hacks]).to be true
+        expect(options[:compress_css_variables]).to be true
+      end
+    end
+  end
+
+  describe "Enhanced CSS Compression Functionality" do
+    let(:css_with_optimizations) do
+      %{
+        /* Duplicate selectors */
+        .button {
+          background-color: #ffffff;
+          color: black;
+        }
+        
+        .button {
+          border: 1px solid red;
+          border-radius: 4px;
+        }
+        
+        /* Shorthand optimization opportunities */
+        .box {
+          margin-top: 10px;
+          margin-right: 15px;
+          margin-bottom: 10px;
+          margin-left: 15px;
+        }
+        
+        /* Color optimization */
+        .colors {
+          color: #000000;
+          background: rgba(255, 255, 255, 1.0);
+        }
+      }
+    end
+
+    it "provides better compression with enhanced features" do
+      # Test standard compression
+      standard_config = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => base_minifier_config
+      })
+      
+      standard_compressor = CSSminify2.new
+      standard_result = standard_compressor.compress(css_with_optimizations, nil)
+      
+      # Test enhanced compression
+      enhanced_config = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => base_minifier_config.merge({
+          'css_enhanced_mode' => true,
+          'css_merge_duplicate_selectors' => true,
+          'css_optimize_shorthand_properties' => true,
+          'css_advanced_color_optimization' => true
+        })
+      })
+      
+      enhanced_result = CSSminify2.compress_enhanced(css_with_optimizations, enhanced_config.css_enhanced_options)
+      
+      # Enhanced compression should produce smaller output
+      expect(enhanced_result.length).to be < standard_result.length
+      
+      # Verify that enhancements were applied by checking selector merging
+      button_occurrences_standard = standard_result.scan('.button{').length
+      button_occurrences_enhanced = enhanced_result.scan('.button{').length
+      expect(button_occurrences_enhanced).to be <= button_occurrences_standard
+    end
+  end
+
+  describe "CSSEnhancedWrapper" do
+    it "provides the same interface as CSSminify2 for HTML compressor" do
+      options = {
+        merge_duplicate_selectors: true,
+        optimize_shorthand_properties: true,
+        advanced_color_optimization: true
+      }
+      
+      wrapper = Jekyll::Minifier::CSSEnhancedWrapper.new(options)
+      expect(wrapper).to respond_to(:compress)
+      
+      css = ".test { color: #ffffff; background: #000000; }"
+      result = wrapper.compress(css)
+      
+      expect(result).to be_a(String)
+      expect(result.length).to be > 0
+      expect(result.length).to be < css.length
+    end
+  end
+
+  describe "HTML Inline CSS Enhancement" do
+    let(:enhanced_config) do
+      base_minifier_config.merge({
+        'css_enhanced_mode' => true,
+        'css_merge_duplicate_selectors' => true,
+        'css_advanced_color_optimization' => true
+      })
+    end
+    
+    let(:test_config) do
+      {
+        'source' => File.join(File.dirname(__FILE__), 'fixtures'),
+        'destination' => File.join(File.dirname(__FILE__), 'fixtures/_site'),
+        'jekyll-minifier' => enhanced_config
+      }
+    end
+
+    it "applies enhanced compression to inline CSS in HTML files" do
+      site.process
+      
+      # Check that HTML files are processed and compressed
+      html_files = Dir.glob(File.join(site.dest, '**/*.html'))
+      expect(html_files).not_to be_empty
+      
+      # Verify that files exist and have content
+      html_files.each do |file|
+        content = File.read(file)
+        expect(content.length).to be > 0
+      end
+    end
+  end
+
+  describe "Performance Impact" do
+    let(:large_css) do
+      css_block = %{
+        .component-#{rand(1000)} {
+          color: #ffffff;
+          background: rgba(0, 0, 0, 1.0);
+          margin-top: 10px;
+          margin-right: 10px;
+          margin-bottom: 10px;
+          margin-left: 10px;
+        }
+      }
+      css_block * 100  # Create large CSS
+    end
+
+    it "enhanced compression completes within reasonable time" do
+      enhanced_config = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => base_minifier_config.merge({
+          'css_enhanced_mode' => true,
+          'css_merge_duplicate_selectors' => true,
+          'css_optimize_shorthand_properties' => true,
+          'css_advanced_color_optimization' => true
+        })
+      })
+      
+      start_time = Time.now
+      result = CSSminify2.compress_enhanced(large_css, enhanced_config.css_enhanced_options)
+      end_time = Time.now
+      
+      processing_time = end_time - start_time
+      
+      expect(result.length).to be > 0
+      expect(result.length).to be < large_css.length
+      expect(processing_time).to be < 5.0  # Should complete within 5 seconds
+    end
+  end
+
+  describe "Error Handling and Robustness" do
+    it "handles invalid CSS gracefully with enhanced mode" do
+      invalid_css = "this is not valid css { broken }"
+      
+      enhanced_config = Jekyll::Minifier::CompressionConfig.new({
+        'jekyll-minifier' => base_minifier_config.merge({
+          'css_enhanced_mode' => true,
+          'css_merge_duplicate_selectors' => true
+        })
+      })
+      
+      expect {
+        result = CSSminify2.compress_enhanced(invalid_css, enhanced_config.css_enhanced_options)
+        expect(result).to be_a(String)
+      }.not_to raise_error
+    end
+    
+    it "falls back gracefully when enhanced features are not available" do
+      # This simulates the case where enhanced features might not be loaded
+      css = ".test { color: red; }"
+      
+      # Should not raise an error even if enhanced features aren't available
+      expect {
+        result = CSSminify2.compress(css)
+        expect(result).to be_a(String)
+      }.not_to raise_error
+    end
+  end
+end