pdk 0.1.0 → 0.2.0

data/lib/pdk/cli/input.rb

@@ -10,10 +10,10 @@ module PDK
       #
       # @return [String] The value provided by the user (or the supplied
       # default value).
-      def self.get(message, default=nil)
+      def self.get(message, default = nil)
         print message
         if default.nil?
-          print " [(none)]"
+          print ' [(none)]'
         else
           print " [#{default}]"
         end

data/lib/pdk/cli/new.rb

@@ -1,30 +1,15 @@
-require 'cri'
-require 'pdk/cli/new/module'
-require 'pdk/cli/new/class'
-
-module PDK
-  module CLI
-    module New
-      def self.command
-        @new ||= Cri::Command.new.tap do |cmd|
-          cmd.modify do
-            name 'new'
-            usage _("new <type> [options]")
-            summary _("create a new module, etc.")
-            description _("Creates a new instance of <type> using the options relevant to that type of thing")
-
-            # print the help text for the 'new' sub command if no type has been
-            # provided.
-            run do |opts, args, cmd|
-              puts command.help
-              exit 1
-            end
-          end
 
-          cmd.add_command(PDK::CLI::New::Module.command)
-          cmd.add_command(PDK::CLI::New::PuppetClass.command)
-        end
-      end
-    end
+module PDK::CLI
+  @new_cmd = @base_cmd.define_command do
+    name 'new'
+    usage _('new <type> [options]')
+    summary _('create a new module, etc.')
+    description _('Creates a new instance of <type> using the options relevant to that type of thing')
+    default_subcommand 'help'
   end
+
+  @new_cmd.add_command Cri::Command.new_basic_help
 end
+
+require 'pdk/cli/new/class'
+require 'pdk/cli/new/module'

data/lib/pdk/cli/new/class.rb

@@ -1,45 +1,32 @@
-require 'cri'
-require 'pdk/cli/util/option_validator'
-
-require 'pdk/generators/module'
-require 'pdk/generators/puppet_class'
-
-module PDK
-  module CLI
-    module New
-      class PuppetClass
-        include PDK::CLI::Util
-
-        def self.command
-          @puppet_class ||= Cri::Command.define do
-            name 'class'
-            usage _("class [options] <class_name> [parameter[:type]] [parameter[:type]] ...")
-            summary _("Create a new class named <class_name> using given options")
-
-            option nil, 'template-url', _("Specifies the URL to the template to use when creating the module. Defaults to the template used to create the module, otherwise %{default}") % {:default => PDK::Generate::Module::DEFAULT_TEMPLATE}, argument: :required
-
-            run do |opts, args, cmd|
-              class_name = args[0]
-              module_dir = Dir.pwd
-
-              if class_name.nil? || class_name.empty?
-                puts command.help
-                exit 1
-              end
-
-              unless PDK::CLI::Util::OptionValidator.is_valid_class_name?(class_name)
-                raise PDK::CLI::FatalError, _("'%{name}' is not a valid class name") % {name: class_name}
-              end
-
-              if args.length > 1
-                opts[:params] = args[1..-1].map { |r| PDK::CLI::Util::OptionNormalizer.parameter_specification(r) }
-              end
-
-              PDK::Generate::PuppetClass.new(module_dir, class_name, opts).run
-            end
-          end
-        end
+
+module PDK::CLI
+  @new_class_cmd = @new_cmd.define_command do
+    name 'class'
+    usage _('class [options] <class_name> [parameter[:type]] [parameter[:type]] ...')
+    summary _('Create a new class named <class_name> using given options')
+
+    PDK::CLI.template_url_option(self)
+
+    run do |opts, args, _cmd|
+      require 'pdk/generators/puppet_class'
+
+      class_name = args[0]
+      module_dir = Dir.pwd
+
+      if class_name.nil? || class_name.empty?
+        puts command.help
+        exit 1
       end
+
+      unless Util::OptionValidator.valid_class_name?(class_name)
+        raise PDK::CLI::FatalError, _("'%{name}' is not a valid class name") % { name: class_name }
+      end
+
+      if args.length > 1
+        opts[:params] = args[1..-1].map { |r| Util::OptionNormalizer.parameter_specification(r) }
+      end
+
+      PDK::Generate::PuppetClass.new(module_dir, class_name, opts).run
     end
   end
 end

data/lib/pdk/cli/new/module.rb

@@ -1,55 +1,44 @@
-require 'cri'
-require 'pdk/cli/util/option_validator'
 
-require 'pdk/generators/module'
+module PDK::CLI
+  @new_module_cmd = @new_cmd.define_command do
+    name 'module'
+    usage _('module [options] <module_name> [target_dir]')
+    summary _('Create a new module named <module_name> using given options')
 
-module PDK
-  module CLI
-    module New
-      class Module
-        include PDK::CLI::Util
+    PDK::CLI.template_url_option(self)
 
-        def self.command
-          @module ||= Cri::Command.define do
-            name 'module'
-            usage _("module [options] <module_name> [target_dir]")
-            summary _("Create a new module named <module_name> using given options")
+    option nil, 'license', _('Specifies the license this module is written under. ' \
+      "This should be a identifier from https://spdx.org/licenses/. Common values are 'Apache-2.0', 'MIT', or 'proprietary'."), argument: :required
 
-            option nil, 'template-url', _("Specifies the URL to the template to use when creating the module. Defaults to %{default}") % {:default => PDK::Generate::Module::DEFAULT_TEMPLATE}, argument: :required
+    option nil, 'vcs', _("Specifies the version control driver. Valid values: 'git', 'none'. Default: 'git'."), argument: :required
 
-            option nil, 'license', _("Specifies the license this module is written under. This should be a identifier from https://spdx.org/licenses/. Common values are 'Apache-2.0', 'MIT', or 'proprietary'."), argument: :required
+    flag nil, 'skip-interview', _('When specified, skips interactive querying of metadata.')
 
-            option nil, 'vcs', _("Specifies the version control driver. Valid values: 'git', 'none'. Default: 'git'."), argument: :required
+    run do |opts, args, _cmd|
+      require 'pdk/generators/module'
 
-            flag nil, 'skip-interview', _("When specified, skips interactive querying of metadata.")
+      module_name = args[0]
+      target_dir = args[1]
 
-            run do |opts, args, cmd|
-              module_name = args[0]
-              target_dir = args[1]
-
-              if module_name.nil? || module_name.empty?
-                puts command.help
-                exit 1
-              end
+      if module_name.nil? || module_name.empty?
+        puts command.help
+        exit 1
+      end
 
-              unless OptionValidator.is_valid_module_name?(module_name)
-                error_msg = _(
-                  "'%{module_name}' is not a valid module name.\n" +
-                  "Module names must begin with a lowercase letter and can only include lowercase letters, digits, and underscores."
-                ) % {:module_name => module_name}
-                raise PDK::CLI::FatalError.new(error_msg)
-              end
+      unless Util::OptionValidator.valid_module_name?(module_name)
+        error_msg = _(
+          "'%{module_name}' is not a valid module name.\n" \
+          'Module names must begin with a lowercase letter and can only include lowercase letters, digits, and underscores.',
+        ) % { module_name: module_name }
+        raise PDK::CLI::FatalError, error_msg
+      end
 
-              opts[:name] = module_name
-              opts[:target_dir] = target_dir.nil? ? module_name : target_dir
-              opts[:vcs] ||= 'git'
+      opts[:name] = module_name
+      opts[:target_dir] = target_dir.nil? ? module_name : target_dir
+      opts[:vcs] ||= 'git'
 
-              PDK.logger.info(_("Creating new module: %{modname}") % {:modname => module_name})
-              PDK::Generate::Module.invoke(opts)
-            end
-          end
-        end
-      end
+      PDK.logger.info(_('Creating new module: %{modname}') % { modname: module_name })
+      PDK::Generate::Module.invoke(opts)
     end
   end
 end

data/lib/pdk/cli/test.rb

@@ -1,23 +1,12 @@
-require 'cri'
-require 'pdk/cli/tests/unit'
-require 'pdk/report'
 
-
-module PDK
-  module CLI
-    module Test
-
-      def self.command
-        @test ||= Cri::Command.new.tap do |cmd|
-          cmd.modify do
-            name 'test'
-            usage _("test [type] [options]")
-            summary _("Run tests.")
-          end
-
-          cmd.add_command(PDK::CLI::Test::Unit.command)
-        end
-      end
-    end
+module PDK::CLI
+  @test_cmd = @base_cmd.define_command do
+    name 'test'
+    usage _('test [type] [options]')
+    summary _('Run tests.')
+    default_subcommand 'help'
   end
+  @test_cmd.add_command Cri::Command.new_basic_help
 end
+
+require 'pdk/cli/test/unit'

data/lib/pdk/cli/test/unit.rb

@@ -0,0 +1,38 @@
+
+module PDK::CLI
+  @test_unit_cmd = @test_cmd.define_command do
+    name 'unit'
+    usage _('unit [options]')
+    summary _('Run unit tests.')
+
+    flag nil, :list, _('list all available unit tests and their descriptions')
+
+    option nil, :tests, _('a comma-separated list of tests to run'), argument: :required do |values|
+      OptionValidator.list(values)
+    end
+
+    option nil, :runner_options, _('options to pass through to the actual test-runner'), argument: :required
+
+    run do |opts, _args, _cmd|
+      require 'pdk/tests/unit'
+
+      report = nil
+
+      if opts[:list]
+        puts _('List of all available unit tests: (TODO)')
+      end
+
+      if opts[:tests]
+        tests = opts.fetch(:tests)
+      end
+
+      # Note: Reporting may be delegated to the validation tool itself.
+      if opts[:'report-file']
+        format = opts.fetch(:'report-format', PDK::Report.default_format)
+        report = Report.new(opts.fetch(:'report-file'), format)
+      end
+
+      PDK::Test::Unit.invoke(tests, report)
+    end
+  end
+end

data/lib/pdk/cli/util/option_normalizer.rb

@@ -2,41 +2,67 @@ module PDK
   module CLI
     module Util
       class OptionNormalizer
-        def self.comma_separated_list_to_array(list, options = {})
-          raise _("Error: expected comma separated list") unless OptionValidator.is_comma_separated_list?(list)
+        def self.comma_separated_list_to_array(list, _options = {})
+          raise _('Error: expected comma separated list') unless OptionValidator.comma_separated_list?(list)
           list.split(',').compact
         end
 
-        # Parse one or more format:target pairs.
-        # @return [Array<Report>] An array of one or more Reports.
-        def self.report_formats(formats, options = {})
-          reports = []
-          formats.each do |f|
-            if f.include?(':')
-              format, target = f.split(':')
-            else
-              format, target = f, PDK::Report.default_target
+        # Parse one or more format:target pairs into report format
+        # specifications.
+        #
+        # Each specification is a Hash with two values:
+        #   :method => The name of the method to call on the PDK::Report object
+        #              to render the report.
+        #   :target => The target to write the report to. This can be either an
+        #              IO object that implements #write, or a String filename
+        #              that will be opened for writing.
+        #
+        # If the target given is "stdout" or "stderr", this will convert those
+        # strings into the appropriate IO object.
+        #
+        # @return [Array<Hash{Symbol=>Object}>] An array of one or more report
+        #   format specifications
+        def self.report_formats(formats)
+          formats.map do |f|
+            format, target = f.split(':', 2)
+
+            begin
+              OptionValidator.enum(format, PDK::Report.formats)
+            rescue
+              raise PDK::CLI::FatalError, _("'%{name}' is not a valid report format (%{valid})") % {
+                name:  format,
+                valid: PDK::Report.formats.join(', '),
+              }
             end
 
-            reports << Report.new(target, format)
-          end
+            case target
+            when 'stdout'
+              target = $stdout
+            when 'stderr'
+              target = $stderr
+            end
 
-          reports
+            { method: "to_#{format}".to_sym, target: target }
+          end
         end
 
         def self.parameter_specification(value)
           param_name, param_type = value.split(':', 2)
           param_type = 'String' if param_type.nil?
 
-          unless PDK::CLI::Util::OptionValidator.is_valid_param_name?(param_name)
-            raise PDK::CLI::FatalError, _("'%{name}' is not a valid parameter name") % {name: param_name}
+          unless PDK::CLI::Util::OptionValidator.valid_param_name?(param_name)
+            raise PDK::CLI::FatalError, _("'%{name}' is not a valid parameter name") % {
+              name: param_name,
+            }
           end
 
-          unless PDK::CLI::Util::OptionValidator.is_valid_data_type?(param_type)
-            raise PDK::CLI::FatalError, _("'%{type}' is not a valid data type") % {type: param_type}
+          unless PDK::CLI::Util::OptionValidator.valid_data_type?(param_type)
+            raise PDK::CLI::FatalError, _("'%{type}' is not a valid data type") % {
+              type: param_type,
+            }
           end
 
-          {name: param_name, type: param_type}
+          { name: param_name, type: param_type }
         end
       end
     end

data/lib/pdk/cli/util/option_validator.rb

@@ -2,16 +2,16 @@ module PDK
   module CLI
     module Util
       class OptionValidator
-        def self.is_comma_separated_list?(list, options = {})
-          list =~ /^[\w\-]+(?:,[\w\-]+)+$/ ? true : false
+        def self.comma_separated_list?(list, _options = {})
+          (list =~ %r{^[\w\-]+(?:,[\w\-]+)+$}) ? true : false
         end
 
-        def self.enum(val, valid_entries, options = {})
+        def self.enum(val, valid_entries, _options = {})
           vals = val.is_a?(Array) ? val : [val]
-          invalid_entries = vals.find_all { |e| !valid_entries.include?(e) }
+          invalid_entries = vals.reject { |e| valid_entries.include?(e) }
 
           unless invalid_entries.empty?
-            raise _("Error: the following values are invalid: %{invalid_entries}") % {invalid_entries: invalid_entries}
+            raise _('Error: the following values are invalid: %{invalid_entries}') % { invalid_entries: invalid_entries }
           end
 
           val
@@ -19,31 +19,31 @@ module PDK
 
         # Validate the module name against the regular expression in the
         # documentation: https://docs.puppet.com/puppet/4.10/modules_fundamentals.html#allowed-module-names
-        def self.is_valid_module_name?(string)
-          !(string =~ /\A[a-z][a-z0-9_]*\Z/).nil?
+        def self.valid_module_name?(string)
+          !(string =~ %r{\A[a-z][a-z0-9_]*\Z}).nil?
         end
 
         # Validate a Puppet namespace against the regular expression in the
         # documentation: https://docs.puppet.com/puppet/4.10/lang_reserved.html#classes-and-defined-resource-types
-        def self.is_valid_namespace?(string)
+        def self.valid_namespace?(string)
           return false if (string || '').split('::').last == 'init'
 
-          !(string =~ /\A([a-z][a-z0-9_]*)(::[a-z][a-z0-9_]*)*\Z/).nil?
+          !(string =~ %r{\A([a-z][a-z0-9_]*)(::[a-z][a-z0-9_]*)*\Z}).nil?
         end
 
-        singleton_class.send(:alias_method, :is_valid_class_name?, :is_valid_namespace?)
-        singleton_class.send(:alias_method, :is_valid_defined_type_name?, :is_valid_namespace?)
+        singleton_class.send(:alias_method, :valid_class_name?, :valid_namespace?)
+        singleton_class.send(:alias_method, :valid_defined_type_name?, :valid_namespace?)
 
         # Validate that a class/defined type parameter matches the regular
         # expression in the documentation: https://docs.puppet.com/puppet/4.10/lang_reserved.html#parameters
         # The parameter should also not be a reserved word or overload
         # a metaparameter.
-        def self.is_valid_param_name?(string)
-          reserved_words = %w{trusted facts server_facts title name}.freeze
-          metaparams = %w{alias audit before loglevel noop notify require schedule stage subscribe tag}.freeze
+        def self.valid_param_name?(string)
+          reserved_words = %w[trusted facts server_facts title name].freeze
+          metaparams = %w[alias audit before loglevel noop notify require schedule stage subscribe tag].freeze
           return false if reserved_words.include?(string) || metaparams.include?(string)
 
-          !(string =~ /\A[a-z][a-zA-Z0-9_]*\Z/).nil?
+          !(string =~ %r{\A[a-z][a-zA-Z0-9_]*\Z}).nil?
         end
 
         # Naive validation of a data type declaration. Extracts all the bare
@@ -53,17 +53,21 @@ module PDK
         #   but that shouldn't be a problem for the current feature set. This
         #   should be replaced eventually by something better (or just call
         #   Puppet::Pops::Types::TypesParser)
-        def self.is_valid_data_type?(string)
-          valid_types = %w{
+        def self.valid_data_type?(string)
+          valid_types = %w[
             String Integer Float Numeric Boolean Array Hash Regexp Undef
             Default Class Resource Scalar Collection Variant Data Pattern Enum
             Tuple Struct Optional Catalogentry Type Any Callable NotUndef
-          }.freeze
+          ].freeze
 
-          string.scan(/\b(([a-zA-Z]+)(,|\[|\]|\Z))/) do |result|
+          string.scan(%r{\b(([a-zA-Z0-9_]+)(,|\[|\]|\Z))}) do |result|
             type = result[1]
 
-            return false unless valid_types.include?(type)
+            return false unless string =~ %r{\A[A-Z]}
+
+            unless valid_types.include?(type)
+              PDK.logger.warn(_("Non-standard data type '%{type}', make sure the type is available in your code, or dependencies") % { type: type })
+            end
           end
 
           true