nasl-pedant 0.0.4 → 0.0.5

data/lib/pedant/checks/conditional_contains_assignment.rb

@@ -0,0 +1,82 @@
+################################################################################
+# Copyright (c) 2014, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+module Pedant
+  class CheckConditionalContainsAssignment < Check
+    def self.requires
+      super + [:trees]
+    end
+
+    def check(file, tree)
+      def walk(node, root)
+        # Assignments of literals are the most likely to be bugs (determined empiracally).
+        literals = [
+          Nasl::String,
+          Nasl::Integer,
+          Nasl::Identifier,
+          Nasl::Ip,
+        ]
+
+        # 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) }
+        end
+
+        if node.is_a?(Nasl::Assignment)
+          # A bit of a kludge, here. Because assignment has such a low precedence, we can see two
+          # different scenarios: the simpler scenario, where the Assignment's expr is the literal
+          # being assigned. Example:
+          #   if (a = 5) { ... }  ->  node.expr == <Nasl::Integer>:5
+          #
+          # In the other scenario, the literal being assigned gets "absorbed" into an Expression
+          # with the higher-precedence operators. Example:
+          #   if (a = 5 && foo == bar) { ... }  ->  node.expr     == <Nasl::Expression>
+          #                                         node.expr.lhs == <Nasl::Integer>:5
+          #
+          # In this second case, we can look for the literal in the Expression's left-hand side.
+          if literals.include?(node.expr.class) or
+             node.expr.is_a?(Nasl::Expression) && literals.include?(node.expr.lhs.class)
+
+            fail
+            report(:error, "A conditional statement contains an assignment operation.")
+            report(:error, node.op.context(root))
+          end
+        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
+
+    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
+  end
+end

data/lib/pedant/checks/conditional_or_loop_is_empty.rb

@@ -39,6 +39,7 @@ module Pedant
           fail
 
           report(:error, "#{cls} loop in #{file} has an empty statement as its body.")
+          report(:error, node.body.context(node))
         end
       end
 
@@ -55,6 +56,7 @@ module Pedant
           fail
 
           report(:error, "If statement in #{file} has an empty statement as #{name} branch.")
+          report(:error, branch.context(node))
         end
       end
     end

data/lib/pedant/checks/confusing_variable_names.rb

@@ -0,0 +1,104 @@
+################################################################################
+# Copyright (c) 2014, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+require 'set'
+
+module Pedant
+  class CheckConfusingVariableNames < Check
+    def self.requires
+      super + [:trees]
+    end
+
+    def check(file, tree)
+      # Two identifiers with the same normalization are likely to be confused.
+      # E.g.: CA_list and ca_list, certlist and cert_list
+      def normalize name
+        name.gsub(/_/, '').downcase
+      end
+
+      # Set of all declared and assigned-to names in the source.
+      names = Set.new
+
+      # Handle all local_var and global_var occurrences (both assignments and declarations).
+      (tree.all(:Global) + tree.all(:Local)).each do |decl|
+        decl.idents.each do |node|
+          names << node.name      if node.is_a? Nasl::Identifier
+          names << node.lval.name if node.is_a? Nasl::Assignment
+        end
+      end
+
+      # Add every identifier from every assigned-to Nasl::Lvalue to the set of names.
+      tree.all(:Assignment).map(&:lval).each do |lval|
+        # Generate a nested array of Nasl::Identifier, representing the tree structure
+        # of a Nasl::Lvalue.
+        def lval_to_arr(lval)
+          return lval if not lval.is_a?(Nasl::Lvalue)
+          return [lval.ident, lval.indexes.map { |lval| lval_to_arr(lval)} ]
+        end
+
+        if lval.is_a?(Nasl::Lvalue)
+          lval_to_arr(lval).flatten.each do |node|
+            names << node.name if node.is_a?(Nasl::Identifier)
+          end
+        end
+
+        if lval.is_a?(Nasl::Identifier)
+          names << lval.name
+        end
+      end
+
+      # Group names together that have the same normalized form.
+      confusable_name_groups = {}
+      names.each do |name|
+        key = normalize(name)
+        confusable_name_groups[key] ||= Set.new
+        confusable_name_groups[key] << name
+      end
+
+      # Throw away the normalized forms, all we care about now is the groups.
+      confusable_name_groups = confusable_name_groups.values
+
+      # We only care about groups with more than one name in them.
+      confusable_name_groups.map!(&:to_a).select! { |group| group.length > 1 }
+
+      return if confusable_name_groups.length == 0
+
+      warn
+      report(:error, "These sets of names differ only by capitalization or underscores:")
+      confusable_name_groups.each do |names|
+        report(:error, "  #{names.join(', ')}")
+      end
+    end
+
+    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
+  end
+end

data/lib/pedant/checks/contains_unreachable_code.rb

@@ -39,22 +39,30 @@ module Pedant
           if node.is_a?(Nasl::Break) || node.is_a?(Nasl::Continue) || node.is_a?(Nasl::Return) || (node.is_a?(Nasl::Call) && node.name.ident.name == 'exit' && node.name.indexes == [])
             # If this is not the final node in the list, then there is
             # absolutely no way for the later nodes to be accessed.
-            if node != list.last
-              report(:error, "#{file} contains unreachable code.")
-              return fail
-            end
+            return node if node != list.last
           end
         end
+        return nil
       end
 
       # Unreachable statements occur only when there are sequential lists of
       # instructions. In layers deeper than the outermost level of indentation,
       # this only occurs in Blocks.
-      tree.all(:Block).each { |blk| check_statements(file, blk.body) }
+      tree.all(:Block).each do |blk|
+        node = check_statements(file, blk.body)
+        if not node.nil?
+          fail
+          report(:error, node.context(blk))
+        end
+      end
 
       # The main body of a file is not a Block, so it must be considered
       # separately.
-      check_statements(file, tree)
+      node = check_statements(file, tree)
+      if not node.nil?
+        fail
+        report(:error, node.context(node))
+      end
     end
 
     def run

data/lib/pedant/checks/flipped_operands_on_match_or_substring.rb

@@ -0,0 +1,80 @@
+################################################################################
+# Copyright (c) 2015, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+module Pedant
+  class CheckFlippedOperandsOnMatchOrSubstring < Check
+    def self.requires
+      super + [:trees]
+    end
+
+    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)
+
+          if ["=~", "!~"].include?(node.op.body)
+            side = :lhs
+            opposite = :rhs
+          end
+
+          if ["><", ">!<"].include?(node.op.body)
+            side = :rhs
+            opposite = :lhs
+          end
+
+          return if side.nil?
+
+          # The check for no indexes is to account for this uncommon-but-in-use
+          # pattern, to check that a character falls into a certain subset of
+          # acceptable characters:
+          #
+          #   tolower(xml[index]) >< "abcdefghijklmnopqrstuvwxyz:_"
+          #
+          if node.send(side).is_a?(Nasl::String) && node.send(opposite).is_a?(Nasl::Lvalue) && node.send(opposite).indexes == []
+            warn
+            report(:error, "A '#{node.op.body}' operator has a literal string on the #{if side == :lhs then 'left' else 'right' end}-hand side.")
+            report(:error, "The operands may be accidentally swapped.")
+            report(:error, node.send(side).context(node))
+          end
+        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
+
+    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
+  end
+end

data/lib/pedant/version.rb

@@ -1,3 +1,3 @@
 module Pedant
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/test/unit/checks/test_conditional_contains_assignment.rb

@@ -0,0 +1,93 @@
+################################################################################
+# Copyright (c) 2014, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+class TestConditionalContainsAssignment < Test::Unit::TestCase
+  include Pedant::Test
+
+  def test_none
+    check(
+      :pass,
+      :CheckConditionalContainsAssignment,
+      %q||
+    )
+  end
+
+  def test_literal_integer
+    check(
+      :fail,
+      :CheckConditionalContainsAssignment,
+      %q|if (a = 5) { exit(); }|
+    )
+  end
+
+  def test_literal_integer_while
+    check(
+      :fail,
+      :CheckConditionalContainsAssignment,
+      %q|while (a = 5) { exit(); }|
+    )
+  end
+
+  def test_literal_string
+    check(
+      :fail,
+      :CheckConditionalContainsAssignment,
+      %q|if (a = "foo") { exit(); }|
+    )
+  end
+
+  def test_complex_literal_rhs
+    check(
+      :fail,
+      :CheckConditionalContainsAssignment,
+      %q|if (((foobar > 2 && (a = 1 && b < 2)) && foo.bar == bar.foo) && baz == 2) { exit(); }|
+    )
+  end
+
+  def test_complex_literal_lhs
+    check(
+      :fail,
+      :CheckConditionalContainsAssignment,
+      %q|if (((foobar > 2 && (c == 2 && a = 1 && b < 2)) && foo.bar == bar.foo) && baz == 2) { exit(); }|
+    )
+  end
+
+  def test_complex_non_literal
+    check(
+      :pass,
+      :CheckConditionalContainsAssignment,
+      %q|if (((foobar > 2 && (a = one && b < 2)) && foo.bar == bar.foo) && baz == 2) { exit(); }|
+    )
+  end
+
+  def test_non_literal
+    check(
+      :pass,
+      :CheckConditionalContainsAssignment,
+      %q|if ((a = get_oracle_homes()) == "somestring") { exit(); }|
+    )
+  end
+end

data/test/unit/checks/test_confusing_variable_names.rb

@@ -0,0 +1,113 @@
+################################################################################
+# Copyright (c) 2014, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+class TestConfusingVariableNames < Test::Unit::TestCase
+  include Pedant::Test
+
+  def test_does
+    check(
+      :pass,
+      :CheckConfusingVariableNames,
+      %q||
+    )
+  end
+
+  def test_does_not
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|local_var CA_list; calist = 1;|
+    )
+  end
+
+  def test_var_types
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|local_var ca_list; CA_list = 1;|
+    )
+
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|global_var ca_list; CA_list = 1;|
+    )
+
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|global_var ca_list; function foo() { local_var CA_list; }|
+    )
+  end
+
+  def test_underscores
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|global_var ca_list; calist = 1;|
+    )
+
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|global_var ca__list; calist = 1;|
+    )
+  end
+
+  def test_capitalization
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|global_var calist; CAlist = 1;|
+    )
+
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|global_var CA_list; ca_list = 1;|
+    )
+  end
+
+  def test_lvalue_idents
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|ca_list.CA_list = 1;|
+    )
+
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|ca_list[foo.bar[CA_list]] = 1;|
+    )
+
+    check(
+      :warn,
+      :CheckConfusingVariableNames,
+      %q|ca_list[foo.CA_list[10 + "woo"]] = 1;|
+    )
+  end
+end

data/test/unit/checks/test_flipped_operands_on_match_or_substring.rb

@@ -0,0 +1,77 @@
+################################################################################
+# Copyright (c) 2015, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+class TestFlippedOperandsOnMatchOrSubstring < Test::Unit::TestCase
+  include Pedant::Test
+
+  def test_none
+    check(
+      :pass,
+      :CheckFlippedOperandsOnMatchOrSubstring,
+      %q||
+    )
+  end
+
+  def test_no_op
+    check(
+      :pass,
+      :CheckFlippedOperandsOnMatchOrSubstring,
+      %q|if (a == b) exit(0);|
+    )
+  end
+
+  def test_simple_substring
+    check(
+      :warn,
+      :CheckFlippedOperandsOnMatchOrSubstring,
+      %q|if (a >< 'woo') exit(0);|
+    )
+  end
+
+  def test_simple_substring_indexed
+    check(
+      :pass,
+      :CheckFlippedOperandsOnMatchOrSubstring,
+      %q|if (a[i] >< 'woo') exit(0);|
+    )
+  end
+
+  def test_simple_match
+    check(
+      :warn,
+      :CheckFlippedOperandsOnMatchOrSubstring,
+      %q|if ('woo' =~ a) exit(0);|
+    )
+  end
+
+  def test_complex_match
+    check(
+      :warn,
+      :CheckFlippedOperandsOnMatchOrSubstring,
+      %q|if ('woo' >< a && 'woo' =~ a) exit(0);|
+    )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nasl-pedant
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2015-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -83,7 +83,9 @@ files:
 - bin/pedant
 - lib/pedant.rb
 - lib/pedant/check.rb
+- lib/pedant/checks/conditional_contains_assignment.rb
 - lib/pedant/checks/conditional_or_loop_is_empty.rb
+- lib/pedant/checks/confusing_variable_names.rb
 - lib/pedant/checks/contains_ip_address_literals.rb
 - lib/pedant/checks/contains_no_carriage_returns.rb
 - lib/pedant/checks/contains_no_tabs.rb
@@ -91,6 +93,7 @@ files:
 - lib/pedant/checks/contains_unreachable_code.rb
 - lib/pedant/checks/ends_with_newline.rb
 - lib/pedant/checks/files_parse_without_errors.rb
+- lib/pedant/checks/flipped_operands_on_match_or_substring.rb
 - lib/pedant/checks/local_variable_unused.rb
 - lib/pedant/checks/parse_test_code.rb
 - lib/pedant/checks/plugin_type_not_specified.rb
@@ -108,13 +111,16 @@ files:
 - lib/pedant/version.rb
 - pedant.gemspec
 - test/test_helper.rb
+- test/unit/checks/test_conditional_contains_assignment.rb
 - test/unit/checks/test_conditional_or_loop_is_empty.rb
+- test/unit/checks/test_confusing_variable_names.rb
 - test/unit/checks/test_contains_ip_address_literals.rb
 - test/unit/checks/test_contains_no_carriage_returns.rb
 - test/unit/checks/test_contains_no_tabs.rb
 - test/unit/checks/test_contains_registration_section.rb
 - test/unit/checks/test_contains_unreachable_code.rb
 - test/unit/checks/test_ends_with_newline.rb
+- test/unit/checks/test_flipped_operands_on_match_or_substring.rb
 - test/unit/checks/test_plugin_type_not_specified.rb
 - test/unit/checks/test_script_family_not_specified.rb
 homepage: http://github.com/tenable/pedant
@@ -130,12 +136,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 333689523
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 333689523
 requirements: []
 rubyforge_project: nasl-pedant
 rubygems_version: 1.8.23
@@ -144,13 +156,15 @@ specification_version: 3
 summary: A framework for the Nessus Attack Scripting Language.
 test_files:
 - test/test_helper.rb
+- test/unit/checks/test_conditional_contains_assignment.rb
 - test/unit/checks/test_conditional_or_loop_is_empty.rb
+- test/unit/checks/test_confusing_variable_names.rb
 - test/unit/checks/test_contains_ip_address_literals.rb
 - test/unit/checks/test_contains_no_carriage_returns.rb
 - test/unit/checks/test_contains_no_tabs.rb
 - test/unit/checks/test_contains_registration_section.rb
 - test/unit/checks/test_contains_unreachable_code.rb
 - test/unit/checks/test_ends_with_newline.rb
+- test/unit/checks/test_flipped_operands_on_match_or_substring.rb
 - test/unit/checks/test_plugin_type_not_specified.rb
 - test/unit/checks/test_script_family_not_specified.rb
-has_rdoc: