pdk 0.0.1 → 0.1.0

data/exe/pdk

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'pdk/cli'
+
+PDK::CLI.run(ARGV.dup)

data/lib/pdk.rb

@@ -0,0 +1,8 @@
+require 'pdk/version'
+require 'pdk/logger'
+require 'pdk/i18n'
+require 'pdk/generate'
+require 'pdk/validate'
+require 'pdk/report'
+
+module PDK; end

data/lib/pdk/cli.rb

@@ -0,0 +1,80 @@
+require 'cri'
+
+require 'pdk/cli/errors'
+require 'pdk/cli/util/option_validator'
+require 'pdk/cli/util/option_normalizer'
+require 'pdk/logger'
+require 'pdk/report'
+
+require 'pdk/cli/new'
+require 'pdk/cli/validate'
+require 'pdk/cli/test'
+
+module PDK
+  module CLI
+    def self.base_command
+      @base ||= Cri::Command.new.tap do |cmd|
+        cmd.modify do
+          name 'pdk'
+          usage _("pdk command [options]")
+          summary _("Puppet Development Kit")
+          description _("The shortest path to better modules.")
+
+          flag :h, :help, _("show help for this command") do |_, c|
+            puts c.help
+            exit 0
+          end
+
+          format_desc = _(
+            "Specify desired output format. Valid formats are '%{available_formats}'. " +
+            "You may also specify a file to which the formatted output will be directed, " +
+            "for example: '--format=junit:report.xml'. This option may be specified " +
+            "multiple times as long as each option specifies a distinct target file."
+          ) % {available_formats: PDK::Report.formats.join("', '")}
+
+          option :f, :format, format_desc, { argument: :required, multiple: true } do |values|
+            values.compact.each do |v|
+              if v.include?(':')
+                format = v.split(':', 2).first
+
+                PDK::CLI::Util::OptionValidator.enum(format, PDK::Report.formats)
+              else
+                PDK::CLI::Util::OptionValidator.enum(v, PDK::Report.formats)
+              end
+            end
+          end
+
+          flag :d, :debug, _("Enable debug output.") do |_, _|
+            PDK.logger.enable_debug_output
+          end
+        end
+
+        cmd.add_command(Cri::Command.new_basic_help)
+
+        cmd.add_command(PDK::CLI::New.command)
+        cmd.add_command(PDK::CLI::Validate.command)
+        cmd.add_command(PDK::CLI::Test.command)
+      end
+    end
+
+    def self.run(args)
+      base_command.run(args)
+    rescue PDK::CLI::FatalError => e
+      PDK.logger.fatal(e.message) if e.message
+
+      # If FatalError was raised as the result of another exception, send the
+      # details of that exception to the debug log. If there was no cause
+      # (FatalError raised on its own outside a rescue block), send the details
+      # of the FatalError exception to the debug log.
+      cause = e.cause
+      if cause.nil?
+        e.backtrace.each { |line| PDK.logger.debug(line) }
+      else
+        PDK.logger.debug("#{cause.class}: #{cause.message}")
+        cause.backtrace.each { |line| PDK.logger.debug(line) }
+      end
+
+      exit e.exit_code
+    end
+  end
+end

data/lib/pdk/cli/errors.rb

@@ -0,0 +1,12 @@
+module PDK
+  module CLI
+    class FatalError < StandardError
+      attr_reader :exit_code
+
+      def initialize(msg = _("An unexpected error has occurred, try running the command again with --debug"), exit_code=1)
+        @exit_code = exit_code
+        super(msg)
+      end
+    end
+  end
+end

data/lib/pdk/cli/exec.rb

@@ -0,0 +1,51 @@
+require 'childprocess'
+require 'tempfile'
+
+module PDK
+  module CLI
+    module Exec
+      # TODO: decide how to handle multiple output targets when underlying tool doesn't support that
+      # TODO: decide what this method should return
+      # TODO: decide how/when to connect stdin to child process for things like pry
+      def self.execute(*cmd)
+        process = ChildProcess.build(*cmd)
+
+        process.io.stdout = Tempfile.new('stdout')
+        process.io.stderr = Tempfile.new('stderr')
+
+        begin
+          # start the process
+          process.start
+
+          # wait indefinitely for process to exit...
+          process.wait
+
+          stdout = process.io.stdout.open.read
+          stderr = process.io.stderr.open.read
+        ensure
+          process.io.stdout.close
+          process.io.stderr.close
+        end
+
+        {
+          :exit_code => process.exit_code,
+          :stdout => stdout,
+          :stderr => stderr
+        }
+      end
+
+      def self.pdk_basedir
+        @pdk_basedir ||= Gem.win_platform? ? 'C:/Program Files/Puppet Labs/DevelopmentKit' : '/opt/puppetlabs/sdk'
+      end
+
+      def self.git_bindir
+        @git_dir ||= File.join(pdk_basedir, 'private', 'git', 'bin')
+      end
+
+      def self.git(*args)
+        git_path = ENV['PDK_USE_SYSTEM_BINARIES'].nil? ? File.join(git_bindir, 'git') : 'git'
+        execute(git_path, *args)
+      end
+    end
+  end
+end

data/lib/pdk/cli/input.rb

@@ -0,0 +1,28 @@
+module PDK
+  module CLI
+    module Input
+      # Query the user for a value via STDIN.
+      #
+      # @param message [String] The message to be displayed to the user before
+      # accepting input.
+      # @param default [String] The default value to be used if the user
+      # provides a blank value.
+      #
+      # @return [String] The value provided by the user (or the supplied
+      # default value).
+      def self.get(message, default=nil)
+        print message
+        if default.nil?
+          print " [(none)]"
+        else
+          print " [#{default}]"
+        end
+
+        print "\n--> "
+        input = (STDIN.gets || '').chomp.strip
+        input = default if input == ''
+        input
+      end
+    end
+  end
+end

data/lib/pdk/cli/new.rb

@@ -0,0 +1,30 @@
+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
+  end
+end

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

@@ -0,0 +1,45 @@
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'cri'
+require 'pdk/cli/util/option_validator'
+
+require 'pdk/generators/module'
+
+module PDK
+  module CLI
+    module New
+      class Module
+        include PDK::CLI::Util
+
+        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, '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, '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, 'vcs', _("Specifies the version control driver. Valid values: 'git', 'none'. Default: 'git'."), argument: :required
+
+            flag nil, 'skip-interview', _("When specified, skips interactive querying of metadata.")
+
+            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
+
+              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
+
+              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
+    end
+  end
+end

data/lib/pdk/cli/test.rb

@@ -0,0 +1,23 @@
+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
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'cri'
+require 'pdk/cli/util/option_validator'
+require 'pdk/report'
+
+require 'pdk/tests/unit'
+
+module PDK
+  module CLI
+    module Test
+      class Unit
+        include PDK::CLI::Util
+
+        def self.command
+          @unit ||= Cri::Command.define 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|
+              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
+
+              puts _("Running unit tests: %{tests}") % {tests: tests}
+              PDK::Test::Unit.invoke(tests, report)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+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)
+          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
+            end
+
+            reports << Report.new(target, format)
+          end
+
+          reports
+        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}
+          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}
+          end
+
+          {name: param_name, type: param_type}
+        end
+      end
+    end
+  end
+end