yaml-janitor 20251113

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 022b412fb7fefdf3b91aae1bb4d47db513c144e1ddb3e99b6d0b83ee9141ac90
+  data.tar.gz: 0d0f1fd010e75a0bceda041960f03432b283091fb8425b2909d3f0f4beaadc80
+SHA512:
+  metadata.gz: 18655c70a33f9db707541e76d6951bbb98b3f227028f933101ff8dd0ea28d2b0fa319a36af467ccb8b52ea7bb46727ef95d8e6625a5b1d647ebdda6ee4601958
+  data.tar.gz: d48f8f842813eb5538c4e939969736b74b1fc8c2414f7be91d9890108d57336015276c6802b35ee138414e88175305c43cf2b85732e9c8ce95873c893083ad1b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ducks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,185 @@
+# yaml-janitor
+
+A YAML linter built on psych-pure that preserves comments while detecting and
+fixing issues.
+
+## Why?
+
+Traditional YAML tools destroy comments when editing files. yaml-janitor uses
+psych-pure's comment-preserving parser to lint and fix YAML files without
+losing valuable documentation.
+
+## Installation
+
+```bash
+gem install yaml-janitor
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'yaml-janitor'
+```
+
+## Usage
+
+### CLI
+
+Check a single file:
+```bash
+yaml-janitor config.yml
+```
+
+Check all YAML files in a directory:
+```bash
+yaml-janitor containers/
+```
+
+Auto-fix issues:
+```bash
+yaml-janitor --fix config.yml
+```
+
+Run specific rules:
+```bash
+yaml-janitor --rules multiline_certificate config.yml
+```
+
+### Ruby API
+
+```ruby
+require 'yaml_janitor'
+
+# Lint a file
+result = YamlJanitor.lint_file("config.yml")
+result[:violations].each do |violation|
+  puts violation
+end
+
+# Lint and fix
+result = YamlJanitor.lint_file("config.yml", fix: true)
+if result[:fixed]
+  puts "Fixed! New content:\n#{result[:output]}"
+end
+
+# Lint a string
+yaml_string = File.read("config.yml")
+result = YamlJanitor.lint(yaml_string)
+```
+
+## Configuration
+
+Create a `.yaml-janitor.yml` file in your project root:
+
+```yaml
+# Formatting options (applied during --fix)
+indentation: 2
+line_width: 80
+sequence_indent: false
+
+# Rule configuration
+rules:
+  multiline_certificate:
+    enabled: true
+  consistent_indentation:
+    enabled: true
+```
+
+### Configuration Options
+
+**Formatting**:
+- `indentation`: Number of spaces for indentation (default: 2)
+- `line_width`: Maximum line width before wrapping (default: 80)
+- `sequence_indent`: Indent sequences under their key (default: false)
+
+**Rules**:
+- `multiline_certificate`: Detects multi-line certificates in double-quoted strings
+- `consistent_indentation`: Detects and fixes inconsistent indentation
+
+### Command Line Overrides
+
+```bash
+# Override config file settings
+yaml-janitor --indentation 4 --line-width 100 config.yml
+
+# Use a specific config file
+yaml-janitor --config production.yml containers/
+```
+
+## Rules
+
+### multiline_certificate
+
+Detects multi-line certificates embedded in double-quoted strings. This pattern
+triggers a psych-pure parser bug.
+
+```yaml
+# BAD (will trigger violation)
+DISCOURSE_SAML_CERT: "-----BEGIN CERTIFICATE-----
+MIIDGDCCAgCgAwIBAgIVAMP/9hm9Vl3/23QoXrL8hQ31DLwRMA0GCSqGSIb3DQEB
+-----END CERTIFICATE-----"
+
+# GOOD (use block literal style)
+DISCOURSE_SAML_CERT: |
+  -----BEGIN CERTIFICATE-----
+  MIIDGDCCAgCgAwIBAgIVAMP/9hm9Vl3/23QoXrL8hQ31DLwRMA0GCSqGSIb3DQEB
+  -----END CERTIFICATE-----
+```
+
+**Auto-fix**: Not yet implemented (requires psych-pure enhancements)
+
+### consistent_indentation
+
+Detects inconsistent indentation (mixing 2-space, 4-space, etc.) in YAML files.
+
+```yaml
+# BAD (inconsistent: 4 and 8 spaces)
+database:
+    host: "localhost"
+config:
+        timeout: 30
+
+# GOOD (consistent: 2 spaces)
+database:
+  host: "localhost"
+config:
+  timeout: 30
+```
+
+**Auto-fix**: Yes, normalizes to configured indentation (default: 2 spaces)
+
+## Development
+
+### Running Tests
+
+```bash
+# Run integration tests
+ruby -I lib test/integration_test.rb
+
+# Or with rake (if configured)
+bundle install
+bundle exec rake test
+```
+
+### Test Coverage
+
+Integration tests verify:
+- Comment preservation during fixes
+- Indentation normalization
+- Paranoid mode (semantic verification)
+- Config loading and rule enable/disable
+- Multi-line certificate detection
+- Clean files pass without violations
+
+## Background
+
+This tool was built to support YAML comment preservation in Discourse ops
+automation. See the original discussion:
+https://dev.discourse.org/t/should-we-lint-our-yaml-files/33593
+
+Built on top of Kevin Newton's psych-pure gem, which provides a pure Ruby YAML
+parser with comment preservation.
+
+## License
+
+MIT

data/bin/yaml-janitor

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/yaml_janitor"
+
+def print_usage
+  puts <<~USAGE
+    Usage: yaml-janitor [options] <file_or_directory>
+
+    Options:
+      --fix               Auto-fix issues where possible
+      --rules RULES       Comma-separated list of rules (default: all)
+      --config PATH       Path to config file (default: .yaml-janitor.yml)
+      --indentation N     Number of spaces for indentation (default: 2)
+      --line-width N      Maximum line width (default: 80)
+      --help              Show this help message
+
+    Examples:
+      yaml-janitor config.yml
+      yaml-janitor --fix config.yml
+      yaml-janitor --rules multiline_certificate containers/
+      yaml-janitor --config my-config.yml --fix config.yml
+      yaml-janitor --indentation 4 --line-width 100 config.yml
+  USAGE
+  exit 0
+end
+
+# Parse args
+fix = false
+rules = :all
+config_path = nil
+config_overrides = {}
+paths = []
+
+i = 0
+while i < ARGV.length
+  case ARGV[i]
+  when "--fix"
+    fix = true
+  when "--rules"
+    i += 1
+    rules = ARGV[i].split(",").map(&:to_sym)
+  when "--config"
+    i += 1
+    config_path = ARGV[i]
+  when "--indentation"
+    i += 1
+    config_overrides[:indentation] = ARGV[i].to_i
+  when "--line-width"
+    i += 1
+    config_overrides[:line_width] = ARGV[i].to_i
+  when "--help", "-h"
+    print_usage
+  else
+    paths << ARGV[i]
+  end
+  i += 1
+end
+
+if paths.empty?
+  puts "Error: No files or directories specified"
+  print_usage
+end
+
+# Look for default config if not specified
+if !config_path && File.exist?(".yaml-janitor.yml")
+  config_path = ".yaml-janitor.yml"
+end
+
+# Process files
+config = YamlJanitor::Config.new(config_path: config_path, overrides: config_overrides)
+linter = YamlJanitor::Linter.new(rules: rules, config: config)
+total_files = 0
+total_violations = 0
+files_with_violations = []
+
+paths.each do |path|
+  if File.directory?(path)
+    # Process all YAML files in directory
+    yaml_files = Dir.glob(File.join(path, "**", "*.{yml,yaml}"))
+    yaml_files.each do |file|
+      total_files += 1
+      result = linter.lint_file(file, fix: fix)
+
+      if result[:violations].any?
+        files_with_violations << file
+        total_violations += result[:violations].length
+
+        puts "\n#{file}:"
+        result[:violations].each do |violation|
+          puts "  #{violation}"
+        end
+
+        if fix && result[:fixed]
+          puts "  ✓ Fixed"
+        end
+      end
+    end
+  elsif File.file?(path)
+    # Process single file
+    total_files += 1
+    result = linter.lint_file(path, fix: fix)
+
+    if result[:violations].any?
+      files_with_violations << path
+      total_violations += result[:violations].length
+
+      puts "\n#{path}:"
+      result[:violations].each do |violation|
+        puts "  #{violation}"
+      end
+
+      if fix && result[:fixed]
+        puts "  ✓ Fixed"
+      end
+    end
+  else
+    puts "Warning: #{path} not found"
+  end
+end
+
+# Summary
+puts "\n" + "="*60
+puts "Checked #{total_files} files"
+puts "Found #{total_violations} violations in #{files_with_violations.length} files"
+
+if total_violations > 0
+  exit 1
+else
+  puts "✓ All files clean!"
+  exit 0
+end

data/lib/yaml_janitor/config.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module YamlJanitor
+  class Config
+    DEFAULT_CONFIG = {
+      indentation: 2,
+      line_width: 80,
+      sequence_indent: false,
+      rules: {
+        multiline_certificate: { enabled: true },
+        consistent_indentation: { enabled: true }
+      }
+    }.freeze
+
+    attr_reader :config
+
+    def initialize(config_path: nil, overrides: {})
+      @config = deep_dup(DEFAULT_CONFIG)
+      load_config_file(config_path) if config_path
+      merge_overrides(overrides)
+    end
+
+    def indentation
+      @config[:indentation]
+    end
+
+    def line_width
+      @config[:line_width]
+    end
+
+    def sequence_indent
+      @config[:sequence_indent]
+    end
+
+    def rule_enabled?(rule_name)
+      rule_config = @config[:rules][rule_name.to_sym]
+      rule_config && rule_config[:enabled] != false
+    end
+
+    def rule_config(rule_name)
+      @config[:rules][rule_name.to_sym] || {}
+    end
+
+    def dump_options
+      {
+        indentation: indentation,
+        line_width: line_width,
+        sequence_indent: sequence_indent
+      }
+    end
+
+    private
+
+    def load_config_file(path)
+      return unless File.exist?(path)
+
+      file_config = YAML.safe_load(File.read(path), symbolize_names: true)
+      deep_merge!(@config, file_config)
+    rescue => e
+      warn "Warning: Could not load config file #{path}: #{e.message}"
+    end
+
+    def merge_overrides(overrides)
+      deep_merge!(@config, overrides)
+    end
+
+    def deep_dup(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key] = value.is_a?(Hash) ? deep_dup(value) : value
+      end
+    end
+
+    def deep_merge!(hash, other_hash)
+      other_hash.each do |key, value|
+        if value.is_a?(Hash) && hash[key].is_a?(Hash)
+          deep_merge!(hash[key], value)
+        else
+          hash[key] = value
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/yaml_janitor/linter.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module YamlJanitor
+  class Linter
+    attr_reader :rules
+
+    def initialize(rules: :all, config: nil, config_path: nil)
+      @config = config || Config.new(config_path: config_path)
+      @rules = load_rules(rules)
+    end
+
+    # Lint a file, optionally fixing issues
+    def lint_file(path, fix: false)
+      yaml_content = File.read(path)
+      result = lint(yaml_content, fix: fix, file: path)
+
+      if fix && result[:fixed]
+        File.write(path, result[:output])
+      end
+
+      result
+    end
+
+    # Lint YAML content, optionally fixing issues
+    def lint(yaml_content, fix: false, file: nil)
+      violations = []
+
+      # Load with comments
+      loaded = Psych::Pure.load(yaml_content, comments: true)
+
+      # Check for violations
+      @rules.each do |rule|
+        violations += rule.check(loaded, file: file)
+      end
+
+      # Apply fixes if requested
+      output = yaml_content
+      fixed = false
+
+      if fix && violations.any?
+        @rules.each do |rule|
+          rule.fix!(loaded)
+        end
+
+        # Dump back to YAML with configured options
+        output = Psych::Pure.dump(loaded, **@config.dump_options)
+        fixed = true
+
+        # Paranoid mode: verify semantics match
+        verify_semantics!(yaml_content, output)
+      end
+
+      {
+        violations: violations,
+        fixed: fixed,
+        output: output
+      }
+    rescue => e
+      {
+        violations: [Violation.new(
+          rule: :parse_error,
+          message: e.message,
+          file: file
+        )],
+        fixed: false,
+        output: yaml_content,
+        error: e
+      }
+    end
+
+    private
+
+    def load_rules(rule_specs)
+      available_rules = {
+        multiline_certificate: Rules::MultilineCertificate,
+        consistent_indentation: Rules::ConsistentIndentation
+      }
+
+      if rule_specs == :all
+        # Load all enabled rules from config
+        rule_names = available_rules.keys.select do |name|
+          @config.rule_enabled?(name)
+        end
+      elsif rule_specs.is_a?(Array)
+        rule_names = rule_specs
+      else
+        raise Error, "Invalid rules specification: #{rule_specs.inspect}"
+      end
+
+      rule_names.map do |name|
+        rule_class = available_rules[name.to_sym]
+        raise Error, "Unknown rule: #{name}" unless rule_class
+        next unless @config.rule_enabled?(name)
+
+        rule_class.new(@config.rule_config(name))
+      end.compact
+    end
+
+    def verify_semantics!(original, fixed)
+      original_data = YAML.load(original)
+      fixed_data = YAML.load(fixed)
+
+      if original_data != fixed_data
+        raise SemanticMismatchError, "Fixed YAML has different semantics than original"
+      end
+    end
+  end
+end

data/lib/yaml_janitor/rule.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module YamlJanitor
+  class Rule
+    def initialize(config = {})
+      @config = config
+    end
+    # Check for violations in the loaded YAML structure
+    # Returns an array of Violation objects
+    def check(loaded, file: nil)
+      violations = []
+      walk(loaded) do |node, path|
+        if violation = check_node(node, path)
+          violations << Violation.new(
+            rule: rule_name,
+            message: violation,
+            file: file
+          )
+        end
+      end
+      violations
+    end
+
+    # Fix violations in the loaded YAML structure
+    # Modifies the structure in place
+    def fix!(loaded)
+      walk(loaded) do |node, path|
+        fix_node(node, path)
+      end
+    end
+
+    # Override this to check individual nodes
+    def check_node(node, path)
+      nil
+    end
+
+    # Override this to fix individual nodes
+    def fix_node(node, path)
+      # No-op by default
+    end
+
+    # Override this to provide the rule name
+    def rule_name
+      self.class.name.split("::").last.downcase
+    end
+
+    private
+
+    # Walk the YAML structure, yielding each node with its path
+    def walk(node, path = [], &block)
+      yield node, path
+
+      # Handle both regular and LoadedHash/LoadedArray from psych-pure
+      if hash_like?(node)
+        node.each do |key, value|
+          walk(value, path + [key], &block)
+        end
+      elsif array_like?(node)
+        node.each_with_index do |value, index|
+          walk(value, path + [index], &block)
+        end
+      end
+    end
+
+    def hash_like?(node)
+      node.is_a?(Hash) || node.class.name == 'Psych::Pure::LoadedHash'
+    end
+
+    def array_like?(node)
+      node.is_a?(Array) || node.class.name == 'Psych::Pure::LoadedArray'
+    end
+  end
+end

data/lib/yaml_janitor/rules/consistent_indentation.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module YamlJanitor
+  module Rules
+    class ConsistentIndentation < Rule
+      def rule_name
+        "consistent_indentation"
+      end
+
+      # This rule checks the original YAML source for inconsistent indentation
+      # The fix is automatic via Psych::Pure.dump with configured indentation
+      def check(loaded, file: nil)
+        return [] unless file
+
+        # Read the original source
+        source = File.read(file)
+
+        violations = []
+        indentation_levels = detect_indentation_levels(source)
+
+        if indentation_levels.length > 1
+          violations << Violation.new(
+            rule: rule_name,
+            message: "Inconsistent indentation detected: #{indentation_levels.sort.join(', ')} spaces used",
+            file: file
+          )
+        end
+
+        violations
+      end
+
+      # Fix is automatic - Psych::Pure.dump will use configured indentation
+      def fix!(loaded)
+        # No-op - the dumper handles this via config.dump_options
+      end
+
+      private
+
+      def detect_indentation_levels(source)
+        # Track the indentation increment between parent and child
+        indents = []
+        prev_indent = 0
+
+        source.each_line do |line|
+          # Skip empty lines, comments, and document markers
+          next if line.strip.empty?
+          next if line.strip.start_with?('#')
+          next if line.strip.start_with?('---')
+          next if line.strip.start_with?('...')
+          next unless line.include?(':') # Only look at key lines
+
+          # Count leading spaces
+          spaces = 0
+          spaces = line[/^ +/].length if line.start_with?(' ')
+
+          # Calculate the indent increment from previous level
+          if spaces > prev_indent
+            indent_increment = spaces - prev_indent
+            indents << indent_increment
+          end
+
+          prev_indent = spaces if line.strip.end_with?(':')
+        end
+
+        # Find unique indentation increments
+        indents.uniq
+      end
+    end
+  end
+end

data/lib/yaml_janitor/rules/multiline_certificate.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module YamlJanitor
+  module Rules
+    class MultilineCertificate < Rule
+      CERT_PATTERNS = [
+        /BEGIN CERTIFICATE/,
+        /BEGIN RSA PRIVATE KEY/,
+        /BEGIN PRIVATE KEY/,
+        /BEGIN PUBLIC KEY/
+      ].freeze
+
+      def rule_name
+        "multiline_certificate"
+      end
+
+      def check_node(node, path)
+        return unless node.is_a?(String)
+        return unless contains_certificate?(node)
+        return unless has_embedded_newlines?(node)
+
+        key = path.last
+        "Key '#{key}' contains a multi-line certificate in double-quoted format (causes psych-pure bug)"
+      end
+
+      def fix_node(node, path)
+        return unless node.is_a?(String)
+        return unless contains_certificate?(node)
+        return unless has_embedded_newlines?(node)
+
+        # For LoadedObject (psych-pure's wrapper), we need to modify the underlying string
+        if node.respond_to?(:__getobj__)
+          underlying = node.__getobj__
+          # Mark as dirty if it's a LoadedObject
+          node.instance_variable_set(:@dirty, true) if node.respond_to?(:instance_variable_set)
+        else
+          underlying = node
+        end
+
+        # Can't actually fix this yet - psych-pure doesn't support setting style hints on strings
+        # This would need psych-pure to support something like:
+        # node.psych_style = :literal
+        #
+        # For now, just detect the issue
+      end
+
+      private
+
+      def contains_certificate?(string)
+        CERT_PATTERNS.any? { |pattern| string.match?(pattern) }
+      end
+
+      def has_embedded_newlines?(string)
+        string.include?("\n")
+      end
+    end
+  end
+end

data/lib/yaml_janitor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module YamlJanitor
+  VERSION = "20251113"
+end

data/lib/yaml_janitor/violation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module YamlJanitor
+  class Violation
+    attr_reader :rule, :message, :line, :column, :file
+
+    def initialize(rule:, message:, line: nil, column: nil, file: nil)
+      @rule = rule
+      @message = message
+      @line = line
+      @column = column
+      @file = file
+    end
+
+    def to_s
+      location = []
+      location << file if file
+      location << "line #{line}" if line
+      location << "column #{column}" if column
+
+      prefix = location.empty? ? "" : "#{location.join(":")} - "
+      "#{prefix}[#{rule}] #{message}"
+    end
+  end
+end

data/lib/yaml_janitor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "psych/pure"
+require "yaml"
+
+require_relative "yaml_janitor/version"
+require_relative "yaml_janitor/config"
+require_relative "yaml_janitor/linter"
+require_relative "yaml_janitor/rule"
+require_relative "yaml_janitor/violation"
+require_relative "yaml_janitor/rules/multiline_certificate"
+require_relative "yaml_janitor/rules/consistent_indentation"
+
+module YamlJanitor
+  class Error < StandardError; end
+
+  class SemanticMismatchError < Error; end
+
+  class << self
+    # Convenience method to lint a file
+    def lint_file(path, rules: :all, fix: false)
+      linter = Linter.new(rules: rules)
+      linter.lint_file(path, fix: fix)
+    end
+
+    # Convenience method to lint a string
+    def lint(yaml_string, rules: :all, fix: false)
+      linter = Linter.new(rules: rules)
+      linter.lint(yaml_string, fix: fix)
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: yaml-janitor
+version: !ruby/object:Gem::Version
+  version: '20251113'
+platform: ruby
+authors:
+- ducks
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: psych-pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A YAML linter built on psych-pure that can detect and fix common issues
+  while preserving comments
+email:
+- ducks@discourse.org
+executables:
+- yaml-janitor
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/yaml-janitor
+- lib/yaml_janitor.rb
+- lib/yaml_janitor/config.rb
+- lib/yaml_janitor/linter.rb
+- lib/yaml_janitor/rule.rb
+- lib/yaml_janitor/rules/consistent_indentation.rb
+- lib/yaml_janitor/rules/multiline_certificate.rb
+- lib/yaml_janitor/version.rb
+- lib/yaml_janitor/violation.rb
+homepage: https://github.com/ducks/yaml-janitor
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: YAML linter that preserves comments using psych-pure
+test_files: []