Class: PuppetLint::Data

Inherits:
Object
  • Object
show all
Includes:
Singleton
Defined in:
lib/puppet-lint/data.rb

Overview

Public: A singleton class storing all the information about the manifest being analysed.

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.filename ⇒ Object (readonly)

Internal: Get/Set the full expanded path to the manifest file being checked.



12
13
14
 
# File 'lib/puppet-lint/data.rb', line 12

def filename
  @filename
end

.fullpath ⇒ Object (readonly)

Internal: Get/Set the full expanded path to the manifest file being checked.



12
13
14
 
# File 'lib/puppet-lint/data.rb', line 12

def fullpath
  @fullpath
end

.manifest_lines ⇒ Object

Internal: Get/Set the raw manifest data, split by n.



15
16
17
 
# File 'lib/puppet-lint/data.rb', line 15

def manifest_lines
  @manifest_lines
end

.path ⇒ Object

Internal: Get/Set the full expanded path to the manifest file being checked.



12
13
14
 
# File 'lib/puppet-lint/data.rb', line 12

def path
  @path
end

Class Method Details

.class_indexes ⇒ Object

Internal: Calculate the positions of all class definitions within the ‘tokens` Array.

Returns an Array of Hashes, each containing:

:start  - An Integer position in the `tokens` Array pointing to the
          first Token of a class definition.
:end    - An Integer position in the `tokens` Array pointing to the last
          Token of a class definition.
:tokens - An Array consisting of all the Token objects that make up the
          class definition.



164
165
166
 
# File 'lib/puppet-lint/data.rb', line 164

def class_indexes
  @class_indexes ||= definition_indexes(:CLASS)
end

.defined_type_indexes ⇒ Object

Internal: Calculate the positions of all defined type definitions within the ‘tokens` Array.

Returns an Array of Hashes, each containing:

:start  - An Integer position in the `tokens` Array pointing to the
          first Token of a defined type definition.
:end    - An Integer position in the `tokens` Array pointing to the last
          Token of a defined type definition.
:tokens - An Array consisting of all the Token objects that make up the
          defined type.



178
179
180
 
# File 'lib/puppet-lint/data.rb', line 178

def defined_type_indexes
  @defined_type_indexes ||= definition_indexes(:DEFINE)
end

.definition_indexes(type) ⇒ Object

Internal: Calculate the positions of all the specified defintion types within the ‘tokens` Array.

Returns an Array of Hashes, each containing:

:start  - An Integer position in the `tokens` Array pointing to the
          first Token of a definition.
:end    - An Integer position in the `tokens` Array pointing to the last
          Token of a definition.
:tokens - An Array consisting of all the Token objects that make up the
          definition.



192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/puppet-lint/data.rb', line 192

def definition_indexes(type)
  result = []
  tokens.each_with_index do |token, i|
    if token.type == type
      brace_depth = 0
      paren_depth = 0
      in_params = false
      inherited_class = nil
      tokens[i+1..-1].each_with_index do |definition_token, j|
        case definition_token.type
        when :INHERITS
          inherited_class = definition_token.next_code_token
        when :LPAREN
          in_params = true if paren_depth == 0
          paren_depth += 1
        when :RPAREN
          in_params = false if paren_depth == 1
          paren_depth -= 1
        when :LBRACE
          brace_depth += 1
        when :RBRACE
          brace_depth -= 1
          if brace_depth == 0 && !in_params
            if token.next_code_token.type != :LBRACE
              result << {
                :start           => i,
                :end             => i + j + 1,
                :tokens          => tokens[i..(i + j + 1)],
                :param_tokens    => param_tokens(tokens[i..(i + j + 1)]),
                :type            => type,
                :name_token      => token.next_code_token,
                :inherited_token => inherited_class,
              }
              break
            end
          end
        end
      end
    end
  end
  result
end

.find_resource_param_tokens(resource_tokens) ⇒ Object

Internal: Find all the Token objects representing the parameter names in a resource definition.

resource_tokens - An Array of Token objects that comprise the resource

definition.

Returns an Array of Token objects.



148
149
150
151
152
 
# File 'lib/puppet-lint/data.rb', line 148

def find_resource_param_tokens(resource_tokens)
  resource_tokens.select { |token|
    token.type == :NAME && token.next_code_token.type == :FARROW
  }
end

.find_resource_type_token(index) ⇒ Object

Internal: Find the Token representing the type of a resource definition.

index - The Integer pointing to the start of the resource in the ‘tokens`

array.

Returns a Token object.



137
138
139
 
# File 'lib/puppet-lint/data.rb', line 137

def find_resource_type_token(index)
  tokens[tokens[0..index].rindex { |token| token.type == :LBRACE }].prev_code_token
end

.formatting_tokens ⇒ Object

Internal: Retrieves a list of token types that are considered to be formatting tokens (whitespace, newlines, etc).

Returns an Array of Symbols.



272
273
274
 
# File 'lib/puppet-lint/data.rb', line 272

def formatting_tokens
  @formatting_tokens ||= PuppetLint::Lexer::FORMATTING_TOKENS
end

.ignore_overrides ⇒ Object

Internal: Retrieves a Hash of Sets. Each key is a check name Symbol and the Set of Integers returned lists all the lines that the check results should be ignored on.

Returns a Hash of Sets of Integers.



281
282
283
 
# File 'lib/puppet-lint/data.rb', line 281

def ignore_overrides
  @ignore_overrides ||= {}
end

.param_tokens(these_tokens) ⇒ Object

Internal: Finds all the tokens that make up the defined type or class definition parameters.

these_tokens - An Array of PuppetLint::Lexer::Token objects that make up

the defined type or class definition.

Returns an Array of PuppetLint::Lexer::Token objects or nil if it takes no parameters.



243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/puppet-lint/data.rb', line 243

def param_tokens(these_tokens)
  depth = 0
  lparen_idx = nil
  rparen_idx = nil

  these_tokens.each_with_index do |token, i|
    if token.type == :LPAREN
      depth += 1
      lparen_idx = i if depth == 1
    elsif token.type == :RPAREN
      depth -= 1
      if depth == 0
        rparen_idx = i
        break
      end
    end
  end

  if lparen_idx.nil? or rparen_idx.nil?
    nil
  else
    these_tokens[(lparen_idx + 1)..(rparen_idx - 1)]
  end
end

.parse_control_comments ⇒ Object

Internal: Parses all COMMENT, MLCOMMENT and SLASH_COMMENT tokens looking for control comments (comments that enable or disable checks). Builds the contents of the ‘ignore_overrides` hash.

Returns nothing.



290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/puppet-lint/data.rb', line 290

def parse_control_comments
  @ignore_overrides.each_key { |check| @ignore_overrides[check].clear }

  comment_token_types = Set[:COMMENT, :MLCOMMENT, :SLASH_COMMENT]

  comment_tokens = tokens.select { |token|
    comment_token_types.include?(token.type)
  }
  control_comment_tokens = comment_tokens.select { |token|
    token.value.strip =~ /\Alint:(ignore:[\w\d]+|endignore)/
  }

  stack = []
  control_comment_tokens.each do |token|
    control, reason = token.value.strip.split(' ', 2)
    split_control = control.split(':')
    command = split_control[1]

    if command == 'ignore'
      check = split_control[2].to_sym

      if token.prev_token && !Set[:NEWLINE, :INDENT].include?(token.prev_token.type)
        # control comment at the end of the line, override applies to
        # a single line only
        (ignore_overrides[check] ||= {})[token.line] = reason
      else
        stack << [token.line, reason, check]
      end
    else
      start = stack.pop
      unless start.nil?
        (start[0]..token.line).each do |i|
          (ignore_overrides[start[2]] ||= {})[i] = start[1]
        end
      end
    end
  end
end

.resource_indexes ⇒ Object

Internal: Calculate the positions of all resource declarations within the tokenised manifest. These positions only point to the content of the resource declarations, they do not include resource types or titles.

Returns an Array of Hashes, each containing:

:start - An Integer position in the `tokens` Array pointing to the
         first Token of a resource declaration.
:end   - An Integer position in the `tokens` Array pointing to the last
         Token of a resource declaration.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/puppet-lint/data.rb', line 96

def resource_indexes
  @resource_indexes ||= Proc.new do
    result = []
    tokens.each_index do |token_idx|
      if tokens[token_idx].type == :COLON
        next_token = tokens[token_idx].next_code_token
        depth = 1
        if next_token.type != :LBRACE
          tokens[(token_idx + 1)..-1].each_index do |idx|
            real_idx = token_idx + idx + 1
            if tokens[real_idx].type == :LBRACE
              depth += 1
            elsif {:SEMIC => true, :RBRACE => true}.include? tokens[real_idx].type
              unless tokens[real_idx].type == :SEMIC && depth > 1
                depth -= 1
                if depth == 0
                  result << {
                    :start        => token_idx + 1,
                    :end          => real_idx,
                    :tokens       => tokens[(token_idx + 1)..real_idx],
                    :type         => find_resource_type_token(token_idx),
                    :param_tokens => find_resource_param_tokens(tokens[(token_idx + 1)..real_idx]),
                  }
                  break
                end
              end
            end
          end
        end
      end
    end
    result
  end.call
end

.title_tokens ⇒ Object

Internal: Retrieve a list of tokens that represent resource titles

Returns an Array of PuppetLint::Lexer::Token objects.



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/puppet-lint/data.rb', line 61

def title_tokens
  @title_tokens ||= Proc.new do
    result = []
    tokens.each_index do |token_idx|
      if tokens[token_idx].type == :COLON
        # gather a list of tokens that are resource titles
        if tokens[token_idx-1].type == :RBRACK
          array_start_idx = tokens.rindex { |r|
            r.type == :LBRACK
          }
          title_array_tokens = tokens[(array_start_idx + 1)..(token_idx - 2)]
          result += title_array_tokens.select { |token|
            {:STRING => true, :NAME => true}.include? token.type
          }
        else
          next_token = tokens[token_idx].next_code_token
          if next_token.type != :LBRACE
            result << tokens[token_idx - 1]
          end
        end
      end
    end
    result
  end.call
end

.tokens ⇒ Object

Public: Get the tokenised manifest.

Returns an Array of PuppetLint::Lexer::Token objects.



33
34
35
36
37
38
39
 
# File 'lib/puppet-lint/data.rb', line 33

def tokens
  if caller[0][/`.*'/][1..-2] == 'check'
    @tokens.dup
  else
    @tokens
  end
end

.tokens=(tokens) ⇒ Object

Internal: Store the tokenised manifest.

tokens - The Array of PuppetLint::Lexer::Token objects to store.

Returns nothing.



22
23
24
25
26
27
28
 
# File 'lib/puppet-lint/data.rb', line 22

def tokens=(tokens)
  @tokens = tokens
  @title_tokens = nil
  @resource_indexes = nil
  @class_indexes = nil
  @defined_type_indexes = nil
end