pdk 0.1.0 → 0.2.0

data/lib/pdk/template_file.rb

@@ -16,7 +16,7 @@ module PDK
     def initialize(template_file, data = {})
       @template_file = template_file
 
-      if data.has_key?(:configs)
+      if data.key?(:configs)
         @configs = data[:configs]
       end
 
@@ -37,13 +37,15 @@ module PDK
     # @api public
     def render
       case File.extname(@template_file)
-      when ".erb"
+      when '.erb'
         render_erb
       else
         render_plain
       end
     end
-  private
+
+    private
+
     # Reads the content of the template file into memory.
     #
     # @return [String] The content of the template file.
@@ -54,10 +56,10 @@ module PDK
     # @api private
     def template_content
       if File.file?(@template_file) && File.readable?(@template_file)
-        File.read(@template_file)
-      else
-        raise ArgumentError, _("'%{template}' is not a readable file") % {:template => @template_file}
+        return File.read(@template_file)
       end
+
+      raise ArgumentError, _("'%{template}' is not a readable file") % { template: @template_file }
     end
 
     # Renders the content of the template file as an ERB template.

data/lib/pdk/tests/unit.rb

@@ -1,18 +1,23 @@
 require 'pdk'
 require 'pdk/cli/exec'
+require 'pdk/util/bundler'
 
 module PDK
   module Test
     class Unit
-      def self.cmd(tests)
+      def self.cmd(_tests)
         # TODO: actually run the tests
-        #cmd = 'rake spec'
-        #cmd += " #{tests}" if tests
+        # cmd = 'rake spec'
+        # cmd += " #{tests}" if tests
         cmd = 'pwd'
         cmd
       end
 
       def self.invoke(tests, report = nil)
+        PDK::Util::Bundler.ensure_bundle!
+
+        puts _('Running unit tests: %{tests}') % { tests: tests }
+
         output = PDK::CLI::Exec.execute(cmd(tests))
         report.write(output) if report
       end

data/lib/pdk/util.rb

@@ -1,8 +1,28 @@
 require 'tmpdir'
 require 'tempfile'
+require 'puppet/util/windows'
 
 module PDK
   module Util
+    # Searches upwards from current working directory for the given target file.
+    #
+    # @param target [String] Name of file to search for.
+    #
+    # @return [String, nil] Fully qualified path to the given target file if found,
+    #   nil if the target file could not be found.
+    def find_upwards(target)
+      previous = nil
+      current  = File.expand_path(Dir.pwd)
+
+      until !File.directory?(current) || current == previous
+        filename = File.join(current, target)
+        return filename if File.file?(filename)
+        previous = current
+        current = File.expand_path('..', current)
+      end
+    end
+    module_function :find_upwards
+
     # Generate a name for a temporary directory.
     #
     # @param base [String] A string to base the name generation off.
@@ -12,5 +32,50 @@ module PDK
       Dir::Tmpname.make_tmpname(File.join(Dir.tmpdir, base), nil)
     end
     module_function :make_tmpdir_name
+
+    # Return an expanded, absolute path
+    #
+    # @param path [String] Existing path that may not be canonical
+    #
+    # @return [String] Canonical path
+    def canonical_path(path)
+      if Gem.win_platform?
+        unless File.exist?(path)
+          raise PDK::CLI::FatalError, _("Cannot resolve a full path to '%{path}' as it does not currently exist") % { path: path }
+        end
+        Puppet::Util::Windows::File.get_long_pathname(path)
+      else
+        File.expand_path(path)
+      end
+    end
+    module_function :canonical_path
+
+    # Returns the fully qualified path to a per-user PDK cachedir.
+    #
+    # @return [String] Fully qualified path to per-user PDK cachedir.
+    def cachedir
+      basedir = if Gem.win_platform?
+                  ENV['LOCALAPPDATA']
+                else
+                  Dir.home
+                end
+
+      File.join(basedir, '.pdk', 'cache')
+    end
+    module_function :cachedir
+
+    # Returns path to the root of the module being worked on.
+    #
+    # @return [String, nil] Fully qualified base path to module, or nil if
+    #   the current working dir does not appear to be within a module.
+    def module_root
+      metadata_path = find_upwards('metadata.json')
+      if metadata_path
+        File.dirname(metadata_path)
+      else
+        nil
+      end
+    end
+    module_function :module_root
   end
 end

data/lib/pdk/util/bundler.rb

@@ -0,0 +1,167 @@
+require 'bundler'
+require 'tty-spinner'
+require 'pdk/util'
+require 'pdk/cli/exec'
+
+module PDK
+  module Util
+    module Bundler
+      class BundleHelper; end
+
+      def self.ensure_bundle!
+        bundle = BundleHelper.new
+
+        if already_bundled?(bundle.gemfile)
+          PDK.logger.debug(_('Bundle has already been installed, skipping run'))
+          return
+        end
+
+        unless bundle.gemfile?
+          PDK.logger.debug(_("No Gemfile found in '%{cwd}', skipping bundler management") % { cwd: Dir.pwd })
+          return
+        end
+
+        unless bundle.locked?
+          unless bundle.lock!
+            raise PDK::CLI::FatalError, _('Unable to resolve Gemfile dependencies.')
+          end
+        end
+
+        unless bundle.installed?
+          unless bundle.install!
+            raise PDK::CLI::FatalError, _('Unable to install missing Gemfile dependencies.')
+          end
+        end
+
+        mark_as_bundled!(bundle.gemfile)
+      end
+
+      def self.already_bundled?(gemfile)
+        !(@bundled ||= {})[gemfile].nil?
+      end
+
+      def self.mark_as_bundled!(gemfile)
+        (@bundled ||= {})[gemfile] = true
+      end
+
+      def self.ensure_binstubs!(*gems)
+        bundle = BundleHelper.new
+
+        unless bundle.binstubs!(gems) # rubocop:disable Style/GuardClause
+          raise PDK::CLI::FatalError, _('Unable to install requested binstubs.')
+        end
+      end
+
+      class BundleHelper
+        def gemfile?
+          !gemfile.nil?
+        end
+
+        def locked?
+          !gemfile_lock.nil?
+        end
+
+        def installed?
+          output_start(_('Checking for missing Gemfile dependencies'))
+
+          result = invoke('check', "--gemfile=#{gemfile}", "--path=#{bundle_cachedir}")
+
+          output_end(:success)
+
+          result[:exit_code].zero?
+        end
+
+        def lock!
+          output_start(_('Resolving Gemfile dependencies'))
+
+          result = invoke('lock')
+
+          if result[:exit_code].zero?
+            output_end(:success)
+          else
+            output_end(:failure)
+            $stderr.puts result[:stdout]
+            $stderr.puts result[:stderr]
+          end
+
+          result[:exit_code].zero?
+        end
+
+        def install!
+          output_start(_('Installing missing Gemfile dependencies'))
+
+          result = invoke('install', "--gemfile=#{gemfile}", "--path=#{bundle_cachedir}")
+
+          if result[:exit_code].zero?
+            output_end(:success)
+          else
+            output_end(:failure)
+            $stderr.puts result[:stdout]
+            $stderr.puts result[:stderr]
+          end
+
+          result[:exit_code].zero?
+        end
+
+        def binstubs!(gems)
+          # FIXME: wrap in progress indicator
+          result = invoke('binstubs', gems.join(' '), '--force')
+
+          unless result[:exit_code].zero?
+            $stderr.puts result[:stdout]
+            $stderr.puts result[:stderr]
+          end
+
+          result[:exit_code].zero?
+        end
+
+        def gemfile
+          @gemfile ||= PDK::Util.find_upwards('Gemfile')
+        end
+
+        private
+
+        def invoke(*args)
+          bundle_bin = PDK::CLI::Exec.bundle_bin
+          command = PDK::CLI::Exec::Command.new(bundle_bin, *args).tap do |c|
+            c.context = :module
+          end
+
+          command.execute!
+        end
+
+        def gemfile_lock
+          @gemfile_lock ||= PDK::Util.find_upwards('Gemfile.lock')
+        end
+
+        def bundle_cachedir
+          @bundle_cachedir ||= File.join(PDK::Util.cachedir, 'bundler')
+        end
+
+        # These two output_* methods are just a way to not try to do the spinner stuff on Windows for now.
+        def output_start(message)
+          if Gem.win_platform?
+            $stderr.print "#{message}... "
+          else
+            @spinner = TTY::Spinner.new("[:spinner] #{message}")
+            @spinner.auto_spin
+          end
+        end
+
+        def output_end(state)
+          if Gem.win_platform?
+            $stderr.print((state == :success) ? _("done.\n") : _("FAILURE!\n"))
+          else
+            if state == :success
+              @spinner.success
+            else
+              @spinner.error
+            end
+
+            remove_instance_variable(:@spinner)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdk/util/version.rb

@@ -0,0 +1,34 @@
+require 'pdk/version'
+require 'pdk/cli/exec'
+
+module PDK
+  module Util
+    module Version
+      def self.version_string
+        "#{PDK::VERSION} #{pdk_ref}".strip.freeze
+      end
+
+      def self.pdk_ref
+        ref = "#{pkg_sha} #{git_ref}".strip
+        ref.empty? ? nil : "(#{ref})"
+      end
+
+      def self.pkg_sha
+        version_file = File.join(File.expand_path('../../..', File.dirname(__FILE__)), 'VERSION')
+
+        if File.exist? version_file
+          ver = File.read(version_file)
+          sha = ver.strip.split('.')[-1] unless ver.nil?
+        end
+
+        sha
+      end
+
+      def self.git_ref
+        ref_result = PDK::CLI::Exec.git('--git-dir', File.join(File.expand_path('../../..', File.dirname(__FILE__)), '.git'), 'describe', '--all', '--long')
+
+        ref_result[:stdout].strip if ref_result[:exit_code].zero?
+      end
+    end
+  end
+end

data/lib/pdk/validate.rb

@@ -1,12 +1,11 @@
 require 'pdk/validators/metadata'
-require 'pdk/validators/puppet_lint'
-require 'pdk/validators/puppet_parser'
-require 'pdk/validators/ruby_lint'
+require 'pdk/validators/puppet_validator'
+require 'pdk/validators/ruby_validator'
 
 module PDK
   module Validate
     def self.validators
-      @validators ||= [Metadata, PuppetLint, PuppetParser, RubyLint].freeze
+      @validators ||= [Metadata, PuppetValidator, RubyValidator].freeze
     end
   end
 end

data/lib/pdk/validators/base_validator.rb

@@ -4,10 +4,66 @@ require 'pdk/cli/exec'
 module PDK
   module Validate
     class BaseValidator
-      def self.invoke(options = {})
-        PDK.logger.info(_("Running %{cmd} with options: %{options}") % {cmd: cmd, options: options})
-        result = PDK::CLI::Exec.execute(cmd, options)
-        result
+      def self.cmd_path
+        File.join(PDK::Util.module_root, 'bin', cmd)
+      end
+
+      def self.parse_targets(options)
+        # If no targets are specified, then we will run validations from the
+        # base module directory.
+        targets = if options[:targets].nil? || options[:targets].empty?
+                    [PDK::Util.module_root]
+                  else
+                    options[:targets]
+                  end
+
+        targets.map { |target|
+          if respond_to?(:pattern)
+            if File.directory?(target)
+              files_glob = Array[pattern].flatten.map { |p| Dir.glob(File.join(target, p)) }
+              files_glob.flatten.empty? ? target : files_glob
+            else
+              target
+            end
+          else
+            target
+          end
+        }.flatten
+      end
+
+      def self.parse_options(_options, targets)
+        targets
+      end
+
+      def self.spinner_text
+        _('Invoking %{cmd}') % { cmd: cmd }
+      end
+
+      def self.invoke(report, options = {})
+        PDK::Util::Bundler.ensure_binstubs!(cmd)
+
+        targets = parse_targets(options)
+        cmd_argv = parse_options(options, targets).unshift(cmd_path)
+        cmd_argv.unshift('ruby') if Gem.win_platform?
+
+        PDK.logger.debug(_('Running %{cmd}') % { cmd: cmd_argv.join(' ') })
+
+        command = PDK::CLI::Exec::Command.new(*cmd_argv).tap do |c|
+          c.context = :module
+          c.add_spinner(spinner_text)
+        end
+
+        result = command.execute!
+
+        begin
+          json_data = JSON.parse(result[:stdout])
+        rescue JSON::ParserError
+          json_data = []
+        end
+
+        parse_output(report, json_data)
+
+        result[:exit_code]
       end
     end
   end

data/lib/pdk/validators/metadata.rb

@@ -1,6 +1,7 @@
 require 'pdk'
 require 'pdk/cli/exec'
 require 'pdk/validators/base_validator'
+require 'pdk/util/bundler'
 
 module PDK
   module Validate
@@ -12,6 +13,34 @@ module PDK
       def self.cmd
         'metadata-json-lint'
       end
+
+      def self.parse_targets(_options)
+        [File.join(PDK::Util.module_root, 'metadata.json')]
+      end
+
+      def self.parse_options(_options, targets)
+        cmd_options = ['--format', 'json']
+
+        cmd_options.concat(targets)
+      end
+
+      def self.parse_output(report, json_data)
+        return if json_data.empty?
+
+        json_data.delete('result')
+        json_data.keys.each do |type|
+          json_data[type].each do |offense|
+            report.add_event(
+              file:     'metadata.json',
+              source:   cmd,
+              message:  offense['msg'],
+              test:     offense['check'],
+              severity: type,
+              state:    :failure,
+            )
+          end
+        end
+      end
     end
   end
 end