puppet-retrospec 0.11.0 → 0.12.0

data/Rakefile

@@ -6,7 +6,7 @@ begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
   $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  $stderr.puts 'Run `bundle install` to install missing gems'
   exit e.status_code
 end
 require 'rake'
@@ -14,13 +14,13 @@ require 'rake'
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "puppet-retrospec"
-  gem.homepage = "http://github.com/nwops/puppet-retrospec"
-  gem.license = "MIT"
-  gem.summary = %Q{Generates puppet rspec test code based on the classes and defines inside the manifests directory. Aims to reduce some of the boilerplate coding with default test patterns.}
-  gem.description = %Q{Retrofits and generates valid puppet rspec test code to existing modules}
-  gem.email = "corey@logicminds.biz"
-  gem.authors = ["Corey Osman"]
+  gem.name = 'puppet-retrospec'
+  gem.homepage = 'http://github.com/nwops/puppet-retrospec'
+  gem.license = 'MIT'
+  gem.summary = %(Generates puppet rspec test code based on the classes and defines inside the manifests directory. Aims to reduce some of the boilerplate coding with default test patterns.)
+  gem.description = %(Retrofits and generates valid puppet rspec test code to existing modules)
+  gem.email = 'corey@logicminds.biz'
+  gem.authors = ['Corey Osman']
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -1 +1 @@
-0.11.0
+0.12.0

data/lib/retrospec-puppet.rb

@@ -1,4 +1,4 @@
-vendor = File.join(File.dirname(File.dirname(__FILE__)),'vendor')
-$:.unshift(File.expand_path(File.join([vendor, "gems", "puppet-3.7.3", "lib"])))
+vendor = File.join(File.dirname(File.dirname(__FILE__)), 'vendor')
+$LOAD_PATH.unshift(File.expand_path(File.join([vendor, 'gems', 'puppet-3.7.3', 'lib'])))
 require 'retrospec/plugins/v1/plugin/puppet'
-require 'awesome_print'  # required for printing templates
+require 'awesome_print' # required for printing templates

data/lib/retrospec/plugins/v1/plugin/conditional.rb

@@ -8,8 +8,8 @@ class Conditional
   # those that can be changed
   # those that can be influenced (facts, other variables that contain variables)
   # takes a subtype of Puppet::AST::Branch that contains conditional logic
-  def initialize(branch, parameters)
-     @statements = branch.statements
+  def initialize(branch, _parameters)
+    @statements = branch.statements
   end
 
   # get the attributes for the given resources found in the type code passed in
@@ -24,7 +24,7 @@ class Conditional
 
   # a array of types the are known to contain conditional code and statements
   def self.types
-    #test, statement, value
+    # test, statement, value
     # if I don't have a statement that I am part of a bigger code block
     # [Puppet::Parser::AST::IfStatement, Puppet::Parser::AST::CaseStatement, Puppet::Parser::AST::Else,
     #  Puppet::Parser::AST::CaseOpt, Puppet::Parser::AST::Selector]
@@ -35,7 +35,7 @@ class Conditional
   def self.find_conditionals(type)
     conds = []
     if type.code.respond_to?(:find_all)
-      conds = type.code.find_all {|c| types.include?(c.class)  }
+      conds = type.code.find_all { |c| types.include?(c.class) }
     end
     conds
   end
@@ -49,5 +49,4 @@ class Conditional
     end
     conditionals
   end
-
-end
+end

data/lib/retrospec/plugins/v1/plugin/exceptions.rb

@@ -0,0 +1,17 @@
+module Retrospec
+  module Puppet
+    class ParserError < Exception
+    end
+    class NoManifestDirError < Exception
+    end
+    class InvalidModulePathError < Exception
+    end
+    module Generators
+      class CoreTypeException < Exception
+        def message
+          "You cannot use a core puppet type, bad stuff will happen"
+        end
+      end
+    end
+  end
+end

data/lib/retrospec/plugins/v1/plugin/generators.rb

@@ -0,0 +1,7 @@
+require_relative 'generators/fact_generator'
+require_relative 'generators/module_generator'
+require_relative 'generators/function_generator'
+require_relative 'generators/type_generator'
+require_relative 'generators/provider_generator'
+require_relative 'generators/schema_generator'
+require_relative 'exceptions'

data/lib/retrospec/plugins/v1/plugin/generators/fact_generator.rb

@@ -1,15 +1,14 @@
-require_relative 'facter'
+require_relative 'parsers/facter'
 
 module Retrospec
   module Puppet
     module Generators
       class FactGenerator < Retrospec::Plugins::V1::Plugin
-
         attr_reader :template_dir, :context, :module_path, :fact_name, :config_data
 
         # retrospec will initilalize this class so its up to you
         # to set any additional variables you need to get the job done.
-        def initialize(module_path, spec_object={})
+        def initialize(module_path, spec_object = {})
           # below is the Spec Object which serves as a context for template rendering
           # you will need to initialize this object, so the erb templates can get the binding
           # the SpecObject can be customized to your liking as its different for every plugin gem.
@@ -22,13 +21,13 @@ module Retrospec
         # the global options are passed in for your usage
         # http://trollop.rubyforge.org
         # all options here are available in the config passed into config object
-        def self.run_cli(global_opts)
-          sub_command_opts = Trollop::options do
+        def self.run_cli(global_opts, args=ARGV)
+          sub_command_opts = Trollop.options(args) do
             banner <<-EOS
 Generates a new fact with the given name
 
             EOS
-            opt :name, "The name of the fact you wish to create", :type => :string, :require => :true, :short => '-n'
+            opt :name, 'The name of the fact you wish to create', :type => :string, :require => :true, :short => '-n'
           end
           unless sub_command_opts[:name]
             Trollop.educate
@@ -60,17 +59,26 @@ Generates a new fact with the given name
           generate_fact_spec_files
         end
 
+        # returns an array of fact files found in the facter directory
+        def fact_files
+          @fact_files ||= Dir.glob(File.join(facter_dir, '*.rb')).sort
+        end
+
         # generates spec files for each fact defined in the fact file
+        # returns a array of generated spec files
         def generate_fact_spec_files
-          fact_files = Dir.glob(File.join(facter_dir, '*.rb')).sort
+          spec_files = []
+          template_file = File.join(template_dir, 'fact_spec.rb.retrospec.erb')
           fact_files.each do | fact_file|
             fact_file_data = Retrospec::Puppet::Generators::Facter.load_fact(fact_file)
             fact_file_data.facts.each do |name, fact_data|
               # because many facts can be in a single file we want to create a unique file for each fact
               fact_spec_path = File.join(facter_spec_dir, "#{name}_spec.rb")
-              safe_create_template_file(fact_spec_path, File.join(template_dir, 'fact_spec.rb.retrospec.erb'), fact_data)
+              safe_create_template_file(fact_spec_path,template_file , fact_data)
+              spec_files << fact_spec_path
             end
           end
+          spec_files
         end
 
         # the template directory located inside the your retrospec plugin gem
@@ -79,7 +87,7 @@ Generates a new fact with the given name
         def template_dir
           unless @template_dir
             external_templates = File.expand_path(File.join(config_data[:template_dir], 'facts', 'fact.rb.retrospec.erb'))
-            if File.exists?(external_templates)
+            if File.exist?(external_templates)
               @template_dir = File.join(config_data[:template_dir], 'facts')
             else
               @template_dir = File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'templates', 'facts'))
@@ -90,4 +98,4 @@ Generates a new fact with the given name
       end
     end
   end
-end
+end

data/lib/retrospec/plugins/v1/plugin/generators/function_generator.rb

@@ -0,0 +1,187 @@
+require_relative 'parsers/function'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class FunctionGenerator < Retrospec::Plugins::V1::Plugin
+        attr_reader :template_dir, :context
+
+        # retrospec will initilalize this class so its up to you
+        # to set any additional variables you need to get the job done.
+        def initialize(module_path, spec_object = {})
+          super
+          # below is the Spec Object which serves as a context for template rendering
+          # you will need to initialize this object, so the erb templates can get the binding
+          # the SpecObject can be customized to your liking as its different for every plugin gem.
+          @context = OpenStruct.new(:name => spec_object[:name], :return_type => spec_object[:return_type],
+                                    :function_type => spec_object[:type], :test_type => spec_object[:test_type])
+        end
+
+        # Puppet currently has two versions of functions (v3, v4).  At the time of writing v4 is still new
+        # and not used very much.  Because of this we will want to allow the user to pick which version of puppet function dsl
+        # they wish to use.  Based on the version, a slightly different template will be rendered.  This method will return
+        # the template dir based on the version passed in.
+        # By default this method looks inside the user supplied template dir for existence of a template and if true returns that base path, if
+        # false returns the template directory inside the gem location which is mainly used for development only.
+        def template_dir
+          external_templates = File.expand_path(File.join(config_data[:template_dir], 'functions',function_type, 'function_template.rb.retrospec.erb'))
+          if File.exist?(external_templates)
+            File.join(config_data[:template_dir], 'functions', function_type)
+          else
+            File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'templates', 'functions', function_type))
+          end
+        end
+
+        # returns v3 or v4 to specify the function type
+        def function_type
+          context.function_type
+        end
+
+        # used to display subcommand options to the cli
+        # the global options are passed in for your usage
+        # http://trollop.rubyforge.org
+        # all options here are available in the config passed into config object
+        # returns the parameters
+        def self.run_cli(global_opts, args=ARGV)
+          func_types = ['v3', 'v4']
+          func_type  = global_opts['plugins::puppet::default_function_version'] || 'v3'
+          test_type  = global_opts['plugins::puppet::default_function_test_type'] || 'rspec'
+          sub_command_opts = Trollop.options(args) do
+            banner <<-EOS
+Generates a new function with the given name.
+
+            EOS
+            opt :name, 'The name of the function you wish to create', :type => :string, :required => true, :short => '-n'
+            opt :type, 'The version type of the function (v3, v4)', :type => :string, :required => false, :short => '-t',
+                :default => func_type
+            opt :test_type, 'The type of test file to create (rspec, ruby)', :default => test_type, :type => :string, :short => '-u'
+            opt :return_type, 'The return type of the function (rvalue, statement)', :type => :string, :required => false,
+                :short => '-r', :default => 'rvalue'
+          end
+
+          unless func_types.include? sub_command_opts[:type].downcase
+            puts "Invalid type, must be one of #{func_types.join(',')}"
+            Trollop.educate
+            exit 1
+          end
+          unless sub_command_opts[:name]
+            Trollop.educate
+            exit 1
+          end
+          plugin_data = global_opts.merge(sub_command_opts)
+          plugin_data
+        end
+
+        # returns the function directory to create the the function in
+        def function_dir
+          if function_type == 'v3'
+            v3_function_dir
+          else
+            v4_function_dir
+          end
+        end
+
+        # returns the path to the v3 function directory
+        def v3_function_dir
+          @v3_function_dir || File.join(module_path, 'lib', 'puppet', 'parser', 'functions')
+        end
+
+        # returns the path to the v4 function directory
+        def v4_function_dir
+          @v4_function_dir || File.join(module_path, 'lib', 'puppet', 'functions')
+        end
+
+        # returns the path to the function using the function directory
+        def function_path
+          File.join(function_dir, "#{function_name}.rb")
+        end
+
+        # returns the name of the function
+        def function_name
+          context.name
+        end
+
+        # generates the function file based on the template and context
+        def generate_function_file
+          safe_create_template_file(function_path, File.join(template_dir, 'function_template.rb.retrospec.erb'), context)
+          function_path
+        end
+
+        # returns the path to the spec directory
+        # because this can vary between test types and function types
+        # there are many supporting functions to determine which directory to use
+        def spec_file_dir
+          if function_type == 'v3'
+            v3_spec_dir
+          else
+            v4_spec_dir
+          end
+        end
+
+        # returns the path to the v3 spec directory if using using rspec test type
+        # the spec/functions is returned
+        def v3_spec_dir
+          if context[:test_type] == 'ruby'
+            File.join(module_path, 'spec', 'unit', 'puppet', 'parser', 'functions')
+          else
+            File.join(module_path, 'spec', 'functions')
+          end
+        end
+
+        # returns the path to the v4 spec directory if using using rspec test type
+        # the spec/functions is returned
+        def v4_spec_dir
+          if context[:test_type] == 'ruby'
+            File.join(module_path, 'spec', 'unit', 'puppet', 'functions')
+          else
+            File.join(module_path, 'spec', 'functions')
+          end
+        end
+
+        # returns an array of functions found in either the v3 or v4 directories
+        def discovered_functions
+          Dir.glob([File.join(v3_function_dir, '*.rb'), File.join(v4_function_dir, '*.rb')]).sort
+        end
+
+        def is_v3_function?(function_file)
+          File.basename(Pathname.new(function_file).parent.parent) == 'parser'
+        end
+
+        # returns the template file name based on the test type
+        def template_file
+          if context[:test_type] == 'rspec'
+            'function_rspec_template.retrospec.erb'
+          else
+            'function_ruby_template.retrospec.erb'
+          end
+        end
+
+        # creates the spec files for the discovered_functions
+        def generate_spec_files
+          spec_files = []
+          discovered_functions.each do |file|
+            begin
+              if is_v3_function?(file)
+                context.function_type = 'v3'
+                file_data = Retrospec::Puppet::Parser::Functions.load_function(file)
+              else
+                context.function_type = 'v4'
+                file_data = Retrospec::Puppet::Functions.load_function(file)
+              end
+            rescue NoMethodError => e
+              puts "Error evaluating function for #{file}, skipping".warning
+              next
+            rescue SyntaxError => e
+              puts "Function syntax is bad for #{file}, skipping".warning
+              next  # lets skip functions that have bad syntax
+            end
+            spec_path = File.join(spec_file_dir, "#{file_data.name}_spec.rb")
+            spec_files << spec_path
+            safe_create_template_file(spec_path, File.join(template_dir, template_file), file_data)
+          end
+          spec_files
+        end
+      end
+    end
+  end
+end

data/lib/retrospec/plugins/v1/plugin/generators/module_generator.rb

@@ -5,12 +5,11 @@ module Retrospec
   module Puppet
     module Generators
       class ModuleGenerator < Retrospec::Plugins::V1::Plugin
-
-        attr_reader :template_dir, :context, :module_path, :fact_name, :config_data
+        attr_reader :template_dir, :context, :fact_name, :config_data
 
         # retrospec will initilalize this class so its up to you
         # to set any additional variables you need to get the job done.
-        def initialize(module_path, spec_object={})
+        def initialize(module_path, spec_object = {})
           super
           # below is the Spec Object which serves as a context for template rendering
           # you will need to initialize this object, so the erb templates can get the binding
@@ -24,27 +23,28 @@ module Retrospec
         # http://trollop.rubyforge.org
         # all options here are available in the config passed into config object
         # returns a new instance of this class
-        def self.run_cli(global_opts)
+        def self.run_cli(global_opts, args=ARGV)
           namespace     = global_opts['plugins::puppet::namespace'] || 'namespace'
           author        = global_opts['plugins::puppet::author'] || 'author_name'
-          sub_command_opts = Trollop::options do
+          license       = global_opts['plugins::puppet::default_license'] || 'Apache-2.0'
+          sub_command_opts = Trollop.options(args) do
             banner <<-EOS
 Generates a new module with the given name and namespace
 
             EOS
-            opt :name, "The name of the module you wish to create", :type => :string, :required => false, :short => '-n',
-                :default => File.basename(global_opts[:module_path])
-            opt :namespace, "The namespace to use only when creating a new module", :default => namespace, :required => false,
-                :type => :string
-            opt :author, "The full name of the module author", :default => author, :required => false, :short => '-a',
-                :type => :string
+            opt :name, 'The name of the module you wish to create', :type => :string, :required => true, :short => '-n',
+                                                                    :default => File.basename(global_opts[:module_path])
+            opt :namespace, 'The namespace to use only when creating a new module', :default => namespace, :required => false,
+                                                                                    :type => :string
+            opt :author, 'The full name of the module author', :default => author, :required => false, :short => '-a',
+                                                               :type => :string
+            opt :license, "The license type for the module", :default => license, :type => :string, :short => '-l'
           end
           unless sub_command_opts[:name]
             Trollop.educate
             exit 1
           end
           plugin_data = global_opts.merge(sub_command_opts)
-          Retrospec::Puppet::Generators::ModuleGenerator.new(plugin_data[:module_path], plugin_data)
         end
 
         def run(manifest_dir)
@@ -54,9 +54,7 @@ Generates a new module with the given name and namespace
             unless ENV['RETROSPEC_PUPPET_AUTO_GENERATE'] == 'true'
               print "The module located at: #{module_path} does not exist, do you wish to create it? (y/n): "
               answer = gets.chomp
-              unless answer =~ /y/i
-                exit 1
-              end
+              exit 1 unless answer =~ /y/i
             end
 
             create_manifest_file(init_class, content)
@@ -77,28 +75,30 @@ Generates a new module with the given name and namespace
         end
 
         # generates the metadata file in the module directory
-        def generate_metadata_file(mod_name,config_data)
+        def generate_metadata_file(mod_name, config_data)
           require 'puppet/module_tool/metadata'
           # make sure the metadata file exists
           module_path = config_data[:module_path]
+          license = config_data[:license] || config_data['plugins::puppet::default_license'] || 'Apache-2.0'
           author = config_data[:author] || config_data['plugins::puppet::author'] || 'your_name'
           namespace = config_data[:namespace] || config_data['plugins::puppet::namespace'] || 'namespace'
           metadata_file = File.join(module_path, 'metadata.json')
-          unless File.exists?(metadata_file)
+          unless File.exist?(metadata_file)
             # by default the module tool metadata checks for a namespece
-            if ! mod_name.include?('-')
+            if !mod_name.include?('-')
               name = "#{namespace}-#{mod_name}"
             else
               name = mod_name
             end
             begin
               metadata = ::Puppet::ModuleTool::Metadata.new.update(
-                  'name' => name.downcase,
-                  'version' => '0.1.0',
-                  'author'  => author,
-                  'dependencies' => [
-                      { 'name' => 'puppetlabs-stdlib', 'version_requirement' => '>= 4.9.0' }
-                  ]
+                'name' => name.downcase,
+                'version' => '0.1.0',
+                'author'  => author,
+                'license' => license,
+                'dependencies' => [
+                  { 'name' => 'puppetlabs-stdlib', 'version_requirement' => '>= 4.11.0' }
+                ]
               )
             rescue ArgumentError => e
               puts e.message
@@ -107,8 +107,7 @@ Generates a new module with the given name and namespace
             safe_create_file(metadata_file, metadata.to_json)
           end
         end
-
       end
     end
   end
-end
+end