Class: Pedant::CheckEqualityWithRegex

Inherits:
Check
  • Object
show all
Defined in:
lib/pedant/checks/equality_with_regex.rb

Instance Attribute Summary

Attributes inherited from Check

#result

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Check

all, depends, #fail, #fatal, friendly_name, inherited, #initialize, initialize!, list, #pass, provides, ready?, #report, run_checks_in_dependency_order, #skip, #warn

Constructor Details

This class inherits a constructor from Pedant::Check

Class Method Details

.requires ⇒ Object 



29
30
31
 
# File 'lib/pedant/checks/equality_with_regex.rb', line 29

def self.requires
  super + [:trees]
end

Instance Method Details

#check(file, tree) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/pedant/checks/equality_with_regex.rb', line 33

def check(file, tree)
  def walk(node, root)
    # Recursively descend into the right-hand and left-hand sides of each expression.
    if node.is_a? Nasl::Expression
      [:lhs, :rhs].each { |side| walk(node.send(side), root) }

      return unless node.op.is_a?(Nasl::Token)
      return unless ["==", "!="].include?(node.op.body)
      return unless node.rhs.is_a?(Nasl::String)
      str = node.rhs.text
      return unless str.length > 2
      return unless str[0] == "^" and str[-1] == "$"

      fail
      report(:error, "An equality comparison is being made with what appears to be a regex.")
      report(:error, "This might be a typo in the operator.")
      report(:error, node.op.context(node))
    end
  end

  cond_stmts = [:For, :Repeat, :While, :If].map { |cls| tree.all(cls) }.flatten
  cond_stmts.each { |cond_stmt| walk(cond_stmt.cond, cond_stmt) }
end

#run ⇒ Object 



57
58
59
60
61
62
63
 
# File 'lib/pedant/checks/equality_with_regex.rb', line 57

def run
  # This check will pass by default.
  pass

  # Run this check on the tree from every file.
  @kb[:trees].each { |file, tree| check(file, tree) }
end

#walk(node, root) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/pedant/checks/equality_with_regex.rb', line 34

def walk(node, root)
  # Recursively descend into the right-hand and left-hand sides of each expression.
  if node.is_a? Nasl::Expression
    [:lhs, :rhs].each { |side| walk(node.send(side), root) }

    return unless node.op.is_a?(Nasl::Token)
    return unless ["==", "!="].include?(node.op.body)
    return unless node.rhs.is_a?(Nasl::String)
    str = node.rhs.text
    return unless str.length > 2
    return unless str[0] == "^" and str[-1] == "$"

    fail
    report(:error, "An equality comparison is being made with what appears to be a regex.")
    report(:error, "This might be a typo in the operator.")
    report(:error, node.op.context(node))
  end
end