nasl-pedant 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d41b8fcbe0898ca2aab9a2fcc9e1a7ef90ca900d
-  data.tar.gz: 0deb90491e2b59d9ebbd38f005306ae1b5aac425
+  metadata.gz: c89304bdba6963cc2f97f76b1ebd0c3a2711966c
+  data.tar.gz: 93ac35fac25ec9d64bc099dbc0babbdc05e2a074
 SHA512:
-  metadata.gz: daa101baef76f0482ce3fec9dc479a40f7b03393bca55a53703a66efbd51debf6e0f6927ed394010f664450965e1f268b1e448d28bf787b276739f5369363103
-  data.tar.gz: 3f650035854cb18e97d652dba398db8e5352efac1386ba3a84551548f691242d58c4972295c89c7c153de612b54044afd49b0e66654e6c6bba29634084dc72e1
+  metadata.gz: 7cbaf855866862610c321bc4c4044459744e7fb334c443ac8e760b85ea363da2d6625963b1b8af33d2f958a4e9c441933d93f64719d37e12a1a69e7f309c409c
+  data.tar.gz: 8a1ebefac1023fbd3790075e684bb4044b2c71ca46e8e06f197bdc0e1287cc5d91f029964a45b6a58c3be8e96239bb929a355f489b2175da8ac6ebbde1644f34

data/lib/pedant/checks/contains_no_duplicate_words.rb

@@ -0,0 +1,81 @@
+################################################################################
+# Copyright (c) 2016, 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 CheckContainsNoDuplicateWords < Check
+    def self.requires
+      # Don't run on local checks, since those are auto-generated and their text
+      # is beyond our direct control.
+      super + [:trees, :plugin_type_remote]
+    end
+
+    def check(file, tree)
+      def check_string(s)
+        # Clone the string so we don't alter the original.
+        text = String.new(s.text)
+
+        # Remove extra whitespace, including newlines.
+        text.gsub!(/\s+/, " ")
+
+        # Other removals may be good here, but they'll need large scale testing
+        # to avoid false alarms.
+
+        # Check for any words that are duplicated.
+        text.match(/\b(\w+)\b \b\1\b/) do |phrase|
+          word = phrase[1]
+
+          # Numbers are tricky to reason about, ignore them.
+          next if word =~ /^\d+$/
+
+          # Next we need to find the original phrase in the original text.
+          # This needs to be able to jump across whitespace and newlines.
+          real_phrase = s.text.match(/#{word}\s+#{word}/m)
+          next if not real_phrase
+
+          # Access the context object for this code.
+          ctx = s.ctx
+
+          # Calculate the region the phrase spans, for the message.
+          loc = s.region.begin + real_phrase.begin(0) .. s.region.begin + real_phrase.end(0) + 1
+          bol = ctx.bol(s.region.begin + real_phrase.begin(0))
+          eol = ctx.eol(s.region.begin + real_phrase.end(0))
+          report(:error, "Phrase with repeated word found: #{ctx.context(loc, bol..eol)}")
+          fail
+        end
+      end
+
+      tree.all(:String).each { |s| check_string(s) }
+    end
+
+    def run
+      # This check will pass by default.
+      pass
+
+      # Run this check on the tree of every file.
+      @kb[:trees].each { |file, tree| check(file, tree) }
+    end
+  end
+end

data/lib/pedant/checks/contains_no_tabs.rb

@@ -40,7 +40,16 @@ module Pedant
 
       return if tab_lines.length == 0
 
-      report(:warn, "Tabs were found in #{file}, on these lines: #{tab_lines.keys.sort.join(', ')}")
+      # Make the consecutive sequences friendlier to read
+      ranges = self.class.chunk_while(tab_lines.keys.sort) { |i, j| i + 1 == j }.map do |group|
+        if group.length == 1
+          group.first.to_s
+        else
+          "#{group.first.to_s}-#{group.last.to_s}"
+        end
+      end
+
+      report(:warn, "Tabs were found in #{file}, on these lines: #{ranges.join(', ')}")
       report(:warn, "Showing up to five lines:")
       tab_lines.keys.sort.first(5).each do |linenum|
         report(:warn, "#{linenum}: #{tab_lines[linenum].gsub(/\t/, Rainbow("    ").background(:red))}")
@@ -56,5 +65,22 @@ module Pedant
       # Run this check on the code in every file.
       @kb[:codes].each { |file, code| check(file, code) }
     end
+
+    # Enumerable#chunk_while in Ruby 2.3 would remove the need for this
+    def self.chunk_while enumerable
+      # If we're passed an array or something...
+      enumerable = enumerable.to_enum unless enumerable.respond_to? :next
+
+      chunks = [[enumerable.next]] rescue [[]]
+      loop do
+        elem = enumerable.next
+        if yield chunks.last.last, elem
+          chunks[-1] << elem
+        else
+          chunks << [elem]
+        end
+      end
+      return chunks
+    end
   end
 end

data/lib/pedant/checks/files_parse_without_errors.rb

@@ -62,10 +62,10 @@ module Pedant
           tree = Nasl::Parser.new.parse(contents, path)
           @kb[:trees][file] = tree
           report(:info, "Parsed contents of #{path}.")
-        rescue Nasl::ParseException, Nasl::TokenException
-          # XXX-MAK: Incorporate the error from the parser, as it gives full,
-          # coloured context.
+        rescue Nasl::ParseException, Nasl::TokenException => e
           report(:error, "Failed to parse #{path}.")
+          report(:error, e.message)
+          report(:error, e.backtrace)
           return fatal
         end
       end

data/lib/pedant/checks/plugin_type_not_specified.rb

@@ -26,10 +26,17 @@
 
 module Pedant
   class CheckPluginTypeNotSpecified < Check
+
+    @@valid_types = ['combined', 'local', 'reputation', 'remote', 'settings', 'summary', 'thirdparty']
+
     def self.requires
       super + [:main, :trees]
     end
 
+    def self.provides
+      super + @@valid_types.map {|t| "plugin_type_#{t}".to_sym}
+    end
+
     def run
       # This check only applies to plugins.
       return skip unless @kb[:main].extname == '.nasl'
@@ -53,11 +60,15 @@ module Pedant
         next if !arg.is_a? Nasl::String
 
         # Ensure that the plugin type is valid.
-        unless ['combined', 'local', 'reputation', 'remote', 'settings', 'summary', 'thirdparty'].include? arg.text
-          report(:info, "Plugin is of unknown type #{arg.text}:\n#{arg.context(node)}")
+        type = arg.text
+        unless @@valid_types.include? type
+          report(:info, "Plugin is of unknown type #{type}:\n#{arg.context(node)}")
           return fail
         end
 
+        # Turn the plugin type into a symbol on which other checks can depend.
+        @kb["plugin_type_#{type}".to_sym] = true
+
         args << [arg, node]
       end
 

data/lib/pedant/version.rb

@@ -1,3 +1,3 @@
 module Pedant
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

data/test/unit/checks/test_contains_no_tabs.rb

@@ -42,4 +42,26 @@ class TestContainsNoTabs < Test::Unit::TestCase
       %Q|\t|
     )
   end
+
+  def test_line_squashing
+    assert_equal(
+      Pedant::CheckContainsNoTabs.chunk_while([1, 2, 3, 5, 6]) { |i, j| i + 1 == j },
+      [[1, 2, 3], [5, 6]]
+    )
+
+    assert_equal(
+      Pedant::CheckContainsNoTabs.chunk_while([1, 3, 5]) { |i, j| i + 1 == j },
+      [[1], [3], [5]]
+    )
+
+    assert_equal(
+      Pedant::CheckContainsNoTabs.chunk_while([1]) { |i, j| i + 1 == j },
+      [[1]]
+    )
+
+    assert_equal(
+      Pedant::CheckContainsNoTabs.chunk_while([]) { |i, j| i + 1 == j },
+      [[]]
+    )
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nasl-pedant
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Mak Kolybabi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-21 00:00:00.000000000 Z
+date: 2016-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -98,6 +98,7 @@ files:
 - lib/pedant/checks/contains_display.rb
 - lib/pedant/checks/contains_ip_address_literals.rb
 - lib/pedant/checks/contains_no_carriage_returns.rb
+- lib/pedant/checks/contains_no_duplicate_words.rb
 - lib/pedant/checks/contains_no_tabs.rb
 - lib/pedant/checks/contains_registration_section.rb
 - lib/pedant/checks/contains_unreachable_code.rb