puppet-retrospec 0.11.0 → 0.12.0

data/lib/retrospec/plugins/v1/plugin/generators/{facter.rb → parsers/facter.rb}

@@ -1,5 +1,4 @@
 require 'ostruct'
-
 # this is required to use when processing erb templates
 class OpenStruct
   def get_binding
@@ -16,20 +15,14 @@ module Retrospec
           class Execution
             def self.execute(command, options={})
               value = {:klass => self.to_s.gsub('Retrospec::Puppet::Generators::', ''),
-              :method => :execute, :value => command}
+                       :method => :execute, :value => command}
               Retrospec::Puppet::Generators::Facter.exec_calls[command] = value
             end
           end
         end
 
-        @model = OpenStruct.new(:facts => {})
-        @used_facts = {}
-        @confines = []
-        @methods_defined = []
-
         def initialize(name, options, &block)
           @fact_name = name
-          #block.call
         end
 
         def self.exec_calls
@@ -40,6 +33,10 @@ module Retrospec
           @used_facts ||= {}
         end
 
+        def self.methods_defined
+          @methods_defined ||= []
+        end
+
         def self.value(name)
           used_facts[name] = {:name => name}
         end
@@ -51,12 +48,16 @@ module Retrospec
         end
 
         def self.method_missing(method_sym, *arguments, &block)
-          @methods_defined << method_sym
+          unless methods_defined.include?(method_sym)
+            methods_defined << method_sym
+          end
+          method_sym
         end
 
         def self.setcode(&block)
           begin
             block.call
+          rescue Exception => e
           rescue NameError => e
           end
         end
@@ -68,49 +69,41 @@ module Retrospec
         # loads the fact into the loader for evaluation
         # and data collection
         def self.load_fact(file)
-          @model = OpenStruct.new(:facts => {})
-          @used_facts = {}
-          @model = eval(File.read(file))
-          transform_data(@model)
+          @model = OpenStruct.new(:facts => {}, :defined_methods => [], :global_used_facts => {}, :global_used_execs => {})
+          begin
+            proc = Proc.new {}
+            eval(File.read(file), proc.binding, file)
+          rescue LoadError => e
+            puts "Error loading dependency for file: #{file}, skipping".fatal
+          rescue Exception => e
+            puts "Error evaluating file: #{file}, skipping".fatal
+          end
+          @model
         end
 
         # every fact will have a Facter.add functionality
         # this is the startign point to collect all data
         def self.add(name, options={}, &block)
-          @model.facts[name] = OpenStruct.new(:fact_name => name)
           # calls the facter.add block
           # this may call separate confine statements
-          @model.global_used_facts = used_facts
-          @used_facts = {}  # clear before fact specific are evaluated
-          @model.global_used_execs = exec_calls
+          # for each Facter.add block that gets called we need to reset a few things
+          @confines = {}
+          @used_facts = {}
           @exec_calls = {}
           begin
             block.call
+          rescue Exception => e
           rescue NameError => e
           end
+
+          @model.facts[name] = OpenStruct.new(:fact_name => name)
           @model.facts[name].used_facts = used_facts
           @model.facts[name].confines = @confines
-          # clear any persistant data
-          @confines = []
-          @model.defined_methods = @methods_defined
+          @model.defined_methods = methods_defined
           @model.facts[name].exec_calls = exec_calls
           @model
         end
-
-        def self.transform_data(data)
-          #ObenStruct.new(:)
-          # {:method_fact=>
-          #      {:fact_name=>:method_fact,
-          #       :used_facts=>{:is_virtual=>{:name=>:is_virtual}},
-          #       :confines=>[{:kernel=>"Linux"}],
-          #       :exec_calls=>["which lsb"]},
-          #  :global_used_facts=>{},
-          #  :global_used_execs=>[],
-          #  :defined_methods=>[:default_kernel]}
-          data
-        end
       end
-
      end
   end
-end
+end

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

@@ -0,0 +1,91 @@
+require 'ostruct'
+require 'retrospec/plugins/v1/plugin/puppet_module'
+# this is required to use when processing erb templates
+class OpenStruct
+  def get_binding
+    binding
+  end
+end
+
+module Retrospec
+  module Puppet
+    module Functions
+      # for puppet 4 functions
+      def self.create_function(func_name, function_base = nil, &block)
+        # the bundled version of puppet with this gem is quite old and is preventing me from creating a function
+        # to get the actual properties of it.  For now we can just skip the creation and stub enough functions
+        # to get at the data.  However, if we just eval the file we can probably bypass all this code and use class
+        # methods instead
+        #require 'puppet/pops'
+        #f = ::Puppet::Functions.create_function(func_name, function_base, &block)
+        block.call
+        @model.name = func_name
+      end
+
+      def self.load_function(file)
+        begin
+          ::Puppet.initialize_settings
+        rescue
+          # do nothing otherwise calling init twice raises an error
+        end
+        @model = OpenStruct.new(:name => File.basename(file, '.rb'), :dispatched_methods => {},
+                                :required_methods => [])
+
+        f = eval(File.read(file))
+        @model.required_methods = find_required_methods(@model.name, @model.dispatched_methods.keys)
+        @model
+      end
+
+      # figures out which methods need to be present in the function so that we can create a test for them
+      def self.find_required_methods(name, dispatched_methods=[])
+        if dispatched_methods.empty?
+          [name]
+        else
+          dispatched_methods
+        end
+      end
+
+      def self.dispatch(meth_name, &block)
+          @params = [] # reset the variable
+          args = block.call
+          @model.dispatched_methods[meth_name] = {:name => meth_name, :args => args}
+      end
+
+      # this is a catch all method that helps us discover which dsl methods are used
+      def self.method_missing(meth_sym, *arguments, &block)
+        @params << {:name => meth_sym, :args => arguments}
+      end
+
+    end
+
+    module Parser
+      module Functions
+        # for puppet 3 functions
+        def self.newfunction(name, options = {}, &block)
+          options.merge({:name => name})
+        end
+
+        # for puppet 4 functions
+        def self.create_function(func_name, function_base = Function, &block)
+          {:name => func_name }
+        end
+
+        def self.load_function(file)
+          begin
+            ::Puppet.initialize_settings
+          rescue
+            # do nothing otherwise calling init twice raises an error
+          end
+          @model = OpenStruct.new(:name => File.basename(file, '.rb'), :arity => nil, :doc => '', :type => nil,
+                                  :class_methods => [], :instance_methods => [], :options => {})
+          f = eval(File.read(file))
+          @model.name = f[:name]
+          @model.arity = f[:arity]
+          @model.doc   = f[:doc]
+          @model.type = f[:type]
+          @model
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'ostruct'
+
+# this is required to use when processing erb templates
+class OpenStruct
+  def get_binding
+    binding
+  end
+end
+# we could also create a new instance of the type and use instances methods to retrieve many things
+# Puppet::Type.type(type_name) after loading the file
+module Retrospec
+  module Puppet
+    class Type
+      # loads the type_file and provider_file if given
+      # determines if type or provider is being used and
+      # evals the code
+      # if the provider_file is not loadable we cannot build a full context
+      # for the template to be rendered with so we use a default context instead
+      def self.load_type(type_file, provider_file = nil)
+        if provider_file
+          begin
+            file = provider_file
+            @model = OpenStruct.new(:name => File.basename(file, '.rb'), :file => file,
+                                    :class_methods => [], :instance_methods => [],
+                                    :properties => [], :parameters => [])
+            require type_file
+            require provider_file
+            t = eval(File.read(file))
+            @model.parameters = t.resource_type.parameters
+            @model.properties = t.resource_type.validproperties
+            @model.name = t.name
+            @model.class_methods = t.methods(false)
+            @model.instance_methods = t.instance_methods(false)
+          rescue LoadError => e
+            puts "#{e.message}, generating empty file".fatal
+          rescue NameError => e
+            puts "#{e.message}, is this valid provider code?".fatal
+          rescue NoMethodError => e
+            puts "#{e.message}, is this valid provider code?".fatal
+          rescue ::Puppet::Context::UndefinedBindingError => e
+            puts "There was an issue with loading the provider code for #{file}, skipping".fatal
+          end
+          @model
+        else
+          begin
+            require type_file
+            file = type_file
+            @model = OpenStruct.new(:name => File.basename(file, '.rb'), :file => file,
+                                    :properties => [], :instance_methods => [],
+                                    :parameters => [], :methods_defined => [])
+            t = eval(File.read(file))
+            @model.name = t.name
+            @model.parameters = t.parameters
+            @model.properties = t.properties.collect(&:name)
+            @model.instance_methods = t.instance_methods(false)
+            @model
+          rescue LoadError => e
+            puts "#{e.message}, generating empty file".fatal
+          rescue NameError => e
+            puts "#{e.message}, is this valid type code?".fatal
+          rescue NoMethodError => e
+            puts "#{e.message}, is this valid type code?".fatal
+          end
+        end
+        @model
+      end
+
+      def self.type(name, _options = {}, &_block)
+        ::Puppet::Type.type(name)
+      end
+
+      # I don't know of a better way to get the name of the type
+      def self.newtype(name, _options = {}, &_block)
+        ::Puppet::Type.type(name)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require_relative 'parsers/type'
+require 'facets'
+
+module Retrospec::Puppet::Generators
+  class ProviderGenerator < Retrospec::Plugins::V1::Plugin
+    attr_reader :template_dir, :context
+    attr_accessor :provider_type
+
+    # retrospec will initaialize this class so its up to you
+    # to set any additional variables you need in the context in feed the templates.
+    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(:provider_name => spec_object[:name], :type_name => spec_object[:type])
+      @provider_type = context.type_name
+    end
+
+    # returns the path to the templates
+    # first looks inside the external templates directory for specific file
+    # then looks inside the gem path templates directory, which is really only useful
+    # when developing new templates.
+    def template_dir
+      external_templates = File.expand_path(File.join(config_data[:template_dir], 'providers', 'provider_template.rb.retrospec.erb'))
+      if File.exist?(external_templates)
+        File.join(config_data[:template_dir], 'providers')
+      else
+        File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'templates', 'providers'))
+      end
+    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)
+      sub_command_opts = Trollop.options(args) do
+        banner <<-EOS
+Generates a new provider with the given name.
+
+        EOS
+        opt :name, 'The name of the provider you wish to create', :type => :string, :required => true, :short => '-n'
+        opt :type, 'The type name of the provider', :type => :string, :required => true, :short => '-t'
+      end
+      unless sub_command_opts[:name]
+        Trollop.educate
+        exit 1
+      end
+      plugin_data = global_opts.merge(sub_command_opts)
+      plugin_data
+    end
+
+    def provider_dir
+      File.join(module_path, 'lib', 'puppet', 'provider')
+    end
+
+    def type_dir
+      File.join(module_path, 'lib', 'puppet', 'type')
+    end
+
+    # returns the type file that the provider uses
+    # if the type file does not exist it assumes a core puppet type
+    # because we could potentially dealing with multiple
+    def type_file(p_type = provider_type)
+      if TypeGenerator::CORE_TYPES.include?(p_type)
+        type_file = "puppet/type/#{p_type}.rb"
+      else
+        type_file = File.join(type_dir, "#{p_type}.rb")
+      end
+      type_file
+    end
+
+    def provider_spec_dir
+      File.join(module_path, 'spec', 'unit', 'puppet', 'provider')
+    end
+
+    def provider_name_path
+      File.join(provider_dir, provider_type, "#{provider_name}.rb")
+    end
+
+    def provider_name
+      context.provider_name
+    end
+
+    def generate_provider_files
+      safe_create_template_file(provider_name_path, File.join(template_dir, 'provider_template.rb.retrospec.erb'), context)
+      provider_name_path
+    end
+
+    def generate_provider_spec_files
+      provider_files = Dir.glob(File.join(provider_dir, '**', '*.rb')).sort
+      spec_files = []
+      provider_files.each do |provider_file|
+        t_name = File.basename(File.dirname(provider_file))
+        provider_file_data = Retrospec::Puppet::Type.load_type(type_file(t_name), provider_file)
+        provider_file_data.type_name = t_name # add the provider type
+        # because many facts can be in a single file we want to create a unique file for each fact
+        provider_spec_path = File.join(provider_spec_dir, t_name, "#{provider_file_data.name}_spec.rb")
+        spec_files << provider_spec_path
+        safe_create_template_file(provider_spec_path, File.join(template_dir, 'provider_spec.rb.retrospec.erb'), provider_file_data)
+      end
+      spec_files
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+require 'yaml'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class SchemaGenerator < Retrospec::Plugins::V1::Plugin
+        attr_reader :template_dir, :schema
+        attr_accessor :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(:puppet_context => spec_object[:puppet_context])
+          @schema = base_schema
+          @parameter_count = 0
+        end
+
+        # returns the path to the templates
+        # first looks inside the external templates directory for specific file
+        # then looks inside the gem path templates directory, which is really only useful
+        # when developing new templates.
+        def template_dir
+          external_templates = File.expand_path(File.join(config_data[:template_dir], 'schemas', 'schema_file.yaml.retrospec.erb'))
+          if File.exist?(external_templates)
+            File.join(config_data[:template_dir], 'schemas')
+          else
+            File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'templates', 'schemas'))
+          end
+        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)
+          sub_command_opts = Trollop.options(args) do
+            banner <<-EOS
+Generates a kwalify schema based off class parameters.
+
+            EOS
+          end
+          plugin_data = global_opts.merge(sub_command_opts)
+          plugin_data
+        end
+
+        # creates the schema in ruby object format
+        def create_map_content
+          all_hiera_data.each do |name, opts|
+            add_mapping(name => opts)
+          end
+          schema
+        end
+
+        def schema_name
+          puppet_context.module_name || File.basename(module_path)
+        end
+
+        # absolute path of schema file
+        def schema_path
+          File.join(module_path, "#{schema_name}_schema.yaml")
+        end
+
+        # generates the schema file, using a template
+        def generate_schema_file
+          map_content = create_map_content
+          context[:map_content] = map_content.to_yaml
+          context[:raw_maps] = map_content
+          context[:parameter_count] = @parameter_count
+          context[:schema_path] = schema_path
+          context[:schema_name] = schema_name
+          template_file = File.join(template_dir, 'schema_file.yaml.retrospec.erb')
+          safe_create_template_file(schema_path, template_file, context)
+          schema_path
+        end
+
+        # example
+        # "motd::motd_content" => {
+        #   "type" => "str",
+        #   "required" => false
+        # },
+        def add_mapping(map_value)
+          schema['mapping'].merge!(map_value)
+        end
+
+        def types
+          context.puppet_context.types
+        end
+
+        private
+
+        # generates a class or defination map
+        def generate_type_map(puppet_type)
+          type_name = puppet_type.type.to_s
+          arg_map = {}
+          #arg_map = {'mapping' => {}, 'required' => false, 'type' => 'map' }
+          puppet_type.arguments.each do |k, _v|
+            key = "#{puppet_type.name}::#{k}"
+            kwalify_type = type_map(_v.class)
+            @parameter_count = @parameter_count + 1
+            arg_map.deep_merge!(generate_map(key, _v, kwalify_type))
+          end
+          t_map = {type_name => { 'type' => 'map', 'mapping' => arg_map}}
+        end
+
+        # returns a hash of parameters with their classes
+        def parameter_schema(found_types)
+          parameter_data = {}
+          found_types.each do |t|
+            parameter_data = parameter_data.deep_merge(generate_type_map(t))
+          end
+          parameter_data
+        end
+
+        # gathers all the class parameters that could be used in hiera data mocking
+        # this is the only function that generates the necessary data to be used for schema
+        # creation.
+        def all_hiera_data
+          if @all_hiera_data.nil?
+            @all_hiera_data = parameter_schema(types)
+          end
+          @all_hiera_data
+        end
+
+        def is_required?(item)
+          item.nil?
+        end
+
+        def base_schema
+          @base_schema ||= {
+            "type" => "map",
+            "mapping" => {
+              "hostclass" => {
+                "type" => "map",
+                "mapping" => {}
+              },
+              "definition" => {
+                "type" => "map",
+                "mapping" => {}
+              }
+            }
+          }
+        end
+
+        def any_map
+          {"=" => {
+              "type" => "any",
+              "required" => false
+            }
+          }
+        end
+
+        def puppet_context
+          context.puppet_context
+        end
+
+        # conversion table from ruby types to kwalify types
+        def type_table
+          @type_table ||= {
+            'Array'=>"seq",
+            'Hash'=>"map",
+            'String'=>"str",
+            'Integer'=>"int",
+            'Float'=>"float",
+            'Numeric'=>"number",
+            'Date'=>"date",
+            'Time'=>"timestamp",
+            'Object'=>"any",
+            'FalseClass' => 'bool',
+            'TrueClass' => 'bool',
+            'Fixnum' => 'number',
+            'NilClass' => 'any',
+            'Puppet::Parser::AST::Variable' => 'any',
+            'Puppet::Parser::AST::Boolean' => 'bool',
+            'Puppet::Parser::AST::String' => 'str',
+            'Puppet::Parser::AST::ASTHash' => 'map',
+            'Puppet::Parser::AST::ASTArray' => 'seq',
+          }
+        end
+
+        # convert the given class to a kwalify class, defaults to any
+        def type_map(klass)
+          type_table[klass.to_s] || 'any'
+        end
+
+        # given a kwalify key undefined error
+        # this method will produce a map of how the key should be defined
+        # example
+        #"motd::motd_content" => {
+        #   "type" => "str",
+        #   "required" => false
+        # },
+        def generate_map(key, value, value_type)
+          case value_type
+            when 'seq'
+              {key => {
+                "type" => 'seq',
+                "sequence" => [{'type' => 'str'}],
+                "required" => is_required?(value)
+              }}
+            when 'map'
+              {key => {
+                "type" => 'map',
+                "mapping" => {'=' => {'type' => 'any', 'required' => false}},
+                "required" => is_required?(value)
+              }}
+            else
+              {key => {
+                "type" => value_type,
+                "required" => is_required?(value)
+              }}
+          end
+        end
+      end
+    end
+  end
+end
+