Lint

.djlintrc

@@ -0,0 +1,14 @@
+{
+  "profile": "golang",
+  "indent": 2,
+  "max_line_length": 120,
+  "format_css": true,
+  "format_js": true,
+  "exclude": "node_modules,public,resources,static,.git",
+  "ignore": "H006,H013,H016,H021,H030,H031,T001,T002",
+  "custom_blocks": "define,block,range,with,if,else,end",
+  "linter_output_format": "### {message}\n{filename}, line {line}, code {code} \n```html\n{match}\n```",
+  "require_pragma": false,
+  "preserve_blank_lines": true,
+  "max_blank_lines": 2
+}

.github/workflows/analysis.yml

@@ -0,0 +1,44 @@
+name: Hugo Static Analysis
+
+on: push
+
+permissions:
+  contents: read
+  pull-requests: write
+  checks: write
+
+jobs:
+  template-lint:
+    name: Lint Hugo Templates
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.13' 
+
+      - name: Install djLint
+        run: pip install djlint
+
+      - name: Lint layouts
+        run: |
+          echo "## djLint" >> report.txt
+          djlint layouts/ >> report.txt || true
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4.1'
+
+      - name: Complexity
+        run: |
+          ruby bin/hugolint.rb >> report.txt || true
+
+      - name: Comment pull request
+        uses: mshick/add-pr-comment@v2
+        with:
+          message-path: |
+            report.txt

.hugolint

@@ -0,0 +1,12 @@
+engines:
+  directories:
+    exclude:
+      - partials/blocks/templates
+  complexity:
+    exclude:
+  lines:
+    exclude:
+  calls:
+    exclude:
+      - partials/projects/single/sidebar.html
+      - partials/blocks/templates/categories.html

bin/hugolint.rb

@@ -0,0 +1,2 @@
+require_relative 'hugolint/analyzer'
+puts Hugolint::Analyzer.run

bin/hugolint/analyzer.rb

@@ -0,0 +1,41 @@
+require_relative 'engines/base'
+require_relative 'engines/complexity'
+require_relative 'engines/directories'
+require_relative 'engines/lines'
+require_relative 'engines/calls'
+require_relative 'file'
+require_relative 'utils'
+require 'yaml'
+
+module Hugolint
+  class Analyzer
+
+    LAYOUTS = './layouts/**/*'
+    CONFIG = '.hugolint'
+
+    def self.run
+      new.to_s
+    end
+
+    def to_s
+      message = "## Hugo analyzer\n"
+      message += Engines::Directories.new(self).to_s
+      message += Engines::Calls.new(self).to_s
+      message += Engines::Lines.new(self).to_s
+      message += Engines::Complexity.new(self).to_s
+      message
+    end
+
+    def paths
+      @paths ||= Dir.glob(LAYOUTS)
+    end
+
+    def files
+      @files ||= paths.map { |path| Hugolint::File.new(path) }
+    end
+
+    def config
+      @config ||= YAML.load_file(CONFIG)
+    end
+  end
+end

bin/hugolint/engines/base.rb

@@ -0,0 +1,54 @@
+module Hugolint
+  module Engines
+    class Base
+      attr_reader :analyzer
+
+      ICON_DANGER = '❌'
+      ICON_WARNING = '⚠️'
+      ICON_OK = '✅'
+
+      def initialize(analyzer)
+        @analyzer = analyzer
+      end
+
+      def analyzed_files
+        unless @analyzed_files
+          @analyzed_files = []
+          analyzer.files.each do |file|
+            next unless should_analyze?(file)
+            @analyzed_files << analyze(file)
+          end
+          sort!
+        end
+        @analyzed_files
+      end
+
+      def to_s
+      end
+
+      protected
+
+      def should_analyze?(file)
+        !files_excluded.include?(file.short_path)
+      end
+
+      def analyze(file)
+      end
+
+      def sort!
+      end
+
+      def engine_identifier
+        self.class.name.split('::').last.downcase
+      end
+
+      def engine_config
+        @engine_config ||= analyzer.config.dig('engines', engine_identifier)
+      end
+
+      def files_excluded
+        @files_excluded ||= engine_config&.dig('exclude') || []
+      end
+    end
+  end
+end

bin/hugolint/engines/calls.rb

@@ -0,0 +1,62 @@
+module Hugolint
+  module Engines
+    class Calls < Base
+
+      ROOT = './layouts/partials/'
+
+      def to_s
+        message = "### Partials calls\n"
+        message += "Partials called once might be in the wrong place. Partials never called might be metaprogrammed, or obsolete.\n"
+        message += "| Id | State | Calls | Fragment | Partial |\n"
+        message += "|---|---|---|---|---|\n"
+        index = 1
+        analyzed_files.each do |file|
+          calls = file.json[:calls]
+          next unless calls[:problem]
+          message += "| cal-#{index} | #{calls[:icon]} | #{calls[:count]} | #{calls[:fragment]} | #{file.short_path} |\n"
+          index += 1
+        end
+        message
+      end
+
+      protected 
+
+      def should_analyze?(file)
+        super &&
+        !file.directory? &&
+        file.path.include?(ROOT)
+      end
+
+      def analyze(file)
+        fragment = file.path.gsub(ROOT, '').gsub('.html', '')
+        call = "partial \"#{fragment}"
+        count = Hugolint::Utils.occurrences_in_files(call, analyzer.files)
+        # Les fichiers ont le droit d'être utilisés 1 seule fois, 
+        # si et seulement si ce ne sont pas des helpers à la racine
+        is_helper = !fragment.include?('/')
+        if count == 0
+          problem = true
+          icon = ICON_DANGER
+        elsif count == 1 && is_helper
+          problem = true
+          icon = ICON_WARNING
+        else
+          problem = false
+          icon = ICON_OK
+        end
+        file.json[:calls] = {
+          fragment: fragment,
+          count: count,
+          problem: problem,
+          icon: icon
+        }
+        file
+      end
+
+      def sort!
+        @analyzed_files.sort_by! { |file| file.json[:calls][:count] }
+                       .reverse!
+      end
+    end
+  end
+end

bin/hugolint/engines/complexity.rb

@@ -0,0 +1,63 @@
+module Hugolint
+  module Engines
+    class Complexity < Base
+
+      KEYWORDS = [
+        'if',
+        'else',
+        'for',
+        'range',
+        'with',
+      ].freeze
+
+      DANGER = 10
+      WARNING = 5
+
+      def to_s
+        message = "### Complexity\n"
+        message += "Cyclomatic complexity should not be too high.\n"
+        message += "| Id | State | Complexity | File |\n"
+        message += "|---|---|---|---|\n"
+        index = 1
+        analyzed_files.each do |file|
+          complexity = file.json[:complexity]
+          next unless complexity[:problem]
+          message += "| cpx-#{index} | #{complexity[:icon]} | #{complexity[:score]} | #{file.short_path} |\n"
+          index += 1
+        end
+        message
+      end
+
+      protected
+
+      def should_analyze?(file)
+        super &&
+        !file.directory?
+      end
+
+      def sort!
+        @analyzed_files.sort_by!{ |file| file.json[:complexity][:score] }.reverse!
+      end
+
+      def analyze(file)
+        score = 1
+        KEYWORDS.each do |keyword|
+          score += Hugolint::Utils.occurences("#{keyword} ", file.data)
+        end
+        problem = score > WARNING
+        icon = ICON_OK
+        if score > DANGER
+          icon = ICON_DANGER
+        elsif score > WARNING
+          icon = ICON_WARNING
+        end
+        file.json[:complexity] = {
+          score: score,
+          icon: icon,
+          problem: problem
+        }
+        file
+      end
+    end
+  end
+end

bin/hugolint/engines/directories.rb

@@ -0,0 +1,53 @@
+module Hugolint
+  module Engines
+    class Directories < Base
+
+      DANGER = 20
+      WARNING = 10
+
+      def to_s
+        message = "### Directories \n"
+        message += "Directories should not contain too many files, it's probably a sign of mess.\n"
+        message += "| Id | State | Files | Directory |\n"
+        message += "|---|---|---|---|\n"
+        index = 1
+        analyzed_files.each do |file|
+          directory = file.json[:directory]
+          next unless directory[:problem]
+          message += "| dir-#{index} | #{directory[:icon]} | #{directory[:count]} | #{file.short_path} |\n"
+          index += 1
+        end
+        message
+      end
+
+      protected 
+
+      def should_analyze?(file)
+        super &&
+        file.directory?
+      end
+
+      def analyze(file)
+        count = Dir["#{file.path}/*.*"].length
+        problem = count > WARNING
+        icon = ICON_OK
+        if count > DANGER
+          icon = ICON_DANGER
+        elsif count > WARNING
+          icon = ICON_WARNING
+        end
+        file.json[:directory] = {
+          count: count,
+          icon: icon,
+          problem: problem
+        }
+        file
+      end
+
+      def sort!
+        @analyzed_files.sort_by! { |file| file.json[:directory][:count] }
+                       .reverse!
+      end
+    end
+  end
+end