Class: Chef::Cookbook::SyntaxCheck

Inherits:
Object
  • Object
show all
Includes:
Mixin::Checksum, Mixin::ShellOut
Defined in:
lib/chef/cookbook/syntax_check.rb

Overview

Chef::Cookbook::SyntaxCheck

Encapsulates the process of validating the ruby syntax of files in Chef cookbooks.

Defined Under Namespace

Classes: PersistentSet

Constant Summary

Constants included from Mixin::ShellOut

Mixin::ShellOut::DEPRECATED_OPTIONS

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Mixin::Checksum

#checksum

Methods included from Mixin::ShellOut

#run_command_compatible_options, #shell_out, #shell_out!, #shell_out_with_systems_locale, #shell_out_with_systems_locale!

Constructor Details

#initialize(cookbook_path) ⇒ SyntaxCheck

Create a new SyntaxCheck object

Arguments

cookbook_path:

the (on disk) path to the cookbook



96
97
98
99
100
101
 
# File 'lib/chef/cookbook/syntax_check.rb', line 96

def initialize(cookbook_path)
  @cookbook_path = cookbook_path
  @chefignore ||= Chefignore.new(cookbook_path)

  @validated_files = PersistentSet.new
end

Instance Attribute Details

#chefignore ⇒ Object (readonly)

Returns the value of attribute chefignore.



81
82
83
 
# File 'lib/chef/cookbook/syntax_check.rb', line 81

def chefignore
  @chefignore
end

#cookbook_path ⇒ Object (readonly)

Returns the value of attribute cookbook_path.



75
76
77
 
# File 'lib/chef/cookbook/syntax_check.rb', line 75

def cookbook_path
  @cookbook_path
end

#validated_files ⇒ Object (readonly)

A PersistentSet object that tracks which files have already been validated.



79
80
81
 
# File 'lib/chef/cookbook/syntax_check.rb', line 79

def validated_files
  @validated_files
end

Class Method Details

.for_cookbook(cookbook_name, cookbook_path = nil) ⇒ Object

Creates a new SyntaxCheck given the cookbook_name and a cookbook_path. If no cookbook_path is given, Chef::Config.cookbook_path is used.



85
86
87
88
89
90
91
 
# File 'lib/chef/cookbook/syntax_check.rb', line 85

def self.for_cookbook(cookbook_name, cookbook_path = nil)
  cookbook_path ||= Chef::Config.cookbook_path
  unless cookbook_path
    raise ArgumentError, "Cannot find cookbook #{cookbook_name} unless Chef::Config.cookbook_path is set or an explicit cookbook path is given"
  end
  new(File.join(cookbook_path, cookbook_name.to_s))
end

Instance Method Details

#invalid_erb_file(erb_file, error_message) ⇒ Object

Debug a syntax error in a template.



211
212
213
214
215
216
 
# File 'lib/chef/cookbook/syntax_check.rb', line 211

def invalid_erb_file(erb_file, error_message)
  file_relative_path = erb_file[/^#{Regexp.escape(cookbook_path + File::Separator)}(.*)/, 1]
  Chef::Log.fatal("Erb template #{file_relative_path} has a syntax error:")
  error_message.each_line { |l| Chef::Log.fatal(l.chomp) }
  nil
end

#invalid_ruby_file(ruby_file, error_message) ⇒ Object

Debugs ruby syntax errors by printing the path to the file and any diagnostic info given in error_message



246
247
248
249
250
251
 
# File 'lib/chef/cookbook/syntax_check.rb', line 246

def invalid_ruby_file(ruby_file, error_message)
  file_relative_path = ruby_file[/^#{Regexp.escape(cookbook_path + File::Separator)}(.*)/, 1]
  Chef::Log.fatal("Cookbook file #{file_relative_path} has a ruby syntax error:")
  error_message.each_line { |l| Chef::Log.fatal(l.chomp) }
  false
end

#remove_ignored_files(file_list) ⇒ Object 



103
104
105
106
107
108
109
110
 
# File 'lib/chef/cookbook/syntax_check.rb', line 103

def remove_ignored_files(file_list)
  return file_list if chefignore.ignores.empty?

  file_list.reject do |full_path|
    relative_pn = Chef::Util::PathHelper.relative_path_from(cookbook_path, full_path)
    chefignore.ignored?(relative_pn.to_s)
  end
end

#remove_uninteresting_ruby_files(file_list) ⇒ Object 



112
113
114
 
# File 'lib/chef/cookbook/syntax_check.rb', line 112

def remove_uninteresting_ruby_files(file_list)
  file_list.reject { |f| f =~ %r{#{cookbook_path}/(files|templates)/} }
end

#ruby ⇒ Object

Returns the full path to the running ruby.



254
255
256
 
# File 'lib/chef/cookbook/syntax_check.rb', line 254

def ruby
  Gem.ruby
end

#ruby_files ⇒ Object 



116
117
118
119
120
121
122
 
# File 'lib/chef/cookbook/syntax_check.rb', line 116

def ruby_files
  path  = Chef::Util::PathHelper.escape_glob_dir(cookbook_path)
  files = Dir[File.join(path, "**", "*.rb")]
  files = remove_ignored_files(files)
  files = remove_uninteresting_ruby_files(files)
  files
end

#template_files ⇒ Object 



135
136
137
 
# File 'lib/chef/cookbook/syntax_check.rb', line 135

def template_files
  remove_ignored_files Dir[File.join(Chef::Util::PathHelper.escape_glob_dir(cookbook_path), "**/templates/**", "*.erb")]
end

#untested_ruby_files ⇒ Object 



124
125
126
127
128
129
130
131
132
133
 
# File 'lib/chef/cookbook/syntax_check.rb', line 124

def untested_ruby_files
  ruby_files.reject do |file|
    if validated?(file)
      Chef::Log.debug("Ruby file #{file} is unchanged, skipping syntax check")
      true
    else
      false
    end
  end
end

#untested_template_files ⇒ Object 



139
140
141
142
143
144
145
146
147
148
 
# File 'lib/chef/cookbook/syntax_check.rb', line 139

def untested_template_files
  template_files.reject do |file|
    if validated?(file)
      Chef::Log.debug("Template #{file} is unchanged, skipping syntax check")
      true
    else
      false
    end
  end
end

#validate_erb_file_inline(erb_file) ⇒ Object

Validate the ruby code in an erb template. Uses RubyVM to do syntax checking.



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/chef/cookbook/syntax_check.rb', line 184

def validate_erb_file_inline(erb_file)
  old_stderr = $stderr

  engine = Erubis::Eruby.new
  engine.convert!(IO.read(erb_file))

  ruby_code = engine.src

  # Even when we're compiling the code w/ RubyVM, syntax errors just
  # print to $stderr. We want to capture this and handle the printing
  # ourselves, so we must temporarily swap $stderr to capture the output.
  tmp_stderr = $stderr = StringIO.new

  abs_path = File.expand_path(erb_file)
  RubyVM::InstructionSequence.new(ruby_code, erb_file, abs_path, 0)

  true
rescue SyntaxError
  $stderr = old_stderr
  invalid_erb_file(erb_file, tmp_stderr.string)
  false
ensure
  # be paranoid about setting stderr back to the old value.
  $stderr = old_stderr if defined?(old_stderr) && old_stderr
end

#validate_ruby_file(ruby_file) ⇒ Object 



177
178
179
180
 
# File 'lib/chef/cookbook/syntax_check.rb', line 177

def validate_ruby_file(ruby_file)
  Chef::Log.debug("Testing #{ruby_file} for syntax errors...")
  validate_ruby_file_inline(ruby_file)
end

#validate_ruby_file_inline(ruby_file) ⇒ Object

Validate the syntax of a ruby file. Uses (Ruby 1.9+ only) RubyVM to compile the code without evaluating it or spawning a new process.



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/chef/cookbook/syntax_check.rb', line 220

def validate_ruby_file_inline(ruby_file)
  # Even when we're compiling the code w/ RubyVM, syntax errors just
  # print to $stderr. We want to capture this and handle the printing
  # ourselves, so we must temporarily swap $stderr to capture the output.
  old_stderr = $stderr
  tmp_stderr = $stderr = StringIO.new
  abs_path = File.expand_path(ruby_file)
  file_content = IO.read(abs_path)
  # We have to wrap this in a block so the user code evaluates in a
  # similar context as what Chef does normally. Otherwise RubyVM
  # will reject some common idioms, like using `return` to end evaluation
  # of a recipe. See also CHEF-5199
  wrapped_content = "Object.new.instance_eval do\n#{file_content}\nend\n"
  RubyVM::InstructionSequence.new(wrapped_content, ruby_file, abs_path, 0)
  true
rescue SyntaxError
  $stderr = old_stderr
  invalid_ruby_file(ruby_file, tmp_stderr.string)
  false
ensure
  # be paranoid about setting stderr back to the old value.
  $stderr = old_stderr if defined?(old_stderr) && old_stderr
end

#validate_ruby_files ⇒ Object 



158
159
160
161
162
163
 
# File 'lib/chef/cookbook/syntax_check.rb', line 158

def validate_ruby_files
  untested_ruby_files.each do |ruby_file|
    return false unless validate_ruby_file(ruby_file)
    validated(ruby_file)
  end
end

#validate_template(erb_file) ⇒ Object 



172
173
174
175
 
# File 'lib/chef/cookbook/syntax_check.rb', line 172

def validate_template(erb_file)
  Chef::Log.debug("Testing template #{erb_file} for syntax errors...")
  validate_erb_file_inline(erb_file)
end

#validate_templates ⇒ Object 



165
166
167
168
169
170
 
# File 'lib/chef/cookbook/syntax_check.rb', line 165

def validate_templates
  untested_template_files.each do |template|
    return false unless validate_template(template)
    validated(template)
  end
end

#validated(file) ⇒ Object 



154
155
156
 
# File 'lib/chef/cookbook/syntax_check.rb', line 154

def validated(file)
  validated_files.add(checksum(file))
end

#validated?(file) ⇒ Boolean

Returns:

  • (Boolean) 


150
151
152
 
# File 'lib/chef/cookbook/syntax_check.rb', line 150

def validated?(file)
  validated_files.include?(checksum(file))
end