pdk 0.1.0 → 0.2.0

data/lib/pdk/cli/validate.rb

@@ -1,81 +1,81 @@
-require 'cri'
-require 'pdk/cli/util/option_validator'
-require 'pdk/report'
+require 'pdk/util/bundler'
 
-require 'pdk/validate'
+module PDK::CLI
+  @validate_cmd = @base_cmd.define_command do
+    name 'validate'
+    usage _('validate [options]')
+    summary _('Run static analysis tests.')
+    description _('Run metadata, puppet, or ruby validation.')
 
-module PDK
-  module CLI
-    class Validate
-      include PDK::CLI::Util
+    flag nil, :list, _('list all available validators')
 
-      def self.command
-        @validate ||= Cri::Command.define do
-          name 'validate'
-          usage _("validate [options]")
-          summary _("Run static analysis tests.")
-          description _("Run metadata-json-lint, puppet parser validate, puppet-lint, or rubocop.")
+    run do |opts, args, _cmd|
+      validator_names = PDK::Validate.validators.map { |v| v.name }
+      validators = PDK::Validate.validators
+      targets = []
 
-          flag nil, :list, _("list all available validators")
+      if opts[:list]
+        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: validator_names.join(', ') })
+        exit 0
+      end
 
-          run do |opts, args, cmd|
-            validator_names = PDK::Validate.validators.map { |v| v.name }
-            validators = PDK::Validate.validators
-            targets = []
-            reports = nil
+      if args[0]
+        # This may be a single validator, a list of validators, or a target.
+        if Util::OptionValidator.comma_separated_list?(args[0])
+          # This is a comma separated list. Treat each item as a validator.
 
-            if opts[:list]
-              puts _("Available validators: %{validator_names}") % {validator_names: validator_names.join(', ')}
-              exit 0
-            end
+          vals = Util::OptionNormalizer.comma_separated_list_to_array(args[0])
+          validators = PDK::Validate.validators.select { |v| vals.include?(v.name) }
 
-            if args[0]
-              # This may be a single validator, a list of validators, or a target.
-              if OptionValidator.is_comma_separated_list?(args[0])
-                # This is a comma separated list. Treat each item as a validator.
+          invalid = vals.reject { |v| validator_names.include?(v) }
+          invalid.each do |v|
+            PDK.logger.warn(_("Unknown validator '%{v}'. Available validators: %{validators}") % { v: v, validators: validator_names.join(', ') })
+          end
+        else
+          # This is a single item. Check if it's a known validator, or otherwise treat it as a target.
+          val = PDK::Validate.validators.find { |v| args[0] == v.name }
+          if val
+            validators = [val]
+          else
+            targets = [args[0]]
+            # We now know that no validators were passed, so let the user know we're using all of them by default.
+            PDK.logger.info(_('Running all available validators...'))
+          end
+        end
+      else
+        PDK.logger.info(_('Running all available validators...'))
+      end
 
-                vals = OptionNormalizer.comma_separated_list_to_array(args[0])
-                validators = PDK::Validate.validators.find_all { |v| vals.include?(v.name) }
+      # Subsequent arguments are targets.
+      targets.concat(args[1..-1]) if args.length > 1
 
-                invalid = vals.find_all { |v| !validator_names.include?(v) }
-                invalid.each do |v|
-                  PDK.logger.warn(_("Unknown validator '%{v}'. Available validators: %{validators}") % {v: v, validators: validator_names.join(', ')})
-                end
-              else
-                # This is a single item. Check if it's a known validator, or otherwise treat it as a target.
-                val = PDK::Validate.validators.find { |v| args[0] == v.name }
-                if val
-                  validators = [val]
-                else
-                  targets = [args[0]]
-                  # We now know that no validators were passed, so let the user know we're using all of them by default.
-                  PDK.logger.info(_("Running all available validators..."))
-                end
-              end
-            else
-              PDK.logger.info(_("Running all available validators..."))
-            end
+      report = PDK::Report.new
+      report_formats = if opts[:format]
+                         PDK::CLI::Util::OptionNormalizer.report_formats(opts[:format])
+                       else
+                         [{
+                           method: PDK::Report.default_format,
+                           target: PDK::Report.default_target,
+                         }]
+                       end
 
-            # Subsequent arguments are targets.
-            targets.concat(args[1..-1]) if args.length > 1
+      options = targets.empty? ? {} : { targets: targets }
 
-            # Note: Reporting may be delegated to the validation tool itself.
-            if opts[:format]
-              reports = OptionNormalizer.report_formats(opts.fetch(:format))
-            end
+      exit_code = 0
 
-            options = targets.empty? ? {} : { :targets => targets }
-            validators.each do |validator|
-              result = validator.invoke(options)
-              if reports
-                reports.each do |r|
-                  r.write(result)
-                end
-              end
-            end
-          end
-        end
+      # Ensure that the bundle is installed and tools are available before running any validations.
+      PDK::Util::Bundler.ensure_bundle!
+
+      validators.each do |validator|
+        exit_code = validator.invoke(report, options)
+        break if exit_code != 0
       end
+
+      report_formats.each do |format|
+        report.send(format[:method], format[:target])
+      end
+
+      exit exit_code
     end
   end
 end

data/lib/pdk/generate.rb

@@ -1,3 +1,8 @@
+require 'pdk/generators/module'
+require 'pdk/generators/puppet_class'
+require 'pdk/module/metadata'
+require 'pdk/module/templatedir'
+
 module PDK
   module Generate; end
 end

data/lib/pdk/generators/module.rb

@@ -9,31 +9,35 @@ require 'pdk/module/templatedir'
 require 'pdk/cli/exec'
 require 'pdk/cli/input'
 require 'pdk/util'
+require 'pdk/util/version'
 
 module PDK
   module Generate
     class Module
-      DEFAULT_TEMPLATE = 'https://github.com/puppetlabs/pdk-module-template'
+      DEFAULT_TEMPLATE = 'https://github.com/puppetlabs/pdk-module-template'.freeze
 
-      def self.invoke(opts={})
+      def self.invoke(opts = {})
         defaults = {
+          'name'         => "#{Etc.getlogin}-#{opts[:name]}",
           'version'      => '0.1.0',
           'dependencies' => [
-            { 'name' => 'puppetlabs-stdlib', 'version_requirement' => '>= 1.0.0' }
-          ]
+            { 'name' => 'puppetlabs-stdlib', 'version_requirement' => '>= 4.13.1 < 5.0.0' },
+          ],
         }
 
-        defaults['license'] = opts[:license] if opts.has_key? :license
+        defaults['license'] = opts[:license] if opts.key? :license
         target_dir = File.expand_path(opts[:target_dir])
 
-        if File.exists?(target_dir)
-          raise PDK::CLI::FatalError, _("The destination directory '%{dir}' already exists") % {:dir => target_dir}
+        if File.exist?(target_dir)
+          raise PDK::CLI::FatalError, _("The destination directory '%{dir}' already exists") % { dir: target_dir }
         end
 
         metadata = PDK::Module::Metadata.new(defaults)
 
         module_interview(metadata, opts) unless opts[:'skip-interview'] # @todo Build way to get info by answers file
 
+        metadata.update!('pdk-version' => PDK::Util::Version.version_string)
+
         temp_target_dir = PDK::Util.make_tmpdir_name('pdk-module-target')
 
         prepare_module_directory(temp_target_dir)
@@ -67,60 +71,60 @@ module PDK
           begin
             FileUtils.mkdir_p(dir)
           rescue SystemCallError
-            raise PDK::CLI::FatalError, _("Unable to create directory '%{dir}'") % {:dir => dir}
+            raise PDK::CLI::FatalError, _("Unable to create directory '%{dir}'") % { dir: dir }
           end
         end
       end
 
-      def self.module_interview(metadata, opts={})
+      def self.module_interview(metadata, opts = {})
         puts _(
-          "We need to create a metadata.json file for this module. Please answer the " +
-          "following questions; if the question is not applicable to this module, feel free " +
-          "to leave it blank."
+          'We need to create a metadata.json file for this module. Please answer the ' \
+          'following questions; if the question is not applicable to this module, feel free ' \
+          'to leave it blank.',
         )
 
         begin
-          puts ""
-          forge_user = PDK::CLI::Input.get(_("What is your Puppet Forge username?"), Etc.getlogin)
+          puts ''
+          forge_user = PDK::CLI::Input.get(_('What is your Puppet Forge username?'), metadata.data['author'])
           metadata.update!('name' => "#{forge_user}-#{opts[:name]}")
         rescue StandardError => e
-          PDK.logger.error(_("We're sorry, we could not parse your module name: %{message}") % {:message => e.message})
+          PDK.logger.error(_("We're sorry, we could not parse your module name: %{message}") % { message: e.message })
           retry
         end
 
         begin
-          puts "\n" + _("Puppet uses Semantic Versioning (semver.org) to version modules.")
-          module_version = PDK::CLI::Input.get(_("What version is this module?"), metadata.data['version'])
+          puts "\n" + _('Puppet uses Semantic Versioning (semver.org) to version modules.')
+          module_version = PDK::CLI::Input.get(_('What version is this module?'), metadata.data['version'])
           metadata.update!('version' => module_version)
         rescue StandardError => e
-          PDK.logger.error(_("We're sorry, we could not parse that as a Semantic Version: %{message}") % {message: e.message})
+          PDK.logger.error(_("We're sorry, we could not parse that as a Semantic Version: %{message}") % { message: e.message })
           retry
         end
 
-        puts ""
-        module_author = PDK::CLI::Input.get(_("Who wrote this module?"), metadata.data['author'])
+        puts ''
+        module_author = PDK::CLI::Input.get(_('Who wrote this module?'), metadata.data['author'])
         metadata.update!('author' => module_author)
 
-        unless opts.has_key?(:license)
-          puts ""
-          module_license = PDK::CLI::Input.get(_("What license does this module code fall under?"), metadata.data['license'])
+        unless opts.key?(:license)
+          puts ''
+          module_license = PDK::CLI::Input.get(_('What license does this module code fall under?'), metadata.data['license'])
           metadata.update!('license' => module_license)
         end
 
-        puts ""
-        module_summary = PDK::CLI::Input.get(_("How would you describe this module in a single sentence?"))
+        puts ''
+        module_summary = PDK::CLI::Input.get(_('How would you describe this module in a single sentence?'), metadata.data['summary'])
         metadata.update!('summary' => module_summary)
 
-        puts ""
-        module_source = PDK::CLI::Input.get(_("Where is this module's source code repository?"))
+        puts ''
+        module_source = PDK::CLI::Input.get(_("Where is this module's source code repository?"), metadata.data['source'])
         metadata.update!('source' => module_source)
 
-        puts ""
-        module_page = PDK::CLI::Input.get(_("Where can others go to learn more about this module?"), metadata.data['project_page'])
+        puts ''
+        module_page = PDK::CLI::Input.get(_('Where can others go to learn more about this module?'), metadata.data['project_page'])
         metadata.update!('project_page' => module_page)
 
-        puts ""
-        module_issues = PDK::CLI::Input.get(_("Where can others go to file issues about this module?"), metadata.data['issues_url'])
+        puts ''
+        module_issues = PDK::CLI::Input.get(_('Where can others go to file issues about this module?'), metadata.data['issues_url'])
         metadata.update!('issues_url' => module_issues)
 
         puts
@@ -129,8 +133,8 @@ module PDK
         puts '-' * 40
         puts
 
-        if PDK::CLI::Input.get(_("About to generate this module; continue?"), 'Y') !~ /^y(es)?$/i
-          puts _("Aborting...")
+        unless PDK::CLI::Input.get(_('About to generate this module; continue?'), 'Y') =~ %r{^y(es)?$}i # rubocop:disable Style/GuardClause
+          puts _('Aborting...')
           exit 0
         end
       end

data/lib/pdk/generators/puppet_class.rb

@@ -10,7 +10,7 @@ module PDK
       # @return [Hash{Symbol => Object}] a hash of information that will be
       # provided to the class and class spec templates during rendering.
       def template_data
-        data = {name: object_name}
+        data = { name: object_name }
         if @options.key?(:params)
           data[:params] = @options[:params]
           data[:max_type_length] = @options[:params].map { |r| r[:type].length }.max

data/lib/pdk/generators/puppet_object.rb

@@ -31,14 +31,14 @@ module PDK
         @module_dir = module_dir
         @options = options
 
-        if [:class, :defined_type].include?(object_type)
+        if [:class, :defined_type].include?(object_type) # rubocop:disable Style/GuardClause
           object_name_parts = object_name.split('::')
 
-          if object_name_parts.first == module_name
-            @object_name = object_name
-          else
-            @object_name = [module_name, object_name].join('::')
-          end
+          @object_name = if object_name_parts.first == module_name
+                           object_name
+                         else
+                           [module_name, object_name].join('::')
+                         end
         end
       end
 
@@ -84,12 +84,12 @@ module PDK
       def run
         [target_object_path, target_spec_path].each do |target_file|
           if File.exist?(target_file)
-            raise PDK::CLI::FatalError, _("Unable to generate class, '%{file}' already exists.") % {file: target_file}
+            raise PDK::CLI::FatalError, _("Unable to generate class, '%{file}' already exists.") % { file: target_file }
           end
         end
 
         with_templates do |template_path, config_hash|
-          data = template_data.merge(:configs => config_hash)
+          data = template_data.merge(configs: config_hash)
 
           render_file(target_object_path, template_path[:object], data)
           render_file(target_spec_path, template_path[:spec], data) if template_path[:spec]
@@ -109,7 +109,7 @@ module PDK
       #
       # @api private
       def render_file(dest_path, template_path, data)
-        PDK.logger.info(_("Creating %{file} from template.") % {file: dest_path})
+        PDK.logger.info(_("Creating '%{file}' from template.") % { file: dest_path })
         file_content = PDK::TemplateFile.new(template_path, data).render
         FileUtils.mkdir_p(File.dirname(dest_path))
         File.open(dest_path, 'w') { |f| f.write file_content }
@@ -132,7 +132,7 @@ module PDK
       def with_templates
         templates.each do |template|
           if template[:url].nil?
-            PDK.logger.debug(_("No %{dir_type} template specified; trying next template directory.") % {dir_type: template[:type]})
+            PDK.logger.debug(_('No %{dir_type} template specified; trying next template directory.') % { dir_type: template[:type] })
             next
           end
 
@@ -142,13 +142,12 @@ module PDK
             if template_paths
               config_hash = template_dir.object_config
               yield template_paths, config_hash
-              return
+              # TODO: refactor to a search-and-execute form instead
+              return # work is done # rubocop:disable Lint/NonLocalExitFromIterator
+            elsif template[:allow_fallback]
+              PDK.logger.debug(_('Unable to find a %{type} template in %{url}, trying next template directory') % { type: object_type, url: template[:url] })
             else
-              if template[:allow_fallback]
-                PDK.logger.debug(_("Unable to find a %{type} template in %{url}, trying next template directory") % {type: object_type, url: template[:url]})
-              else
-                raise PDK::CLI::FatalError, _("Unable to find the %{type} template in %{url}.") % {type: object_type, url: template[:url]}
-              end
+              raise PDK::CLI::FatalError, _('Unable to find the %{type} template in %{url}.') % { type: object_type, url: template[:url] }
             end
           end
         end
@@ -176,9 +175,9 @@ module PDK
       # @api private
       def templates
         @templates ||= [
-          {type: 'CLI', url: @options[:'template-url'], allow_fallback: false},
-          {type: 'metadata', url: module_metadata.data['template-url'], allow_fallback: true},
-          {type: 'default', url: PDK::Generate::Module::DEFAULT_TEMPLATE, allow_fallback: false},
+          { type: 'CLI', url: @options[:'template-url'], allow_fallback: false },
+          { type: 'metadata', url: module_metadata.data['template-url'], allow_fallback: true },
+          { type: 'default', url: PDK::Generate::Module::DEFAULT_TEMPLATE, allow_fallback: false },
         ]
       end
 
@@ -205,7 +204,7 @@ module PDK
         @module_metadata ||= begin
           PDK::Module::Metadata.from_file(File.join(module_dir, 'metadata.json'))
         rescue ArgumentError => e
-          raise PDK::CLI::FatalError, _("'%{dir}' does not contain valid Puppet module metadata; %{msg}") % {dir: module_dir, msg: e.message}
+          raise PDK::CLI::FatalError, _("'%{dir}' does not contain valid Puppet module metadata: %{msg}") % { dir: module_dir, msg: e.message }
         end
       end
     end

data/lib/pdk/logger.rb

@@ -11,7 +11,7 @@ module PDK
       super(STDOUT)
 
       # TODO: Decide on output format.
-      self.formatter = proc do |severity,datetime,progname,msg|
+      self.formatter = proc do |severity, _datetime, _progname, msg|
         "pdk (#{severity}): #{msg}\n"
       end
 

data/lib/pdk/module/metadata.rb

@@ -3,21 +3,38 @@ require 'json'
 module PDK
   module Module
     class Metadata
-
       attr_accessor :data
 
       DEFAULTS = {
         'name'          => nil,
         'version'       => nil,
         'author'        => nil,
-        'summary'       => nil,
+        'summary'       => '',
         'license'       => 'Apache-2.0',
         'source'        => '',
         'project_page'  => nil,
         'issues_url'    => nil,
         'dependencies'  => Set.new.freeze,
         'data_provider' => nil,
-      }
+        'operatingsystem_support' => [
+          {
+            'operatingsystem' => 'Debian',
+            'operatingsystemrelease' => ['8'],
+          },
+          {
+            'operatingsystem' => 'RedHat',
+            'operatingsystemrelease' => ['7.0'],
+          },
+          {
+            'operatingsystem' => 'Ubuntu',
+            'operatingsystemrelease' => ['16.04'],
+          },
+          {
+            'operatingsystem' => 'Windows',
+            'operatingsystemrelease' => ['2016'],
+          },
+        ],
+      }.freeze
 
       def initialize(params = {})
         @data = DEFAULTS.dup
@@ -26,17 +43,17 @@ module PDK
 
       def self.from_file(metadata_json_path)
         unless File.file?(metadata_json_path)
-          raise ArgumentError, _("'%{file}' does not exist or is not a file") % {file: metadata_json_path}
+          raise ArgumentError, _("'%{file}' does not exist or is not a file") % { file: metadata_json_path }
         end
 
         unless File.readable?(metadata_json_path)
-          raise ArgumentError, _("Unable to open '%{file}' for reading") % {file: metadata_json_path}
+          raise ArgumentError, _("Unable to open '%{file}' for reading") % { file: metadata_json_path }
         end
 
         begin
           data = JSON.parse(File.read(metadata_json_path))
         rescue JSON::JSONError => e
-          raise ArgumentError, _("Invalid JSON in metadata.json: %{msg}") % {msg: e.message}
+          raise ArgumentError, _('Invalid JSON in metadata.json: %{msg}') % { msg: e.message }
         end
 
         new(data)
@@ -58,28 +75,28 @@ module PDK
       # Do basic validation and parsing of the name parameter.
       def process_name(data)
         validate_name(data['name'])
-        author, module_name = data['name'].split(/[-\/]/, 2)
+        author, _modname = data['name'].split(%r{[-/]}, 2)
 
         data['author'] ||= author if @data['author'] == DEFAULTS['author']
       end
 
       # Validates that the given module name is both namespaced and well-formed.
       def validate_name(name)
-        return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
+        return if name =~ %r{\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z}i
 
-        namespace, modname = name.split(/[-\/]/, 2)
+        namespace, modname = name.split(%r{[-/]}, 2)
         modname = :namespace_missing if namespace == ''
 
         err = case modname
-        when nil, '', :namespace_missing
-          "the field must be a dash-separated username and module name"
-        when /[^a-z0-9_]/i
-          "the module name contains non-alphanumeric (or underscore) characters"
-        when /^[^a-z]/i
-          "the module name must begin with a letter"
-        else
-          "the namespace contains non-alphanumeric characters"
-        end
+              when nil, '', :namespace_missing
+                'the field must be a dash-separated username and module name'
+              when %r{[^a-z0-9_]}i
+                'the module name contains non-alphanumeric (or underscore) characters'
+              when %r{^[^a-z]}i
+                'the module name must begin with a letter'
+              else
+                'the namespace contains non-alphanumeric characters'
+              end
 
         raise ArgumentError, "Invalid 'name' field in metadata.json: #{err}"
       end