polytrix 0.1.2 → 0.1.3

data/lib/polytrix/command.rb

@@ -2,13 +2,10 @@ require 'thread'
 
 module Polytrix
   module Command
-    class Base
+    class Base # rubocop:disable ClassLength
       include Polytrix::DefaultLogger
       include Polytrix::Logging
-      include Polytrix::Core::FileSystemHelper
-
-      # Need standard executor...
-      SUPPORTED_EXTENSIONS = %w(py rb js)
+      include Polytrix::Util::FileSystem
 
       # Contstructs a new Command object.
       #
@@ -28,9 +25,9 @@ module Polytrix
         @action = options.fetch(:action, nil)
         @help = options.fetch(:help, -> { 'No help provided' })
         @manifest_file = options.fetch('manifest', nil)
-        @test_dir = options.fetch('test_dir', nil)
         @loader = options.fetch(:loader, nil)
         @shell = options.fetch(:shell)
+        @queue = Queue.new
       end
 
       private
@@ -47,10 +44,6 @@ module Polytrix
       # @api private
       attr_reader :help
 
-      # @return [Config] a Config object
-      # @api private
-      attr_reader :test_dir
-
       # @return [Thor::Shell] a Thor shell object
       # @api private
       attr_reader :shell
@@ -60,50 +53,7 @@ module Polytrix
       attr_reader :action
 
       def setup
-        manifest_file = File.expand_path @manifest_file
-        if File.exists? manifest_file
-          logger.debug "Loading manifest file: #{manifest_file}"
-          Polytrix.configuration.manifest = @manifest_file
-        elsif @options.solo
-          solo_setup
-        else
-          fail StandardError, "No manifest found at #{manifest_file} and not using --solo mode"
-        end
-
-        Polytrix.configuration.documentation_dir = options[:target_dir]
-        Polytrix.configuration.documentation_format = options[:format]
-
-        manifest.build_challenges
-
-        test_dir = @test_dir.nil? ? nil : File.expand_path(@test_dir)
-        if test_dir && File.directory?(test_dir)
-          $LOAD_PATH.unshift test_dir
-          Dir["#{test_dir}/**/*.rb"].each do | file_to_require |
-            require relativize(file_to_require, test_dir).to_s.gsub('.rb', '')
-          end
-        end
-      end
-
-      def solo_setup
-        suites = {}
-        solo_basedir = @options.solo
-        solo_glob = @options.fetch('solo_glob', "**/*.{#{SUPPORTED_EXTENSIONS.join(',')}}")
-        Dir[File.join(solo_basedir, solo_glob)].sort.each do | code_sample |
-          code_sample = Pathname.new(code_sample)
-          suite_name = relativize(code_sample.dirname, solo_basedir).to_s
-          suite_name = solo_basedir if suite_name == '.'
-          scenario_name = code_sample.basename(code_sample.extname).to_s
-          suite = suites[suite_name] ||= Polytrix::Manifest::Suite.new(samples: [])
-          suite.samples << scenario_name
-        end
-        @manifest = Polytrix.configuration.manifest = Polytrix::Manifest.new(
-          implementors: {
-            File.basename(solo_basedir) => {
-              basedir: solo_basedir
-            }
-          },
-          suites: suites
-        )
+        Polytrix.setup(options, @manifest_file)
       end
 
       def manifest
@@ -124,44 +74,6 @@ module Polytrix
         exit 1
       end
 
-      # @return [Array<Scenario>] an array of scenarios
-      # @raise [SystemExit] if no scenario are returned
-      # @api private
-      def all_scenarios
-        result = manifest.challenges.values
-
-        if result.empty?
-          die 'No scenarios defined'
-        else
-          result
-        end
-      end
-
-      # Return an array on scenarios whos name matches the regular expression.
-      #
-      # @param regexp [Regexp] a regular expression matching on instance names
-      # @return [Array<Instance>] an array of scenarios
-      # @raise [SystemExit] if no scenarios are returned or the regular
-      #   expression is invalid
-      # @api private
-      def filtered_scenarios(regexp)
-        result = begin
-          manifest.challenges.get(regexp) ||
-            manifest.challenges.get_all(/#{regexp}/)
-        rescue RegexpError => e
-          die "Invalid Ruby regular expression, " \
-            "you may need to single quote the argument. " \
-            "Please try again or consult http://rubular.com/ (#{e.message})"
-        end
-        result = [result] unless result.is_a? Array
-
-        if result.empty?
-          die "No scenarios for regex `#{regexp}', try running `polytrix list'"
-        else
-          result
-        end
-      end
-
       # Return an array on scenarios whos name matches the regular expression,
       # the full instance name, or  the `"all"` literal.
       #
@@ -169,9 +81,14 @@ module Polytrix
       #   `"all"`, or `nil`
       # @return [Array<Instance>] an array of scenarios
       # @api private
-      def parse_subcommand(arg = nil)
-        arg ||= 'all'
-        arg == 'all' ? all_scenarios : filtered_scenarios(arg)
+      def parse_subcommand(regexp = nil)
+        scenarios = Polytrix.filter_scenarios(regexp, options)
+        die "No scenarios for regex `#{regexp}', try running `polytrix list'" if scenarios.empty?
+        scenarios
+      rescue RegexpError => e
+        die 'Invalid Ruby regular expression, ' \
+          'you may need to single quote the argument. ' \
+          "Please try again or consult http://rubular.com/ (#{e.message})"
       end
     end
 
@@ -184,26 +101,42 @@ module Polytrix
       #
       # @param action [String] action to perform
       # @param scenarios [Array<Instance>] an array of scenarios
-      def run_action(action, scenarios, *args)
+      def run_action(_action, scenarios, *_args)
         concurrency = 1
         if options[:concurrency]
           concurrency = options[:concurrency] || scenarios.size
           concurrency = scenarios.size if concurrency > scenarios.size
         end
 
-        queue = Queue.new
-        scenarios.each { |i| queue << i }
-        concurrency.times { queue << nil }
+        scenarios.each { |i| @queue << i }
+        concurrency.times { @queue << nil }
+
+        threads = concurrency.times.map { |i| spawn(i) }
+        threads.map do |t|
+          begin
+            t.join
+          rescue Polytrix::ExecutionError, Polytrix::ChallengeFailure
+            # respawn thread
+            t.kill
+            threads.delete(t)
+            threads.push(spawn)
+          end
+        end while threads.any?(&:alive?)
+      end
+
+      private
 
-        threads = []
-        concurrency.times do
-          threads << Thread.new do
-            while (instance = queue.pop)
+      def spawn(i)
+        Thread.new(i) do |test_env_number|
+          Thread.current[:test_env_number] = test_env_number
+          while (instance = @queue.pop)
+            begin
               instance.public_send(action, *args)
+            rescue Polytrix::ExecutionError, Polytrix::ChallengeFailure => e
+              logger.error(e)
             end
           end
         end
-        threads.map { |i| i.join }
       end
     end
   end

data/lib/polytrix/configuration.rb

@@ -1,27 +1,14 @@
-require 'middleware'
+
+require 'rspec/support'
+require 'rspec/expectations'
 
 module Polytrix
   RESOURCES_DIR = File.expand_path '../../../resources', __FILE__
-  # Autoload pool
-  module Runners
-    module Middleware
-      autoload :FeatureExecutor, 'polytrix/runners/middleware/feature_executor'
-      autoload :SetupEnvVars,    'polytrix/runners/middleware/setup_env_vars'
-      autoload :ChangeDirectory, 'polytrix/runners/middleware/change_directory'
-
-      STANDARD_MIDDLEWARE = ::Middleware::Builder.new do
-        use Polytrix::Runners::Middleware::ChangeDirectory
-        use Polytrix::Runners::Middleware::SetupEnvVars
-        use Polytrix::Runners::Middleware::FeatureExecutor
-      end
-    end
-  end
 
   class Configuration < Polytrix::ManifestSection
     property :dry_run,      default: false
     property :log_root,     default: '.polytrix/logs'
     property :log_level,    default: :info
-    property :middleware,   default: Polytrix::Runners::Middleware::STANDARD_MIDDLEWARE
     property :implementors, default: []
     # coerce_key :implementors, Polytrix::Implementor
     property :suppress_output, default: false
@@ -29,8 +16,13 @@ module Polytrix
     property :template_dir, default: "#{RESOURCES_DIR}"
     property :documentation_dir, default: 'docs/'
     property :documentation_format, default: 'md'
-    # Extra options for rspec
-    property :rspec_options, default: ''
+
+    # TODO: This should probably be configurable, or tied to Thor color options.
+    if RSpec.respond_to?(:configuration)
+      RSpec.configuration.color = true
+    else
+      RSpec::Expectations.configuration.color = true
+    end
 
     def default_logger
       @default_logger ||= Logger.new(stdout: $stdout, level: env_log)
@@ -66,6 +58,10 @@ module Polytrix
 
     attr_writer :default_validator_callback
 
+    def register_spy(spy)
+      Polytrix::Spies.register_spy(spy)
+    end
+
     private
 
     # Determine the default log level from an environment variable, if it is

data/lib/polytrix/{core/hashie.rb → dash.rb}

@@ -1,5 +1,4 @@
 require 'hashie/dash'
-require 'hashie/mash'
 require 'hashie/extensions/coercion'
 
 module Polytrix
@@ -7,8 +6,10 @@ module Polytrix
     include Hashie::Extensions::Coercion
 
     def initialize(hash = {})
-      mash = Hashie::Mash.new(hash)
-      super mash.to_hash(symbolize_keys: true)
+      super Polytrix::Util.symbolized_hash(hash)
     end
   end
+
+  class ManifestSection < Polytrix::Dash
+  end
 end

data/lib/polytrix/documentation/code_segmenter.rb

@@ -5,7 +5,7 @@ module Polytrix
     # This class was extracted from the [Rocco](http://rtomayko.github.com/rocco/) project
     # which was in turn based on the [Docco](http://jashkenas.github.com/docco/).
     class CodeSegmenter # rubocop:disable all
-                        # Cops are disabled because the code is from Rocco
+      # Cops are disabled because the code is from Rocco
       include CommentStyles
 
       DEFAULT_OPTIONS = {
@@ -23,7 +23,7 @@ module Polytrix
       # Parse the raw file source_code into a list of two-tuples. Each tuple has the
       # form `[docs, code]` where both elements are arrays containing the
       # raw lines parsed from the input file, comment characters stripped.
-      def segment(source_code)
+      def segment(source_code) # rubocop:disable all
         sections, docs, code = [], [], []
         lines = source_code.split("\n")
 
@@ -42,20 +42,20 @@ module Polytrix
         in_heredoc = false
         single_line_comment, block_comment_start, block_comment_mid, block_comment_end =
           nil, nil, nil, nil
-        if not @options[:comment_chars][:single].nil?
+        unless @options[:comment_chars][:single].nil?
           single_line_comment = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:single])}\\s?")
         end
-        if not @options[:comment_chars][:multi].nil?
+        unless @options[:comment_chars][:multi].nil?
           block_comment_start = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*$")
           block_comment_end   = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$")
-          block_comment_one_liner = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*(.*?)\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$")
+          block_comment_one_liner = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*(.*?)\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$") # rubocop:disable Metrics/LineLength
           block_comment_start_with = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*(.*?)$")
           block_comment_end_with = Regexp.new("\\s*(.*?)\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$")
           if @options[:comment_chars][:multi][:middle]
             block_comment_mid = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:middle])}\\s?")
           end
         end
-        if not @options[:comment_chars][:heredoc].nil?
+        unless @options[:comment_chars][:heredoc].nil?
           heredoc_start = Regexp.new("#{Regexp.escape(@options[:comment_chars][:heredoc])}(\\S+)$")
         end
         lines.each do |line|
@@ -67,8 +67,8 @@ module Polytrix
               in_comment_block = false
             elsif block_comment_end_with && line.match(block_comment_end_with)
               in_comment_block = false
-              docs << line.match(block_comment_end_with).captures.first.
-                            sub(block_comment_mid || '', '')
+              docs << line.match(block_comment_end_with).captures.first
+                            .sub(block_comment_mid || '', '')
             else
               docs << line.sub(block_comment_mid || '', '')
             end

data/lib/polytrix/documentation/comment_styles.rb

@@ -15,7 +15,7 @@ module Polytrix
         extension.tr! '.', ''
         return extension, COMMENT_STYLES[extension] if COMMENT_STYLES.key? extension
 
-        COMMENT_STYLES.each do | style_name, style |
+        COMMENT_STYLES.each do | _style_name, style |
           return extension, style if style[:extensions].include? extension
         end
 

data/lib/polytrix/documentation/helpers/code_helper.rb

@@ -1,4 +1,5 @@
 require 'polytrix/documentation/code_segmenter'
+require 'rouge'
 
 module Polytrix
   module Documentation
@@ -35,6 +36,14 @@ module Polytrix
           File.read absolute_source_file
         end
 
+        def source?
+          !absolute_source_file.nil?
+        end
+
+        def highlighted_code(formatter = 'terminal256')
+          highlight(source, language: implementor.language, filename: absolute_source_file, formatter: formatter)
+        end
+
         def code_block(source_code, language, opts = { format: :markdown })
           case opts[:format]
           when :rst

data/lib/polytrix/documentation_generator.rb

@@ -1,4 +1,5 @@
-require 'tilt' # seems to be a bug where padrino-helpers should require tilt
+require 'tilt' # padrino-helpers wants you to pre-require tilt/erubis
+require 'erubis'
 require 'padrino-helpers'
 
 module Polytrix
@@ -20,23 +21,19 @@ module Polytrix
     end
 
     def process(challenges)
+      return nil unless File.readable? @template_file
+
       @challenges = challenges
-      if File.readable? @template_file
-        # @template_file ||= find_file @search_path, scenario, ""
-        erb = ERB.new File.read(@template_file)
-        @result = erb.result(binding) || ''
-      end
+      erb = ERB.new File.read(@template_file)
+      @result = erb.result(binding) || ''
     end
 
     def save(target_file)
-      fail 'No results to write, please call process before save' if @result.nil?
-      if @result.empty?
-        # Warn: skip creating empty file
-      else
-        FileUtils.mkdir_p File.dirname(target_file)
-        File.open(target_file, 'wb') do |f|
-          f.write @result
-        end
+      fail 'No results to write, please call process before save' if @result.nil? || @result.empty?
+
+      FileUtils.mkdir_p File.dirname(target_file)
+      File.open(target_file, 'wb') do |f|
+        f.write @result
       end
     end
 

data/lib/polytrix/error.rb

@@ -96,114 +96,121 @@ module Polytrix
   # Exception class capturing what caused an challenge to die.
   class ChallengeFailure < TransientFailure; end
 
+  # Exception class capturing what caused a validation to fail.
+  class ValidationFailure < TransientFailure; end
+
   class ExecutionError < TransientFailure
     attr_accessor :execution_result
   end
 
-  # Yields to a code block in order to consistently emit a useful crash/error
-  # message and exit appropriately. There are two primary failure conditions:
-  # an expected challenge failure, and any other unexpected failures.
-  #
-  # **Note** This method may call `Kernel.exit` so may not return if the
-  # yielded code block raises an exception.
-  #
-  # ## Challenge Failure
-  #
-  # This is an expected failure scenario which could happen if an challenge
-  # couldn't be created, a Chef run didn't successfully converge, a
-  # post-convergence test suite failed, etc. In other words, you can count on
-  # encountering these failures all the time--this is Polytrix's worldview:
-  # crash early and often. In this case a cleanly formatted exception is
-  # written to `STDERR` and the exception message is written to
-  # the common Polytrix file logger.
-  #
-  # ## Unexpected Failure
-  #
-  # All other forms of `Polytrix::Error` exceptions are considered unexpected
-  # or unplanned exceptions, typically from user configuration errors, driver
-  # or provisioner coding issues or bugs, or internal code issues. Given
-  # a stable release of Polytrix and a solid set of drivers and provisioners,
-  # the most likely cause of this is user configuration error originating in
-  # the `.polytrix.yml` setup. For this reason, the exception is written to
-  # `STDERR`, a full formatted exception trace is written to the common
-  # Polytrix file logger, and a message is displayed on `STDERR` to the user
-  # informing them to check the log files and check their configuration with
-  # the `polytrix diagnose` subcommand.
-  #
-  # @raise [SystemExit] if an exception is raised in the yielded block
-  def self.with_friendly_errors
-    yield
-  rescue Polytrix::ChallengeFailure => e
-    Polytrix.mutex.synchronize do
-      handle_challenge_failure(e)
-    end
-    exit 10
-  rescue Polytrix::Error => e
-    Polytrix.mutex.synchronize do
-      handle_error(e)
+  class << self
+    # Yields to a code block in order to consistently emit a useful crash/error
+    # message and exit appropriately. There are two primary failure conditions:
+    # an expected challenge failure, and any other unexpected failures.
+    #
+    # **Note** This method may call `Kernel.exit` so may not return if the
+    # yielded code block raises an exception.
+    #
+    # ## Challenge Failure
+    #
+    # This is an expected failure scenario which could happen if an challenge
+    # couldn't be created, a Chef run didn't successfully converge, a
+    # post-convergence test suite failed, etc. In other words, you can count on
+    # encountering these failures all the time--this is Polytrix's worldview:
+    # crash early and often. In this case a cleanly formatted exception is
+    # written to `STDERR` and the exception message is written to
+    # the common Polytrix file logger.
+    #
+    # ## Unexpected Failure
+    #
+    # All other forms of `Polytrix::Error` exceptions are considered unexpected
+    # or unplanned exceptions, typically from user configuration errors, driver
+    # or provisioner coding issues or bugs, or internal code issues. Given
+    # a stable release of Polytrix and a solid set of drivers and provisioners,
+    # the most likely cause of this is user configuration error originating in
+    # the `.polytrix.yml` setup. For this reason, the exception is written to
+    # `STDERR`, a full formatted exception trace is written to the common
+    # Polytrix file logger, and a message is displayed on `STDERR` to the user
+    # informing them to check the log files and check their configuration with
+    # the `polytrix diagnose` subcommand.
+    #
+    # @raise [SystemExit] if an exception is raised in the yielded block
+    def with_friendly_errors
+      yield
+    rescue Polytrix::ChallengeFailure => e
+      Polytrix.mutex.synchronize do
+        handle_challenge_failure(e)
+      end
+      exit 10
+    rescue Polytrix::Error => e
+      Polytrix.mutex.synchronize do
+        handle_error(e)
+      end
+      exit 20
     end
-    exit 20
-  end
 
-  private
-
-  # Writes an array of lines to the common Polytrix logger's file device at the
-  # given severity level. If the Polytrix logger is set to debug severity, then
-  # the array of lines will also be written to the console output.
-  #
-  # @param level [Symbol,String] the desired log level
-  # @param lines [Array<String>] an array of strings to log
-  # @api private
-  def self.file_log(level, lines)
-    Array(lines).each do |line|
-      if Polytrix.logger.debug?
-        Polytrix.logger.debug(line)
-      else
-        Polytrix.logger.logdev && Polytrix.logger.logdev.public_send(level, line)
-      end
+    # Handles an challenge failure exception.
+    #
+    # @param e [StandardError] an exception to handle
+    # @see Polytrix.with_friendly_errors
+    # @api private
+    def handle_challenge_failure(e)
+      stderr_log(e.message.split(/\s{2,}/))
+      stderr_log(Error.formatted_exception(e.original))
+      file_log(:error, e.message.split(/\s{2,}/).first)
+      debug_log(Error.formatted_trace(e))
     end
-  end
 
-  # Writes an array of lines to the `STDERR` device.
-  #
-  # @param lines [Array<String>] an array of strings to log
-  # @api private
-  def self.stderr_log(lines)
-    Array(lines).each do |line|
-      $stderr.puts(Color.colorize(">>>>>> #{line}", :red))
+    alias_method :handle_validation_failure, :handle_challenge_failure
+
+    # Handles an unexpected failure exception.
+    #
+    # @param e [StandardError] an exception to handle
+    # @see Polytrix.with_friendly_errors
+    # @api private
+    def handle_error(e)
+      stderr_log(Error.formatted_exception(e))
+      stderr_log('Please see .polytrix/logs/polytrix.log for more details')
+      # stderr_log("Also try running `polytrix diagnose --all` for configuration\n")
+      file_log(:error, Error.formatted_trace(e))
     end
-  end
 
-  # Writes an array of lines to the common Polytrix debugger with debug
-  # severity.
-  #
-  # @param lines [Array<String>] an array of strings to log
-  # @api private
-  def self.debug_log(lines)
-    Array(lines).each { |line| Polytrix.logger.debug(line) }
-  end
+    private
 
-  # Handles an challenge failure exception.
-  #
-  # @param e [StandardError] an exception to handle
-  # @see Polytrix.with_friendly_errors
-  # @api private
-  def self.handle_challenge_failure(e)
-    stderr_log(e.message.split(/\s{2,}/))
-    stderr_log(Error.formatted_exception(e.original))
-    file_log(:error, e.message.split(/\s{2,}/).first)
-    debug_log(Error.formatted_trace(e))
-  end
+    # Writes an array of lines to the common Polytrix logger's file device at the
+    # given severity level. If the Polytrix logger is set to debug severity, then
+    # the array of lines will also be written to the console output.
+    #
+    # @param level [Symbol,String] the desired log level
+    # @param lines [Array<String>] an array of strings to log
+    # @api private
+    def file_log(level, lines)
+      Array(lines).each do |line|
+        if Polytrix.logger.debug?
+          Polytrix.logger.debug(line)
+        else
+          Polytrix.logger.logdev && Polytrix.logger.logdev.public_send(level, line)
+        end
+      end
+    end
 
-  # Handles an unexpected failure exception.
-  #
-  # @param e [StandardError] an exception to handle
-  # @see Polytrix.with_friendly_errors
-  # @api private
-  def self.handle_error(e)
-    stderr_log(Error.formatted_exception(e))
-    stderr_log('Please see .polytrix/logs/polytrix.log for more details')
-    # stderr_log("Also try running `polytrix diagnose --all` for configuration\n")
-    file_log(:error, Error.formatted_trace(e))
+    # Writes an array of lines to the `STDERR` device.
+    #
+    # @param lines [Array<String>] an array of strings to log
+    # @api private
+    def stderr_log(lines)
+      Array(lines).each do |line|
+        $stderr.puts(Color.colorize(">>>>>> #{line}", :red))
+      end
+    end
+
+    # Writes an array of lines to the common Polytrix debugger with debug
+    # severity.
+    #
+    # @param lines [Array<String>] an array of strings to log
+    # @api private
+    def debug_log(lines)
+      Array(lines).each { |line| Polytrix.logger.debug(line) }
+    end
   end
 end

data/lib/polytrix/executor.rb

@@ -0,0 +1,33 @@
+module Polytrix
+  module Executors
+    autoload :BuffShellOutExecutor, 'polytrix/executors/buff_shellout_executor'
+    autoload :MixlibShellOutExecutor, 'polytrix/executors/mixlib_shellout_executor'
+
+    class ExecutionResult < Polytrix::Dash
+      property :exitstatus, require: true
+      property :stdout, required: true
+      property :stderr, required: true
+      coerce_value String, ->(v) { v.force_encoding('utf-8') }
+    end
+  end
+
+  module Executor
+    attr_writer :executor
+    attr_accessor :env
+
+    def executor
+      @executor ||= if RUBY_PLATFORM == 'java'
+                      # TODO: Display warning that JRuby support is experimental
+                      # (because executor may not be equivalent)
+                      Polytrix::Executors::BuffShellOutExecutor.new
+                    else
+                      Polytrix::Executors::MixlibShellOutExecutor.new
+                    end
+    end
+
+    def execute(command, opts = {})
+      opts[:env] = env unless env.nil?
+      executor.execute(command, opts)
+    end
+  end
+end