puppet-lint 0.3.2 → 0.4.0.pre1

data/lib/puppet-lint/configuration.rb

@@ -1,19 +1,50 @@
 class PuppetLint
   class Configuration
+    # Internal: Add helper methods for a new check to the
+    # PuppetLint::Configuration object.
+    #
+    # check - The String name of the check.
+    #
+    # Returns nothing.
+    #
+    # Signature
+    #
+    #   <check>_enabled?
+    #   disable_<check>
+    #   enable_<check>
     def self.add_check(check)
+      # Public: Determine if the named check is enabled.
+      #
+      # Returns true if the check is enabled, otherwise return false.
       define_method("#{check}_enabled?") do
         settings["#{check}_disabled"] == true ? false : true
       end
 
+      # Public: Disable the named check.
+      #
+      # Returns nothing.
       define_method("disable_#{check}") do
         settings["#{check}_disabled"] = true
       end
 
+      # Public: Enable the named check.
+      #
+      # Returns nothing.
       define_method("enable_#{check}") do
         settings["#{check}_disabled"] = false
       end
     end
 
+    # Public: Catch situations where options are being set for the first time
+    # and create the necessary methods to get & set the option in the future.
+    #
+    # args[0] - The value to set the option to.
+    #
+    # Returns nothing.
+    #
+    # Signature
+    #
+    #   <option>=(value)
     def method_missing(method, *args, &block)
       if method.to_s =~ /^(\w+)=$/
         option = $1
@@ -24,37 +55,110 @@ class PuppetLint
       end
     end
 
+    # Internal: Add options to the PuppetLint::Configuration object from inside
+    # the class.
+    #
+    # option - The String name of the option.
+    #
+    # Returns nothing.
+    #
+    # Signature
+    #
+    #   <option>
+    #   <option>=(value)
     def add_option(option)
       self.class.add_option(option)
     end
 
+    # Public: Add an option to the PuppetLint::Configuration object from
+    # outside the class.
+    #
+    # option - The String name of the option.
+    #
+    # Returns nothing.
+    #
+    # Signature
+    #
+    #   <option>
+    #   <option>=(value)
     def self.add_option(option)
+      # Public: Set the value of the named option.
+      #
+      # value - The value to set the option to.
+      #
+      # Returns nothing.
       define_method("#{option}=") do |value|
         settings[option] = value
       end
 
+      # Public: Get the value of the named option.
+      #
+      # Returns the value of the option.
       define_method(option) do
         settings[option]
       end
     end
 
+    # Internal: Register a new check.
+    #
+    # check - The String name of the check
+    # b     - The Block containing the logic of the check
+    #
+    # Returns nothing.
     def add_check(check, &b)
       self.class.add_check(check)
       check_method[check] = b
     end
 
+    # Internal: Register a new check helper method.
+    #
+    # name - The String name of the method.
+    # b    - The Block containing the logic of the helper.
+    #
+    # Returns nothing.
+    def add_helper(name, &b)
+      helper_method[name] = b
+    end
+
+    # Internal: Access the internal storage for settings.
+    #
+    # Returns a Hash containing all the settings.
     def settings
       @settings ||= {}
     end
 
+    # Internal: Access the internal storage for check method blocks.
+    #
+    # Returns a Hash containing all the check blocks.
     def check_method
       @check_method ||= {}
     end
 
+    # Public: Get a list of all the defined checks.
+    #
+    # Returns an Array of String check names.
     def checks
       check_method.keys
     end
 
+    # Internal: Access the internal storage for helper method blocks.
+    #
+    # Returns a Hash containing all the helper blocks.
+    def helper_method
+      @helper_method ||= {}
+    end
+
+    # Public: Get a list of all the helper methods.
+    #
+    # Returns an Array of String method names.
+    def helpers
+      helper_method.keys
+    end
+
+    # Public: Clear the PuppetLint::Configuration storage and set some sane
+    # default values.
+    #
+    # Returns nothing.
     def defaults
       settings.clear
       self.with_filename = false
@@ -62,6 +166,7 @@ class PuppetLint
       self.error_level = :all
       self.log_format = ''
       self.with_context = false
+      self.fix = false
     end
   end
 end

data/lib/puppet-lint/lexer.rb

@@ -5,7 +5,17 @@ require 'set'
 
 class PuppetLint
   class LexerError < StandardError
-    attr_reader :line_no, :column
+    # Internal: Get the Integer line number of the location of the error.
+    attr_reader :line_no
+
+    # Internal: Get the Integer column number of the location of the error.
+    attr_reader :column
+
+    # Internal: Initialise a new PuppetLint::LexerError object.
+    #
+    # code   - The String manifest code being tokenised.
+    # offset - The Integer position in the code string that the tokeniser was
+    #          at when it encountered the error.
     def initialize(code, offset)
       chunk = code[0..offset]
       @line_no = chunk.count("\n") + 1
@@ -19,35 +29,43 @@ class PuppetLint
   end
 
   class Lexer
+    # Internal: A Hash whose keys are Strings representing reserved keywords in
+    # the Puppet DSL.
     KEYWORDS = {
-      'class' => true,
-      'case' => true,
-      'default' => true,
-      'define' => true,
-      'import' => true,
-      'if' => true,
-      'else' => true,
-      'elsif' => true,
+      'class'    => true,
+      'case'     => true,
+      'default'  => true,
+      'define'   => true,
+      'import'   => true,
+      'if'       => true,
+      'else'     => true,
+      'elsif'    => true,
       'inherits' => true,
-      'node' => true,
-      'and' => true,
-      'or' => true,
-      'undef' => true,
-      'true' => true,
-      'false' => true,
-      'in' => true,
-      'unless' => true,
+      'node'     => true,
+      'and'      => true,
+      'or'       => true,
+      'undef'    => true,
+      'true'     => true,
+      'false'    => true,
+      'in'       => true,
+      'unless'   => true,
     }
 
+    # Internal: A Hash whose keys are Symbols representing token types which
+    # a regular expression can follow.
     REGEX_PREV_TOKENS = {
-      :NODE => true,
-      :LBRACE => true,
-      :RBRACE => true,
-      :MATCH => true,
+      :NODE    => true,
+      :LBRACE  => true,
+      :RBRACE  => true,
+      :MATCH   => true,
       :NOMATCH => true,
-      :COMMA => true,
+      :COMMA   => true,
     }
 
+    # Internal: An Array of Arrays containing tokens that can be described by
+    # a single regular expression.  Each sub-Array contains 2 elements, the
+    # name of the token as a Symbol and a regular expression describing the
+    # value of the token.
     KNOWN_TOKENS = [
       [:CLASSREF, /\A(((::){0,1}[A-Z][-\w]*)+)/],
       [:NUMBER, /\A\b((?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?))\b/],
@@ -93,19 +111,32 @@ class PuppetLint
       [:TIMES, /\A(\*)/],
     ]
 
+    # Internal: A Hash whose keys are Symbols representing token types which
+    # are considered to be formatting tokens (i.e. tokens that don't contain
+    # code).
     FORMATTING_TOKENS = {
-      :WHITESPACE => true,
-      :NEWLINE => true,
-      :COMMENT => true,
-      :MLCOMMENT => true,
+      :WHITESPACE    => true,
+      :NEWLINE       => true,
+      :COMMENT       => true,
+      :MLCOMMENT     => true,
       :SLASH_COMMENT => true,
-      :INDENT => true,
+      :INDENT        => true,
     }
 
+    # Internal: Access the internal token storage.
+    #
+    # Returns an Array of PuppetLint::Lexer::Toxen objects.
     def tokens
       @tokens ||= []
     end
 
+    # Internal: Convert a Puppet manifest into tokens.
+    #
+    # code - The Puppet manifest to be tokenised as a String.
+    #
+    # Returns an Array of PuppetLint::Lexer::Token objects.
+    # Raises PuppetLint::LexerError if it encounters unexpected characters
+    # (usually the result of syntax errors).
     def tokenise(code)
       code.chomp!
 
@@ -165,8 +196,7 @@ class PuppetLint
             mlcomment_size = mlcomment.size
             mlcomment.sub!(/\A\/\* ?/, '')
             mlcomment.sub!(/ ?\*\/\Z/, '')
-            mlcomment.gsub!(/^ ?\* ?/, '')
-            mlcomment.gsub!(/\n/, ' ')
+            mlcomment.gsub!(/ *\* ?/, '')
             mlcomment.strip!
             tokens << new_token(:MLCOMMENT, mlcomment, :chunk => code[0..i])
             i += mlcomment_size
@@ -176,7 +206,7 @@ class PuppetLint
             tokens << new_token(:REGEX, str_content[0..-2], :chunk => code[0..i])
             i += str_content.size + 1
 
-          elsif indent = chunk[/\A\n([ \t]+)/m, 1]
+          elsif indent = chunk[/\A\r?\n([ \t]+)/m, 1]
             tokens << new_token(:NEWLINE, '\n', :chunk => code[0..i])
             tokens << new_token(:INDENT, indent, :chunk => code[0..i+1])
             i += indent.size + 1
@@ -185,7 +215,7 @@ class PuppetLint
             tokens << new_token(:WHITESPACE, whitespace, :chunk => code[0..i])
             i += whitespace.size
 
-          elsif chunk.match(/\A\n/)
+          elsif chunk.match(/\A\r?\n/)
             tokens << new_token(:NEWLINE, '\n', :chunk => code[0..i])
             i += 1
 
@@ -202,6 +232,10 @@ class PuppetLint
       tokens
     end
 
+    # Internal: Given the tokens already processed, determine if the next token
+    # could be a regular expression.
+    #
+    # Returns true if the next token could be a regex, otherwise return false.
     def possible_regex?
       prev_token = tokens.reject { |r|
         FORMATTING_TOKENS.include? r.type
@@ -216,6 +250,19 @@ class PuppetLint
       end
     end
 
+    # Internal: Create a new PuppetLint::Lexer::Token object, calculate its
+    # line number and column and then add it to the Linked List of tokens.
+    #
+    # type  - The Symbol token type.
+    # value - The token value.
+    # opts  - A Hash of additional values required to determine line number and
+    #         column:
+    #   :chunk  - The String chunk of the manifest that has been tokenised so
+    #             far.
+    #   :line   - The Integer line number if calculated externally.
+    #   :column - The Integer column number if calculated externally.
+    #
+    # Returns the instantiated PuppetLint::Lexer::Token object.
     def new_token(type, value, opts = {})
       if opts[:chunk]
         line_no = opts[:chunk].count("\n") + 1
@@ -248,6 +295,15 @@ class PuppetLint
       token
     end
 
+    # Internal: Split a string on multiple terminators, excluding escaped
+    # terminators.
+    #
+    # string      - The String to be split.
+    # terminators - The String of terminators that the String should be split
+    #               on.
+    #
+    # Returns an Array consisting of two Strings, the String up to the first
+    # terminator and the terminator that was found.
     def get_string_segment(string, terminators)
       str = string.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]+/)
       begin
@@ -257,6 +313,13 @@ class PuppetLint
       end
     end
 
+    # Internal: Tokenise the contents of a double quoted string.
+    #
+    # string - The String to be tokenised.
+    # line   - The Integer line number of the start of the passed string.
+    # column - The Integer column number of the start of the passed string.
+    #
+    # Returns nothing.
     def interpolate_string(string, line, column)
       ss = StringScanner.new(string)
       first = true

data/lib/puppet-lint/lexer/token.rb

@@ -2,10 +2,10 @@ class PuppetLint
   class Lexer
     class Token
       # Internal: Returns the Symbol type of the Token.
-      attr_reader :type
+      attr_accessor :type
 
       # Internal: Returns the String value of the Token.
-      attr_reader :value
+      attr_accessor :value
 
       # Internal: Returns the Integer line number of the manifest text where
       # the Token can be found.
@@ -57,6 +57,42 @@ class PuppetLint
       def inspect
         "<Token #{@type.inspect} (#{@value}) @#{@line}:#{@column}>"
       end
+
+      # Internal: Produce a Puppet DSL representation of a Token.
+      #
+      # Returns a Puppet DSL String.
+      def to_manifest
+        case @type
+        when :STRING
+          "\"#{@value}\""
+        when :SSTRING
+          "'#{@value}'"
+        when :DQPRE
+          "\"#{@value}"
+        when :DQPOST
+          "#{@value}\""
+        when :VARIABLE
+          if !@prev_code_token.nil? && [:DQPRE, :DQMID].include?(@prev_code_token.type)
+            "${#{@value}}"
+          else
+            "$#{@value}"
+          end
+        when :UNENC_VARIABLE
+          "$#{@value}"
+        when :NEWLINE
+          "\n"
+        when :COMMENT
+          if @value.start_with?('#') || @value.empty?
+            "##{@value}"
+          else
+            "# #{@value}"
+          end
+        when :REGEX
+          "/#{@value}/"
+        else
+          @value
+        end
+      end
     end
   end
 end

data/lib/puppet-lint/monkeypatches.rb

@@ -0,0 +1,2 @@
+require 'puppet-lint/monkeypatches/string_prepend'
+require 'puppet-lint/monkeypatches/string_percent'

data/lib/puppet-lint/monkeypatches/string_percent.rb

@@ -0,0 +1,52 @@
+# If we are using an older ruby version, we back-port the basic functionality
+# we need for formatting output: 'somestring' % <hash>
+begin
+  if ('%{test}' % {:test => 'replaced'} == 'replaced')
+    # If this works, we are all good to go.
+  end
+rescue
+  # If the test failed (threw a error), monkeypatch String.
+  # Most of this code came from http://www.ruby-forum.com/topic/144310 but was
+  # simplified for our use.
+
+  # Basic implementation of 'string' % { } like we need it. needs work.
+  class String
+    Percent = instance_method '%' unless defined? Percent
+    def % *a, &b
+      a.flatten!
+
+      string = case a.last
+      when Hash
+        expand a.pop
+      else
+        self
+      end
+
+      if a.empty?
+        string
+      else
+        Percent.bind(string).call(a, &b)
+      end
+
+    end
+    def expand! vars = {}
+      loop do
+        changed = false
+        vars.each do |var, value|
+          var = var.to_s
+          var.gsub! %r/[^a-zA-Z0-9_]/, ''
+          [
+            %r/\%\{#{ var }\}/,
+          ].each do |pat|
+            changed = gsub! pat, "#{ value }"
+          end
+        end
+        break unless changed
+      end
+      self
+    end
+    def expand opts = {}
+      dup.expand! opts
+    end
+  end
+end