Class: Mdlint::Linter::RuleEngine

Inherits:
Object
  • Object
show all
Defined in:
lib/mdlint/linter/rule_engine.rb,
sig/internal.rbs

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ RuleEngine

Returns a new instance of RuleEngine.

Parameters:

  • options (Object) (defaults to: {}) 


8
9
10
11
12
13
14
 
# File 'lib/mdlint/linter/rule_engine.rb', line 8

def initialize(options = {})
  @options = options
  @configured_rules = options[:rules]
  @enabled_rules = Array(options[:rules]).map { |rule| RuleRegistry.normalize_id(rule) } if options[:rules].is_a?(Array)
  @disabled_rules = Array(options[:disable]).map { |rule| RuleRegistry.normalize_id(rule) }
  @violations = []
end

Instance Attribute Details

#violations ⇒ Object (readonly)

Returns the value of attribute violations.



6
7
8
 
# File 'lib/mdlint/linter/rule_engine.rb', line 6

def violations
  @violations
end

Instance Method Details

#active_rules ⇒ Object

Returns:

  • (Object) 


43
44
45
46
47
 
# File 'lib/mdlint/linter/rule_engine.rb', line 43

def active_rules
  RuleRegistry.all.select do |rule_class|
    configured_enabled?(rule_class) && !@disabled_rules.include?(rule_class.rule_id)
  end
end

#check(tokens, source) ⇒ Object

Parameters:

  • tokens (Object)
  • source (Object)

Returns:

  • (Object) 


16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/mdlint/linter/rule_engine.rb', line 16

def check(tokens, source)
  @violations = []

  active_rules.each do |rule_class|
    rule = rule_class.new(rule_options(rule_class))
    rule.check(tokens, source)
    @violations.concat(rule.violations)
  end

  @violations.sort_by(&:line)
end

#configured_enabled?(rule_class) ⇒ Boolean

Parameters:

  • rule_class (Object)

Returns:

  • (Boolean) 


49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/mdlint/linter/rule_engine.rb', line 49

def configured_enabled?(rule_class)
  if rule_class.preset && @options[:preset].to_s != rule_class.preset.to_s
    explicitly_selected = @enabled_rules&.include?(rule_class.rule_id) || explicitly_configured?(rule_class)
    return false unless explicitly_selected
  end
  return @enabled_rules.include?(rule_class.rule_id) if @enabled_rules
  return true unless @configured_rules.is_a?(Hash)

  setting = rule_setting(rule_class)
  setting != false && (!setting.is_a?(Hash) || setting[:enabled] != false)
end

#explicitly_configured?(rule_class) ⇒ Boolean

Parameters:

  • rule_class (Object)

Returns:

  • (Boolean) 


61
62
63
64
65
 
# File 'lib/mdlint/linter/rule_engine.rb', line 61

def explicitly_configured?(rule_class)
  return false unless @configured_rules.is_a?(Hash)

  @configured_rules.any? { |key, _value| RuleRegistry.normalize_id(key) == rule_class.rule_id }
end

#fix(tokens, source) ⇒ Object

Parameters:

  • tokens (Object)
  • source (Object)

Returns:

  • (Object) 


28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/mdlint/linter/rule_engine.rb', line 28

def fix(tokens, source)
  result = source
  current_tokens = tokens

  active_rules.each do |rule_class|
    rule = rule_class.new(rule_options(rule_class))
    result = rule.fix(current_tokens, result)
    current_tokens = Parser.parse(result, @options) if result != source
  end

  result
end

#rule_options(rule_class) ⇒ Object

Parameters:

  • rule_class (Object)

Returns:

  • (Object) 


67
68
69
70
71
72
73
74
 
# File 'lib/mdlint/linter/rule_engine.rb', line 67

def rule_options(rule_class)
  setting = rule_setting(rule_class)
  setting = {} unless setting.is_a?(Hash)
  global_options = @options.reject { |key, _value| %i[rules disable].include?(key) }
  setting = global_options.merge(setting.transform_keys(&:to_sym))
  setting[:severity] ||= @options[:severity] if @options[:severity]
  setting
end

#rule_setting(rule_class) ⇒ Object

Parameters:

  • rule_class (Object)

Returns:

  • (Object) 


76
77
78
79
80
81
82
 
# File 'lib/mdlint/linter/rule_engine.rb', line 76

def rule_setting(rule_class)
  return nil unless @configured_rules.is_a?(Hash)

  @configured_rules.find do |key, _value|
    RuleRegistry.normalize_id(key) == rule_class.rule_id
  end&.last
end