polytrix 0.1.0.pre → 0.1.0

data/lib/polytrix/logger.rb

@@ -1,17 +1,374 @@
+require 'fileutils'
 require 'logger'
 
 module Polytrix
-  module ClassMethods
-    def logger
-      @logger ||= Polytrix.configuration.logger
+  class Logger
+    include ::Logger::Severity
+
+    # @return [IO] the log device
+    attr_reader :logdev
+
+    # Constructs a new logger.
+    #
+    # @param options [Hash] configuration for a new logger
+    # @option options [Symbol] :color color to use when when outputting
+    #   messages
+    # @option options [Integer] :level the logging severity threshold
+    #   (default: `Polytrix::DEFAULT_LOG_LEVEL`)
+    # @option options [String,IO] :logdev filepath String or IO object to be
+    #   used for logging (default: `nil`)
+    # @option options [String] :progname program name to include in log
+    #   messages (default: `"Polytrix"`)
+    # @option options [IO] :stdout a standard out IO object to use
+    #   (default: `$stdout`)
+    def initialize(options = {})
+      color = options[:color]
+
+      @loggers = []
+      @loggers << @logdev = logdev_logger(options[:logdev]) if options[:logdev]
+      @loggers << stdout_logger(options[:stdout], color) if options[:stdout]
+      @loggers << stdout_logger($stdout, color) if @loggers.empty?
+
+      self.progname = options[:progname] || 'Polytrix'
+      self.level = options[:level] || default_log_level
     end
-  end
 
-  module Logger
-    include ClassMethods
+    def self.new_logger(implementor) # (test, implementor, index)
+      name = implementor.name # instance_name(test, implementor)
+      index = Polytrix.implementors.index(implementor) || 0
+      Logger.new(
+        stdout: STDOUT,
+        color: Color::COLORS[index % Color::COLORS.size].to_sym,
+        logdev: File.join(Polytrix.configuration.log_root, "#{name}.log"),
+        level: Polytrix::Util.to_logger_level(Polytrix.configuration.log_level),
+        progname: name
+      )
+    end
+
+    class << self
+      private
+
+      # @api private
+      # @!macro delegate_to_first_logger
+      #   @method $1()
+      def delegate_to_first_logger(meth)
+        define_method(meth) { |*args| @loggers.first.public_send(meth, *args) }
+      end
+
+      # @api private
+      # @!macro delegate_to_all_loggers
+      #   @method $1()
+      def delegate_to_all_loggers(meth)
+        define_method(meth) do |*args|
+          result = nil
+          @loggers.each { |l| result = l.public_send(meth, *args) }
+          result
+        end
+      end
+    end
+
+    # @return [Integer] the logging severity threshold
+    # @see http://is.gd/Okuy5p
+    delegate_to_first_logger :level
+
+    # Sets the logging severity threshold.
+    #
+    # @param level [Integer] the logging severity threshold
+    # @see http://is.gd/H1VBFH
+    delegate_to_all_loggers :level=
+
+    # @return [String] program name to include in log messages
+    # @see http://is.gd/5uHGK0
+    delegate_to_first_logger :progname
+
+    # Sets the program name to include in log messages.
+    #
+    # @param progname [String] the program name to include in log messages
+    # @see http://is.gd/f2U5Xj
+    delegate_to_all_loggers :progname=
+
+    # @return [String] the date format being used
+    # @see http://is.gd/btmFWJ
+    delegate_to_first_logger :datetime_format
+
+    # Sets the date format being used.
+    #
+    # @param format [String] the date format
+    # @see http://is.gd/M36ml8
+    delegate_to_all_loggers :datetime_format=
+
+    # Log a message if the given severity is high enough.
+    #
+    # @see http://is.gd/5opBW0
+    delegate_to_all_loggers :add
+
+    # Dump one or more messages to info.
+    #
+    # @param message [#to_s] the message to log
+    # @see http://is.gd/BCp5KV
+    delegate_to_all_loggers :<<
+
+    # Log a message with severity of banner (high level).
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/pYUCYU
+    delegate_to_all_loggers :banner
+
+    # Log a message with severity of debug.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/Re97Zp
+    delegate_to_all_loggers :debug
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of debug messages
+    # @see http://is.gd/Iq08xB
+    delegate_to_first_logger :debug?
+
+    # Log a message with severity of info.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/pYUCYU
+    delegate_to_all_loggers :info
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of info messages
+    # @see http://is.gd/lBtJkT
+    delegate_to_first_logger :info?
+
+    # Log a message with severity of error.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/mLwYMl
+    delegate_to_all_loggers :error
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of error messages
+    # @see http://is.gd/QY19JL
+    delegate_to_first_logger :error?
+
+    # Log a message with severity of warn.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/PX9AIS
+    delegate_to_all_loggers :warn
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of warn messages
+    # @see http://is.gd/Gdr4lD
+    delegate_to_first_logger :warn?
+
+    # Log a message with severity of fatal.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/5ElFPK
+    delegate_to_all_loggers :fatal
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of fatal messages
+    # @see http://is.gd/7PgwRl
+    delegate_to_first_logger :fatal?
+
+    # Log a message with severity of unknown.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/Y4hqpf
+    delegate_to_all_loggers :unknown
+
+    # Close the logging devices.
+    #
+    # @see http://is.gd/b13cVn
+    delegate_to_all_loggers :close
+
+    private
+
+    # @return [Integer] the default logger level
+    # @api private
+    def default_log_level
+      Polytrix::Util.to_logger_level(Polytrix.configuration.log_level)
+    end
+
+    # Construct a new standard out logger.
+    #
+    # @param stdout [IO] the IO object that represents stdout (or similar)
+    # @param color [Symbol] color to use when outputing messages
+    # @return [StdoutLogger] a new logger
+    # @api private
+    def stdout_logger(stdout, color)
+      logger = StdoutLogger.new(stdout)
+      if Polytrix.tty?
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          Color.colorize("#{msg}", color).concat("\n")
+        end
+      else
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          msg.concat("\n")
+        end
+      end
+      logger
+    end
+
+    # Construct a new logdev logger.
+    #
+    # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @return [LogdevLogger] a new logger
+    # @api private
+    def logdev_logger(filepath_or_logdev)
+      LogdevLogger.new(resolve_logdev(filepath_or_logdev))
+    end
+
+    # Return an IO object from a filepath String or the IO object itself.
+    #
+    # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @return [IO] an IO object
+    # @api private
+    def resolve_logdev(filepath_or_logdev)
+      if filepath_or_logdev.is_a? String
+        FileUtils.mkdir_p(File.dirname(filepath_or_logdev))
+        file = File.open(File.expand_path(filepath_or_logdev), 'ab')
+        file.sync = true
+        file
+      else
+        filepath_or_logdev
+      end
+    end
+
+    # Internal class which adds a #banner method call that displays the
+    # message with a callout arrow.
+    class LogdevLogger < ::Logger
+      alias_method :super_info, :info
+
+      # Dump one or more messages to info.
+      #
+      # @param msg [String] a message
+      def <<(msg)
+        @buffer ||= ''
+        lines, _, remainder = msg.rpartition("\n")
+        if lines.empty?
+          @buffer << remainder
+        else
+          lines.insert(0, @buffer)
+          lines.split("\n").each { |l| format_line(l.chomp) }
+          @buffer = ''
+        end
+      end
+
+      # Log a banner message.
+      #
+      # @param msg [String] a message
+      def banner(msg = nil, &block)
+        super_info("-----> #{msg}", &block)
+      end
+
+      private
+
+      # Reformat a line if it already contains log formatting.
+      #
+      # @param line [String] a message line
+      # @api private
+      def format_line(line)
+        case line
+        when /^-----> / then banner(line.gsub(/^[ >-]{6} /, ''))
+        when /^>>>>>> / then error(line.gsub(/^[ >-]{6} /, ''))
+        when /^       / then info(line.gsub(/^[ >-]{6} /, ''))
+        else info(line)
+        end
+      end
+    end
+
+    # Internal class which reformats logging methods for display as console
+    # output.
+    class StdoutLogger < LogdevLogger
+      # Log a debug message
+      #
+      # @param msg [String] a message
+      def debug(msg = nil, &block)
+        super("D      #{msg}", &block)
+      end
+
+      # Log an info message
+      #
+      # @param msg [String] a message
+      def info(msg = nil, &block)
+        super("       #{msg}", &block)
+      end
+
+      # Log a warn message
+      #
+      # @param msg [String] a message
+      def warn(msg = nil, &block)
+        super("$$$$$$ #{msg}", &block)
+      end
+
+      # Log an error message
+      #
+      # @param msg [String] a message
+      def error(msg = nil, &block)
+        super(">>>>>> #{msg}", &block)
+      end
+
+      # Log a fatal message
+      #
+      # @param msg [String] a message
+      def fatal(msg = nil, &block)
+        super("!!!!!! #{msg}", &block)
+      end
 
-    def self.included(base)
-      base.extend(ClassMethods)
+      # Log an unknown message
+      #
+      # @param msg [String] a message
+      def unknown(msg = nil, &block)
+        super("?????? #{msg}", &block)
+      end
     end
   end
 end

data/lib/polytrix/logging.rb

@@ -0,0 +1,34 @@
+module Polytrix
+  module DefaultLogger
+    module ClassMethods
+      def logger
+        @logger ||= Polytrix.configuration.default_logger
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    include ClassMethods
+  end
+
+  module Logging
+    class << self
+      private
+
+      def logger_method(meth)
+        define_method(meth) do |*args|
+          logger.public_send(meth, *args)
+        end
+      end
+    end
+
+    logger_method :banner
+    logger_method :debug
+    logger_method :info
+    logger_method :warn
+    logger_method :error
+    logger_method :fatal
+  end
+end

data/lib/polytrix/manifest.rb

@@ -32,45 +32,59 @@ module Polytrix
   # The *global_env* values will be made available to all tests as environment variables, along with the *env*
   # values for that specific test.
   #
-  class Manifest < Hashie::Dash
-    include Logger
+  class Manifest < Polytrix::ManifestSection
+    include Polytrix::DefaultLogger
+    include Polytrix::Logging
     include Hashie::Extensions::DeepMerge
 
+    def initialize(hash = {})
+      super
+      implementors.each do | name, implementor |
+        implementor.name = name
+      end
+    end
+
     class Environment < Hashie::Mash
-      # Hashie Coercion - automatically treat all values as String
-      def self.coerce(obj)
-        data = obj.reduce({}) do |h, (key, value)|
-          h[key] = value.to_s
-          h
-        end
-        new data
+    end
+
+    class CodeSample < Polytrix::ManifestSection
+      property :name, required: true
+
+      def self.coerce(data)
+        data = { name: data } if data.is_a? String
+        new(data)
       end
     end
 
-    class Suite < Hashie::Dash
-      include Hashie::Extensions::Coercion
+    class Suite < Polytrix::ManifestSection
       property :env, default: {}
-      property :samples, default: []
+      property :samples, required: true
+      coerce_key :samples, Array[CodeSample]
       property :results
     end
 
-    class Suites < Hashie::Mash
-      # Hashie Coercion - automatically treat all values as Suite
-      def self.coerce(obj)
-        data = obj.reduce({}) do |h, (key, value)|
-          h[key] = Polytrix::Manifest::Suite.new(value)
-          h
+    property :implementors, required: true
+    coerce_key :implementors, Hash[String => Polytrix::Implementor]
+    property :global_env
+    coerce_key :global_env, Environment
+    property :suites
+    coerce_key :suites, Hash[String => Suite]
+
+    attr_accessor :challenges
+
+    def build_challenges
+      @challenges ||= Challenges.new
+
+      suites.each do | suite_name, suite |
+        suite.samples.each do | sample |
+          implementors.each_value do | implementor |
+            challenge = implementor.build_challenge suite: suite_name, name: sample.name, vars: suite.env
+            @challenges[challenge.slug] = challenge
+          end
         end
-        new data
       end
     end
 
-    include Hashie::Extensions::Coercion
-    property :global_env
-    coerce_key :global_env, Polytrix::Manifest::Environment
-    property :suites
-    coerce_key :suites, Polytrix::Manifest::Suites
-
     # Parses a YAML file to create a {Manifest} object.
     def self.from_yaml(yaml_file)
       ENV['POLYTRIX_SEED'] ||= $PROCESS_ID.to_s
@@ -82,7 +96,7 @@ module Polytrix
     end
 
     def find_suite(suite_name)
-      _, suite = suites.find { |name, _| name.downcase == suite_name.downcase }
+      _, suite = suites.find { |name, _| name.to_s.downcase == suite_name.to_s.downcase }
       suite
     end
 

data/lib/polytrix/result.rb

@@ -4,6 +4,7 @@ module Polytrix
   class Result < Hashie::Dash
     extend Forwardable
     include Hashie::Extensions::Coercion
+
     property :execution_result # , required: true
     def_delegators :execution_result, :stdout, :stderr, :exitstatus
     property :source_file # , required: true

data/lib/polytrix/rspec.rb

@@ -13,18 +13,20 @@ module Polytrix
       def shared_examples(caller) # rubocop:disable MethodLength
         # FIXME: Long method because it's hard to eval in the right context
         caller.instance_eval do
-          Polytrix.manifest['suites'].each do |suite_name, suite_config|
+          Polytrix.manifest.suites.each do |suite_name, suite_config|
             describe suite_name do
-              samples = suite_config['samples'] || []
+              samples = suite_config.samples || []
               samples.each do |scenario|
-                describe scenario do
+                describe scenario.name do
                   Polytrix.implementors.each do |sdk|
                     it sdk.name, sdk.name.to_sym => true do
                       begin
                         skip "#{sdk.name} is not setup" unless File.directory? sdk.basedir
-                        challenge = sdk.build_challenge suite: suite_name, name: scenario, vars: suite_config['env']
+                        slug = Polytrix::Challenge.slugify(suite_name, scenario.name, sdk.name)
+                        challenge = Polytrix.manifest.challenges[slug]
+                        # sdk.build_challenge suite: suite_name, name: scenario, vars: suite_config.env
                         example.metadata[:polytrix_challenge] = challenge
-                        challenge.run
+                        challenge.exec
                         validators = Polytrix::ValidatorRegistry.validators_for challenge
                         validators.each do |validator|
                           instance_exec challenge, &validator.callback

data/lib/polytrix/runners/buff_shellout_executor.rb

@@ -0,0 +1,19 @@
+require 'buff/shell_out'
+
+module Polytrix
+  module Runners
+    class BuffShellOutExecutor
+      def execute(command, opts)
+        cwd = opts.delete(:cwd) || Dir.pwd
+        execution_result = nil
+        Dir.chdir(cwd) do
+          shell = Buff::ShellOut.shell_out(command)
+          # Buff doesn't have a live_stream like Mixlib
+          puts shell.stdout unless Polytrix.configuration.suppress_output
+          execution_result = ExecutionResult.new exitstatus: shell.exitstatus, stdout: shell.stdout, stderr: shell.stderr
+        end
+        execution_result
+      end
+    end
+  end
+end

data/lib/polytrix/runners/executor.rb

@@ -0,0 +1,32 @@
+require 'hashie/dash'
+require 'thor'
+require 'polytrix/core/manifest_section'
+
+module Polytrix
+  module Runners
+    autoload :BuffShellOutExecutor, 'polytrix/runners/buff_shellout_executor'
+    autoload :MixlibShellOutExecutor, 'polytrix/runners/mixlib_shellout_executor'
+
+    class ExecutionResult < Polytrix::ManifestSection
+      property :exitstatus, require: true
+      property :stdout, required: true
+      property :stderr, required: true
+    end
+
+    module Executor
+      attr_writer :executor
+
+      def executor
+        @executor ||= if RUBY_PLATFORM == 'java'
+                        Polytrix::Runners::BuffShellOutExecutor.new
+                      else
+                        Polytrix::Runners::MixlibShellOutExecutor.new
+                      end
+      end
+
+      def execute(command, opts = {})
+        executor.execute(command, opts)
+      end
+    end
+  end
+end

data/lib/polytrix/runners/mixlib_shellout_executor.rb

@@ -0,0 +1,83 @@
+require 'mixlib/shellout'
+
+module Polytrix
+  module Runners
+    class IOToLog < IO
+      def initialize(logger)
+        @logger = logger
+        @buffer = ''
+      end
+
+      def write(string)
+        (@buffer + string).lines.each do |line|
+          if line.end_with? "\n"
+            @buffer = ''
+            @logger.info(line.rstrip)
+          else
+            @buffer = line
+          end
+        end
+      end
+    end
+
+    class MixlibShellOutExecutor
+      include Polytrix::DefaultLogger
+
+      def log_decorator(io, prefix)
+        # OutputDecorator.new(io, prefix) unless Polytrix.configuration.suppress_output
+        # logger = Logging.logger['polytrix::exec']
+        IOToLog.new(logger)
+      end
+
+      def execute(command, opts)
+        prefix = opts.delete :prefix
+        shell = Mixlib::ShellOut.new(command, opts)
+        shell.live_stream = log_decorator $stdout, prefix
+        shell.run_command
+        execution_result = ExecutionResult.new exitstatus: shell.exitstatus, stdout: shell.stdout, stderr: shell.stderr
+        begin
+          shell.error!
+        rescue Mixlib::ShellOut::ShellCommandFailed => e
+          execution_error = ExecutionError.new(e)
+          execution_error.execution_result = execution_result
+          raise execution_error
+        end
+
+        execution_result
+      end
+
+      class OutputDecorator
+        # Reserve :red, :black, :white
+        COLORS = [:green, :yellow, :blue, :magenta, :cyan]
+
+        def self.next_color
+          @next_color ||= 0
+          @next_color += 1
+          COLORS[@next_color % COLORS.size]
+        end
+
+        def initialize(real_io, prefix = nil)
+          @real_io = real_io
+          # @prefix = set_color(prefix, :cyan)
+          @prefix = "#{prefix}: " if prefix
+          @color = self.class.next_color
+          @thor_shell = Thor::Shell::Color.new
+        end
+
+        def puts(line)
+          line = line.gsub(/^/, @prefix) if @prefix
+          @real_io.puts @thor_shell.set_color(line, @color)
+        end
+
+        def <<(line)
+          line = line.gsub(/^/, @prefix) if @prefix
+          @real_io << @thor_shell.set_color(line, @color)
+        end
+
+        def method_missing(meth, *args, &block)
+          @real_io.send meth, *args, &block
+        end
+      end
+    end
+  end
+end