polytrix 0.1.2 → 0.1.3

data/lib/polytrix/util.rb

@@ -1,20 +1,7 @@
 # -*- encoding: utf-8 -*-
 #
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2012, 2013, 2014, Fletcher Nichol
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# Much of this code has been adapted from Fletcher Nichol (<fnichol@nichol.ca>)
+# work on test-kitchen.
 
 module Polytrix
   # Stateless utility methods used in different contexts. Essentially a mini
@@ -59,14 +46,12 @@ module Polytrix
     # @return [Object] a converted hash with all keys as symbols
     def self.symbolized_hash(obj)
       if obj.is_a?(Hash)
-        obj.reduce({}) do |h, (k, v)|
+        obj.each_with_object({}) do |(k, v), h|
           h[k.to_sym] = symbolized_hash(v)
-          h
         end
       elsif obj.is_a?(Array)
-        obj.reduce([]) do |a, e|
+        obj.each_with_object([]) do |e, a|
           a << symbolized_hash(e)
-          a
         end
       else
         obj
@@ -82,14 +67,12 @@ module Polytrix
     # @return [Object] a converted hash with all keys as strings
     def self.stringified_hash(obj)
       if obj.is_a?(Hash)
-        obj.reduce({}) do |h, (k, v)|
+        obj.each_with_object({}) do |(k, v), h|
           h[k.to_s] = stringified_hash(v)
-          h
         end
       elsif obj.is_a?(Array)
-        obj.reduce([]) do |a, e|
+        obj.each_with_object([]) do |e, a|
           a << stringified_hash(e)
-          a
         end
       else
         obj
@@ -107,49 +90,161 @@ module Polytrix
       format('(%dm%.2fs)', minutes, seconds)
     end
 
-    # Generates a command (or series of commands) wrapped so that it can be
-    # invoked on a remote instance or locally.
-    #
-    # This method uses the Bourne shell (/bin/sh) to maximize the chance of
-    # cross platform portability on Unixlike systems.
-    #
-    # @param [String] the command
-    # @return [String] a wrapped command string
-    def self.wrap_command(cmd)
-      cmd = 'false' if cmd.nil?
-      cmd = 'true' if cmd.to_s.empty?
-      cmd = cmd.sub(/\n\Z/, '') if cmd =~ /\n\Z/
-
-      "sh -c '\n#{cmd}\n'"
+    module String
+      module ClassMethods
+        def slugify(*labels)
+          labels.map do |label|
+            label.downcase.gsub(/[\.\s-]/, '_')
+          end.join('-')
+        end
+
+        def ansi2html(text)
+          HTML.from_ansi(text)
+        end
+
+        def escape_html(text)
+          HTML.escape_html(text)
+        end
+        alias_method :h, :escape_html
+
+        def highlight(source, opts = {})
+          return nil if source.nil?
+
+          opts[:language] ||= 'ruby'
+          opts[:formatter] ||= 'terminal256'
+          Highlight.new(opts).highlight(source)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      include ClassMethods
     end
 
-    # Modifes the given string to strip leading whitespace on each line, the
-    # amount which is calculated by using the first line of text.
-    #
-    # @example
-    #
-    #   string = <<-STRING
-    #     a
-    #       b
-    #   c
-    #   STRING
-    #   Util.outdent!(string) # => "a\n  b\nc\n"
-    #
-    # @param string [String] the string that will be modified
-    # @return [String] the modified string
-    def self.outdent!(string)
-      string.gsub!(/^ {#{string.index(/[^ ]/)}}/, '')
+    class Highlight
+      def initialize(opts)
+        @lexer = Rouge::Lexer.find(opts[:language]) || Rouge::Lexer.guess_by_filename(opts[:filename])
+        @formatter = opts[:formatter]
+      end
+
+      def highlight(source)
+        Rouge.highlight(source, @lexer, @formatter)
+      end
     end
 
-    # Returns a set of Bourne Shell (AKA /bin/sh) compatible helper
-    # functions. This function is usually called inline in a string that
-    # will be executed remotely on a test instance.
-    #
-    # @return [String] a string representation of useful helper functions
-    def self.shell_helpers
-      IO.read(File.join(
-        File.dirname(__FILE__), %w[.. .. support download_helpers.sh]
-      ))
+    class HTML
+      ANSICODES = {
+        '1' => 'bold',
+        '4' => 'underline',
+        '30' => 'black',
+        '31' => 'red',
+        '32' => 'green',
+        '33' => 'yellow',
+        '34' => 'blue',
+        '35' => 'magenta',
+        '36' => 'cyan',
+        '37' => 'white',
+        '40' => 'bg-black',
+        '41' => 'bg-red',
+        '42' => 'bg-green',
+        '43' => 'bg-yellow',
+        '44' => 'bg-blue',
+        '45' => 'bg-magenta',
+        '46' => 'bg-cyan',
+        '47' => 'bg-white'
+      }
+
+      def self.from_ansi(text)
+        ansi = StringScanner.new(text)
+        html = StringIO.new
+        until ansi.eos?
+          if ansi.scan(/\e\[0?m/)
+            html.print(%(</span>))
+          elsif ansi.scan(/\e\[0?(\d+)m/)
+            # use class instead of style?
+            style = ANSICODES[ansi[1]] || 'text-reset'
+            html.print(%(<span class="#{style}">))
+          else
+            html.print(ansi.scan(/./m))
+          end
+        end
+        html.string
+      end
+
+      # From Rack
+
+      ESCAPE_HTML = {
+        '&' => '&amp;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        "'" => '&#x27;',
+        '"' => '&quot;',
+        '/' => '&#x2F;'
+      }
+      ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
+
+      # Escape ampersands, brackets and quotes to their HTML/XML entities.
+      def self.escape_html(string)
+        string.to_s.gsub(ESCAPE_HTML_PATTERN) { |c| ESCAPE_HTML[c] }
+      end
+    end
+
+    module FileSystem
+      include Polytrix::Logging
+      include Polytrix::Util::String
+
+      # Finds a file by loosely matching the file name to a scenario name
+      def find_file(search_path, scenario_name, ignored_patterns = nil)
+        ignored_patterns ||= read_gitignore(search_path)
+        glob_string = "#{search_path}/**/*#{slugify(scenario_name)}.*"
+        potential_files = Dir.glob(glob_string, File::FNM_CASEFOLD)
+        potential_files.concat Dir.glob(glob_string.gsub('_', '-'), File::FNM_CASEFOLD)
+        potential_files.concat Dir.glob(glob_string.gsub('_', ''), File::FNM_CASEFOLD)
+
+        # Filter out ignored filesFind the first file, not including generated files
+        files = potential_files.select do |f|
+          !ignored? ignored_patterns, search_path, f
+        end
+
+        # Select the shortest path, likely the best match
+        file = files.min_by(&:length)
+
+        fail Errno::ENOENT, "No file was found for #{scenario_name} within #{search_path}" if file.nil?
+        Pathname.new file
+      end
+
+      def relativize(file, base_path)
+        absolute_file = File.absolute_path(file)
+        absolute_base_path = File.absolute_path(base_path)
+        Pathname.new(absolute_file).relative_path_from Pathname.new(absolute_base_path)
+      end
+
+      private
+
+      # @api private
+      def read_gitignore(dir)
+        gitignore_file = "#{dir}/.gitignore"
+        File.read(gitignore_file)
+      rescue
+        ''
+      end
+
+      # @api private
+      def ignored?(ignored_patterns, base_path, target_file)
+        # Trying to match the git ignore rules but there's some discrepencies.
+        ignored_patterns.split.find do |pattern|
+          # if git ignores a folder, we should ignore all files it contains
+          pattern = "#{pattern}**" if pattern[-1] == '/'
+          started_with_slash = pattern.start_with? '/'
+
+          pattern.gsub!(/\A\//, '') # remove leading slashes since we're searching from root
+          file = relativize(target_file, base_path)
+          ignored = file.fnmatch? pattern
+          ignored || (file.fnmatch? "**/#{pattern}" unless started_with_slash)
+        end
+      end
     end
   end
 end

data/lib/polytrix/validation.rb

@@ -2,19 +2,58 @@ require 'hashie/dash'
 
 module Polytrix
   class Validation < Polytrix::ManifestSection
+    # TODO: Should we have (expectation) 'failed' vs (unexpected) 'error'?
     ALLOWABLE_STATES = %w(passed pending failed skipped)
-    property :validated_by, required: true
-    property :result
+
+    property :result, required: true
+    property :error
 
     def result=(state)
+      state = state.to_s
       fail invalidate_state_error unless ALLOWABLE_STATES.include? state
       super
     end
 
+    ALLOWABLE_STATES.each do |state|
+      define_method "#{state}?" do
+        result == state?
+      end
+    end
+
+    # Gets the source of the validation code block where a ValidationFailure occurred.
+    def error_source
+      return nil if error.nil?
+      source_from_error(error)
+    end
+
     protected
 
     def invalidate_state_error(state)
       ArgumentError.new "Invalid result state: #{state}, should be one of #{ALLOWABLE_STATES.inspect}"
     end
+
+    def source_from_error(e)
+      error_location = e.backtrace_locations.delete_if { |l| l.absolute_path =~ /gems\/rspec-/ }.first
+      error_source = File.read(error_location.absolute_path)
+      error_lineno = error_location.lineno - 1 # lineno counts from 1
+      get_dedented_block(error_source, error_lineno)
+    end
+
+    def get_dedented_block(source_text, target_lineno)
+      block = []
+      lines = source_text.lines
+      target_indent = lines[target_lineno][/\A */].size
+      lines[0...target_lineno].reverse.each do |line|
+        indent = line[/\A */].size
+        block.prepend line
+        break if indent < target_indent
+      end
+      lines[target_lineno..lines.size].each do |line|
+        indent = line[/\A */].size
+        block.push line
+        break if indent < target_indent
+      end
+      block.join
+    end
   end
 end

data/lib/polytrix/validator.rb

@@ -5,21 +5,26 @@ module Polytrix
     include RSpec::Matchers
 
     UNIVERSAL_MATCHER = //
-    attr_reader :description, :suite, :sample, :level, :callback
+    attr_reader :description, :suite, :scenario, :level, :callback
 
     def initialize(description, scope = {}, &validator)
       @description = description
       @suite = scope[:suite] ||= UNIVERSAL_MATCHER
-      @sample = scope[:sample] ||= UNIVERSAL_MATCHER
+      @scenario = scope[:scenario] ||= UNIVERSAL_MATCHER
       @callback = validator
     end
 
     def should_validate?(challenge)
-      !!(@suite.match(challenge.suite.to_s) && @sample.match(challenge.name.to_s))
+      # TODO: Case-insensitive matching?
+      !!(@suite.match(challenge.suite.to_s) && @scenario.match(challenge.name.to_s)) # rubocop:disable Style/DoubleNegation
     end
 
     def validate(challenge)
-      instance_exec challenge, &@callback if should_validate?(challenge)
+      instance_exec(challenge, &@callback) if should_validate?(challenge)
+      challenge.result.validations[description] = Validation.new(result: :passed)
+    rescue StandardError, RSpec::Expectations::ExpectationNotMetError => e
+      validation = Validation.new(result: :failed, error: ValidationFailure.new(e.message, e))
+      challenge.result.validations[description] = validation
     end
 
     def to_s

data/lib/polytrix/version.rb

@@ -1,3 +1,3 @@
 module Polytrix
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

data/lib/polytrix.rb

@@ -1,140 +1,162 @@
+require 'thor'
 require 'pathname'
-require 'polytrix/error'
-require 'polytrix/core/hashie'
-require 'polytrix/core/string_helpers'
 require 'polytrix/version'
-require 'polytrix/util'
-require 'polytrix/color'
 require 'polytrix/logger'
 require 'polytrix/logging'
+require 'polytrix/error'
+require 'polytrix/dash'
+require 'polytrix/util'
+require 'polytrix/color'
 require 'polytrix/state_file'
-require 'polytrix/core/file_system_helper'
-require 'polytrix/runners/executor'
-require 'polytrix/core/manifest_section'
-require 'polytrix/core/implementor'
+require 'polytrix/spies'
+# TODO: Merge these two classes?
+require 'polytrix/executor'
 require 'polytrix/challenge_runner'
+require 'polytrix/implementor'
 require 'polytrix/challenge_result'
 require 'polytrix/challenge'
 require 'polytrix/challenges'
 require 'polytrix/manifest'
 require 'polytrix/configuration'
 require 'polytrix/validation'
-require 'polytrix/validations'
 require 'polytrix/result'
 require 'polytrix/documentation_generator'
 require 'polytrix/validator'
 require 'polytrix/validator_registry'
 
-require 'polytrix/rspec'
-
 module Polytrix
   include Polytrix::DefaultLogger
   include Polytrix::Logging
 
+  # File extensions that Polytrix can automatically detect/execute
+  SUPPORTED_EXTENSIONS = %w(py rb js)
+
   class << self
-    include Polytrix::Core::FileSystemHelper
+    include Polytrix::Util::FileSystem
+
+    DEFAULT_MANIFEST_FILE = 'polytrix.yml'
 
     # @return [Mutex] a common mutex for global coordination
     attr_accessor :mutex
 
-    def reset
-      @configuration = nil
-      Polytrix::ValidatorRegistry.clear
-    end
+    # @return [Logger] the common Polytrix logger
+    attr_accessor :logger
+
+    def setup(options, manifest_file = DEFAULT_MANIFEST_FILE)
+      # manifest_file = File.expand_path manifest
+      if File.exist? manifest_file
+        logger.debug "Loading manifest file: #{manifest_file}"
+        Polytrix.configuration.manifest = manifest_file
+      elsif options[:solo]
+        solo_setup(options)
+      else
+        fail StandardError, "No manifest found at #{manifest_file} and not using --solo mode"
+      end
 
-    # The {Polytrix::Manifest} that describes the test scenarios known to Polytrix.
-    def manifest
-      configuration.manifest
-    end
+      Polytrix.configuration.documentation_dir = options[:target_dir]
+      Polytrix.configuration.documentation_format = options[:format]
 
-    # The set of {Polytrix::Implementor}s registered with Polytrix.
-    def implementors
-      manifest.implementors.values
-    end
+      manifest.build_challenges
 
-    def find_implementor(file)
-      existing_implementor = recursive_parent_search(File.dirname(file)) do |path|
-        implementors.find do |implementor|
-          File.absolute_path(implementor.basedir) == File.absolute_path(path)
-        end
-      end
-      return existing_implementor if existing_implementor
+      test_dir = options[:test_dir].nil? ? nil : File.expand_path(options[:test_dir])
+      return nil unless test_dir && File.directory?(test_dir)
 
-      nil
+      $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
 
-    # Invokes the clone action for each SDK.
-    # @see Polytrix::Implementor#clone
-    def clone(*sdks)
-      select_implementors(sdks).each do |implementor|
-        implementor.clone
+    def solo_setup(options)
+      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
+      )
     end
 
-    # Invokes the bootstrap  action for each SDK.
-    # @see Polytrix::Implementor#bootstrap
-    def bootstrap(*sdks)
-      select_implementors(sdks).each do |implementor|
-        implementor.bootstrap
+    def select_scenarios(regexp)
+      regexp ||= 'all'
+      scenarios = if regexp == 'all'
+                    manifest.challenges.values
+                  else
+                    manifest.challenges.get(regexp) || manifest.challenges.get_all(/#{regexp}/)
+                  end
+      if scenarios.is_a? Array
+        scenarios
+      else
+        [scenarios]
       end
     end
 
-    def exec(*files)
-      # files.map do | file |
-      #   Dir.glob file
-      # end.flatten
-
-      files.each do | file |
-        implementor = find_implementor(file) # || exec_options[:default_implementor]
-
-        extension = File.extname(file)
-        name = File.basename(file, extension)
-        challenge_data = {
-          name: name,
-          # language: extension,
-          source_file: File.expand_path(file, Dir.pwd)
-        }
-        challenge = implementor.build_challenge challenge_data
-        challenge.exec
+    def filter_scenarios(regexp, options = {})
+      select_scenarios(regexp).tap do |scenarios|
+        scenarios.keep_if { |scenario| scenario.failed? == options[:failed] } unless options[:failed].nil?
+        scenarios.keep_if { |scenario| scenario.skipped? == options[:skipped] } unless options[:skipped].nil?
+        scenarios.keep_if { |scenario| scenario.sample? == options[:samples] } unless options[:samples].nil?
       end
     end
 
-    # Registers a {Polytrix::Validator} that will be used during test
-    # execution on matching {Polytrix::Challenge}s.
-    def validate(desc, scope = { suite: //, sample: // }, &block)
-      fail ArgumentError 'You must pass block' unless block_given?
-      validator = Polytrix::Validator.new(desc, scope, &block)
+    # Returns a default file logger which emits on standard output and to a
+    # log file.
+    #
+    # @return [Logger] a logger
+    def default_file_logger
+      logfile = File.expand_path(File.join('.polytrix', 'logs', 'polytrix.log'))
+      Logger.new(stdout: $stdout, logdev: logfile, level: env_log)
+    end
 
-      Polytrix::ValidatorRegistry.register validator
-      validator
+    # Determine the default log level from an environment variable, if it is
+    # set.
+    #
+    # @return [Integer,nil] a log level or nil if not set
+    # @api private
+    def env_log
+      level = ENV['POLYTRIX_LOG'] && ENV['POLYTRIX_LOG'].downcase.to_sym
+      level = Util.to_logger_level(level) unless level.nil?
+      level
     end
 
-    def load_tests
-      manifest.build_challenges
-      Polytrix::RSpec.run_manifest(manifest)
+    # Default log level verbosity
+    DEFAULT_LOG_LEVEL = :info
+
+    def reset
+      @configuration = nil
+      Polytrix::ValidatorRegistry.clear
     end
 
-    # Runs all of the tests described in the {manifest}
-    def verify(implementors = [])
-      test_env = ENV['TEST_ENV_NUMBER'].to_i
-      rspec_options = %W[--color -f documentation -f Polytrix::RSpec::YAMLReport -o reports/test_report#{test_env}.yaml]
-      rspec_options.concat Polytrix.configuration.rspec_options.split if Polytrix.configuration.rspec_options
-      unless implementors.empty?
-        target_sdks = implementors.map(&:name)
-        Polytrix.implementors.map(&:name).each do |sdk|
-          # We don't have an "or" for tags, so it's easier to exclude than include multiple tags
-          rspec_options.concat %W[-t ~#{sdk.to_sym}] unless target_sdks.include? sdk
-        end
-      end
+    # The {Polytrix::Manifest} that describes the test scenarios known to Polytrix.
+    def manifest
+      configuration.manifest
+    end
 
-      load_tests
-      logger.info "polytrix:test\tTesting with rspec options: #{rspec_options.join ' '}"
-      ::RSpec::Core::Runner.run rspec_options
-      logger.info "polytrix:test\tTest execution completed"
+    # The set of {Polytrix::Implementor}s registered with Polytrix.
+    def implementors
+      manifest.implementors.values
     end
 
-    def reset
-      @configuration = nil
+    # Registers a {Polytrix::Validator} that will be used during test
+    # execution on matching {Polytrix::Challenge}s.
+    def validate(desc, scope = { suite: //, scenario: // }, &block)
+      fail ArgumentError 'You must pass block' unless block_given?
+      validator = Polytrix::Validator.new(desc, scope, &block)
+
+      Polytrix::ValidatorRegistry.register validator
+      validator
     end
 
     # @see Polytrix::Configuration
@@ -155,23 +177,6 @@ module Polytrix
     def tty?
       $stdout.tty?
     end
-
-    protected
-
-    def select_implementors(sdks)
-      return implementors if sdks.empty?
-
-      sdks.map do |sdk|
-        if File.directory? sdk
-          sdk_dir = File.absolute_path(sdk)
-          implementors.find { |i| File.absolute_path(i.basedir) == sdk_dir } || configuration.implementor(sdk_dir)
-        else
-          implementor = implementors.find { |i| i.name.to_s.downcase == sdk.to_s.downcase }
-          fail ArgumentError, "SDK #{sdk} not found" if implementor.nil?
-          implementor
-        end
-      end
-    end
   end
 end
 

data/polytrix.gemspec

@@ -23,12 +23,17 @@ Gem::Specification.new do |spec|
   spec.add_dependency "mixlib-shellout", "~> 1.3" # Used for MRI
   spec.add_dependency "buff-shell_out", "~> 0.1"  # Used for JRuby
   spec.add_dependency "middleware", "~> 0.1"
-  spec.add_dependency "rspec", "~> 3.0"
+  spec.add_dependency "rspec-expectations", "~> 3.0"
   spec.add_dependency "hashie", "~> 3.0"
   spec.add_dependency "padrino-helpers", "~> 0.12"
+  spec.add_dependency "erubis", "~> 2.7"
+  spec.add_dependency "cause", "~> 0.1"
+  spec.add_dependency "rouge", "~> 1.7"
+  spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "aruba", "~> 0.5"
-  spec.add_development_dependency 'rubocop', '~> 0.18.0'
+  spec.add_development_dependency 'rubocop', '~> 0.18'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.2'
   spec.add_development_dependency 'fabrication', '~> 2.11'
 end