polytrix 0.1.0.pre → 0.1.0

data/lib/polytrix/state_file.rb

@@ -0,0 +1,60 @@
+require 'hashie'
+
+module Polytrix
+  class StateFileLoadError < StandardError; end
+  class StateFile
+    def initialize(polytrix_root, name)
+      @file_name = File.expand_path(
+        File.join(polytrix_root, '.polytrix', "#{name}.yml")
+      )
+    end
+
+    def read
+      if File.exist?(file_name)
+        Hashie::Mash.load(file_name).dup
+      else
+        Hashie::Mash.new
+      end
+    end
+
+    def write(state)
+      dir = File.dirname(file_name)
+      serialized_string = serialize_hash(Util.stringified_hash(state))
+
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      File.open(file_name, 'wb') { |f| f.write(serialized_string) }
+    end
+
+    def destroy
+      FileUtils.rm_f(file_name) if File.exist?(file_name)
+    end
+
+    def diagnose
+      raw = read
+      result = {}
+      raw.keys.sort.each { |k| result[k] = raw[k] }
+      result
+    end
+
+    private
+
+    attr_reader :file_name
+
+    # @api private
+    def read_file
+      IO.read(file_name)
+    end
+
+    # @api private
+    def deserialize_string(string)
+      SafeYAML.load(string)
+    rescue SyntaxError, Psych::SyntaxError => ex
+      raise StateFileLoadError, "Error parsing #{file_name} (#{ex.message})"
+    end
+
+    # @api private
+    def serialize_hash(hash)
+      ::YAML.dump(hash)
+    end
+  end
+end

data/lib/polytrix/util.rb

@@ -0,0 +1,155 @@
+# -*- 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.
+
+module Polytrix
+  # Stateless utility methods used in different contexts. Essentially a mini
+  # PassiveSupport library.
+  module Util
+    # Returns the standard library Logger level constants for a given symbol
+    # representation.
+    #
+    # @param symbol [Symbol] symbol representation of a logger level (:debug,
+    #   :info, :warn, :error, :fatal)
+    # @return [Integer] Logger::Severity constant value or nil if input is not
+    #   valid
+    def self.to_logger_level(symbol)
+      return nil unless [:debug, :info, :warn, :error, :fatal].include?(symbol)
+
+      Logger.const_get(symbol.to_s.upcase)
+    end
+
+    # Returns the symbol represenation of a logging levels for a given
+    # standard library Logger::Severity constant.
+    #
+    # @param const [Integer] Logger::Severity constant value for a logging
+    #   level (Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR,
+    #   Logger::FATAL)
+    # @return [Symbol] symbol representation of the logging level
+    def self.from_logger_level(const)
+      case const
+      when Logger::DEBUG then :debug
+      when Logger::INFO then :info
+      when Logger::WARN then :warn
+      when Logger::ERROR then :error
+      else :fatal
+      end
+    end
+
+    # Returns a new Hash with all key values coerced to symbols. All keys
+    # within a Hash are coerced by calling #to_sym and hashes within arrays
+    # and other hashes are traversed.
+    #
+    # @param obj [Object] the hash to be processed. While intended for
+    #   hashes, this method safely processes arbitrary objects
+    # @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)|
+          h[k.to_sym] = symbolized_hash(v)
+          h
+        end
+      elsif obj.is_a?(Array)
+        obj.reduce([]) do |a, e|
+          a << symbolized_hash(e)
+          a
+        end
+      else
+        obj
+      end
+    end
+
+    # Returns a new Hash with all key values coerced to strings. All keys
+    # within a Hash are coerced by calling #to_s and hashes with arrays
+    # and other hashes are traversed.
+    #
+    # @param obj [Object] the hash to be processed. While intended for
+    #   hashes, this method safely processes arbitrary objects
+    # @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)|
+          h[k.to_s] = stringified_hash(v)
+          h
+        end
+      elsif obj.is_a?(Array)
+        obj.reduce([]) do |a, e|
+          a << stringified_hash(e)
+          a
+        end
+      else
+        obj
+      end
+    end
+
+    # Returns a formatted string representing a duration in seconds.
+    #
+    # @param total [Integer] the total number of seconds
+    # @return [String] a formatted string of the form (XmYY.00s)
+    def self.duration(total)
+      total = 0 if total.nil?
+      minutes = (total / 60).to_i
+      seconds = (total - (minutes * 60))
+      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'"
+    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(/[^ ]/)}}/, '')
+    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]
+      ))
+    end
+  end
+end

data/lib/polytrix/validation.rb

@@ -1,7 +1,7 @@
 require 'hashie/dash'
 
 module Polytrix
-  class Validation < Hashie::Dash
+  class Validation < Polytrix::ManifestSection
     ALLOWABLE_STATES = %w(passed pending failed skipped)
     property :validated_by, required: true
     property :result

data/lib/polytrix/validator.rb

@@ -1,7 +1,11 @@
+require 'rspec/expectations'
+
 module Polytrix
   class Validator
+    include RSpec::Matchers
+
     UNIVERSAL_MATCHER = //
-    attr_reader :suite, :sample, :callback
+    attr_reader :suite, :sample, :level, :callback
 
     def initialize(scope = {}, &validator)
       @suite = scope[:suite] ||= UNIVERSAL_MATCHER
@@ -10,11 +14,11 @@ module Polytrix
     end
 
     def should_validate?(challenge)
-      !!(@suite.match(challenge.suite) && @sample.match(challenge.name))
+      !!(@suite.match(challenge.suite.to_s) && @sample.match(challenge.name.to_s))
     end
 
-    # def validate(challenge)
-    #   instance_exec challenge, @callback if should_validate?(challenge)
-    # end
+    def validate(challenge)
+      instance_exec challenge, &@callback if should_validate?(challenge)
+    end
   end
 end

data/lib/polytrix/version.rb

@@ -1,3 +1,3 @@
 module Polytrix
-  VERSION = '0.1.0.pre'
+  VERSION = '0.1.0'
 end

data/lib/polytrix.rb

@@ -1,14 +1,21 @@
 require 'pathname'
-require 'hashie/dash'
-require 'hashie/mash'
-require 'hashie/extensions/coercion'
+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/state_file'
 require 'polytrix/core/file_system_helper'
-require 'polytrix/executor'
+require 'polytrix/runners/executor'
+require 'polytrix/core/manifest_section'
 require 'polytrix/core/implementor'
 require 'polytrix/challenge_runner'
+require 'polytrix/challenge_result'
 require 'polytrix/challenge'
+require 'polytrix/challenges'
 require 'polytrix/manifest'
 require 'polytrix/configuration'
 require 'polytrix/validation'
@@ -21,11 +28,15 @@ require 'polytrix/validator_registry'
 require 'polytrix/rspec'
 
 module Polytrix
-  include Polytrix::Logger
+  include Polytrix::DefaultLogger
+  include Polytrix::Logging
 
   class << self
     include Polytrix::Core::FileSystemHelper
 
+    # @return [Mutex] a common mutex for global coordination
+    attr_accessor :mutex
+
     def reset
       @configuration = nil
       Polytrix::ValidatorRegistry.clear
@@ -33,12 +44,12 @@ module Polytrix
 
     # The {Polytrix::Manifest} that describes the test scenarios known to Polytrix.
     def manifest
-      configuration.test_manifest
+      configuration.manifest
     end
 
     # The set of {Polytrix::Implementor}s registered with Polytrix.
     def implementors
-      configuration.implementors
+      manifest.implementors.values
     end
 
     def find_implementor(file)
@@ -49,12 +60,17 @@ module Polytrix
       end
       return existing_implementor if existing_implementor
 
-      implementor_basedir = recursive_parent_search(File.dirname(file), 'polytrix.yml')
-      return Polytrix.configuration.implementor implementor_basedir if implementor_basedir
-
       nil
     end
 
+    # Invokes the clone action for each SDK.
+    # @see Polytrix::Implementor#clone
+    def clone(*sdks)
+      select_implementors(sdks).each do |implementor|
+        implementor.clone
+      end
+    end
+
     # Invokes the bootstrap  action for each SDK.
     # @see Polytrix::Implementor#bootstrap
     def bootstrap(*sdks)
@@ -63,18 +79,24 @@ module Polytrix
       end
     end
 
-    def exec(file, exec_options)
-      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.run
+    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
+      end
     end
 
     # Registers a {Polytrix::Validator} that will be used during test
@@ -91,11 +113,12 @@ module Polytrix
     end
 
     def load_tests
+      manifest.build_challenges
       Polytrix::RSpec.run_manifest(manifest)
     end
 
     # Runs all of the tests described in the {manifest}
-    def run_tests(implementors = [])
+    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
@@ -128,15 +151,12 @@ module Polytrix
       yield(configuration)
     end
 
-    # Merges multiple test results files produced the rspec {Polytrix::RSpec::YAMLReport} formatter.
-    # @param result_files [Array] the location of the files to merge.
-    # @return [String] the merged content
-    def merge_results(result_files)
-      merged_results = Polytrix::Manifest.new
-      result_files.each do |result_file|
-        merged_results.deep_merge! YAML.load(File.read(result_file))
-      end
-      YAML.dump(merged_results.to_hash)
+    # Returns whether or not standard output is associated with a terminal
+    # device (tty).
+    #
+    # @return [true,false] is there a tty?
+    def tty?
+      $stdout.tty?
     end
 
     protected
@@ -149,7 +169,7 @@ module Polytrix
           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 == sdk }
+          implementor = implementors.find { |i| i.name.to_s.downcase == sdk.to_s.downcase }
           fail ArgumentError, "SDK #{sdk} not found" if implementor.nil?
           implementor
         end
@@ -157,3 +177,5 @@ module Polytrix
     end
   end
 end
+
+Polytrix.mutex = Mutex.new

data/polytrix.gemspec

@@ -19,10 +19,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor", "~> 0.19"
-  spec.add_dependency "mixlib-shellout", "~> 1.3"
+  spec.add_dependency "logging", "~> 1.8"
+  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", "~> 2.99"
-  spec.add_dependency "hashie", "~> 2.1"
+  spec.add_dependency "hashie", "~> 3.0"
   spec.add_dependency "padrino-helpers", "~> 0.12"
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"

data/polytrix.rb

@@ -1,6 +1 @@
 Polytrix.configuration.default_doc_template = 'doc-src/_markdown.md'
-
-Polytrix.configure do |polytrix|
-  polytrix.test_manifest = 'polytrix_tests.yml'
-  polytrix.implementor name: 'polytrix', language: 'ruby', basedir: 'samples/'
-end

data/{polytrix_tests.yml → polytrix.yml}

@@ -1,4 +1,9 @@
 ---
+implementors:
+  polytrix:
+    language: 'ruby'
+    basedir: 'samples/'
+
 global_env:                          # global_env defines input available for all scenarios
   LOCALE: <%= ENV['LANG'] %>         # templating is allowed
   FAVORITE_NUMBER: 5

data/samples/default_bootstrap.rb

@@ -3,12 +3,5 @@
 # This example shows the default behavior of `Polytrix#bootstrap`
 require 'polytrix'
 
-Polytrix.configure do |polytrix|
-  Dir['sdks/*'].each do |sdk|
-    name = File.basename(sdk)
-    polytrix.implementor name: name, basedir: sdk
-  end
-end
-
 # Snippet: bootstrap
 Polytrix.bootstrap

data/samples/polytrix.rb

@@ -1,14 +1,5 @@
 require 'polytrix'
 
-basedir = File.expand_path('..', __FILE__)
-
-Polytrix.configure do |polytrix|
-  Dir["#{basedir}/sdks/*"].each do |sdk|
-    name = File.basename(sdk)
-    polytrix.implementor name: name, basedir: sdk
-  end
-end
-
 RSpec.configure do |c|
   c.expose_current_running_example_as :example
 end

data/samples/{polytrix_tests.yml → polytrix.yml}

@@ -1,4 +1,15 @@
 ---
+  implementors:
+    ruby:
+      language: 'ruby'
+      basedir: 'sdks/ruby'
+    java:
+      language: 'java'
+      basedir: 'sdks/java'
+    python:
+      language: 'python'
+      basedir: 'sdks/python'
+
   global_env:                          # global_env defines input available for all scenarios
     LOCALE: <%= ENV['LANG'] %>         # templating is allowed
   suites:

data/samples/polytrix_cli.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash -e
 bundle exec polytrix bootstrap
 bundle exec polytrix exec sdks/ruby/challenges/*.rb --code2doc --target-dir=docs/ruby/
-bundle exec polytrix test
+# bundle exec polytrix test
 bundle exec polytrix report summary
 bundle exec polytrix report summary --format=markdown
 bundle exec polytrix report summary --format=yaml

data/spec/fabricators/implementor_fabricator.rb

@@ -0,0 +1,20 @@
+require 'hashie/mash'
+
+# Fabricates test manifests (.polytrix.yml files)
+LANGUAGES = %w(java ruby python nodejs c# golang php)
+SAMPLE_NAMES = [
+  'hello world',
+  'quine',
+  'my_kata'
+]
+
+Fabricator(:implementor, from: Polytrix::Implementor) do
+  initialize_with { @_klass.new to_hash } # Hash based initialization
+  language { LANGUAGES.sample }
+  name do |attr|
+    "my_#{attr[:language]}_project"
+  end
+  basedir do |attr|
+    "sdks/#{attr[:name]}"
+  end
+end

data/spec/fabricators/manifest_fabricator.rb

@@ -1,6 +1,6 @@
 require 'hashie/mash'
 
-# Fabricates test manifests (.polytrix_tests.yml files)
+# Fabricates test manifests (.polytrix.yml files)
 LANGUAGES = %w(java ruby python nodejs c# golang php)
 SAMPLE_NAMES = [
   'hello world',
@@ -12,6 +12,9 @@ Fabricator(:manifest, from: Polytrix::Manifest) do
   initialize_with { @_klass.new to_hash } # Hash based initialization
   transient suite_count: 3
   transient samples_per_suite: 3
+  implementors do
+    Fabricate(:implementor)
+  end
   global_env do
     {
       VAR1: 1,

data/spec/fixtures/{polytrix_tests.yml → polytrix.yml}

@@ -1,4 +1,14 @@
 ---
+  implementors:
+    ruby:
+      language: 'ruby'
+      basedir: 'sdks/ruby'
+    java:
+      language: 'java'
+      basedir: 'sdks/java'
+    python:
+      language: 'python'
+      basedir: 'sdks/python'
   global_env:
     LOCALE: <%= ENV['LANG'] %>
     FAVORITE_NUMBER: 5

data/spec/polytrix/challenge_runner_spec.rb

@@ -1,13 +1,14 @@
 module Polytrix
   describe ChallengeRunner do
     subject(:runner) { ChallengeRunner.create_runner }
+    let(:implementor) { Fabricate(:implementor) }
     let(:challenge) do
-      Fabricate(:challenge, name: 'factorial', source_file: 'spec/fixtures/factorial.py', basedir: 'spec/fixtures')
+      Fabricate(:challenge, name: 'factorial', source_file: 'spec/fixtures/factorial.py', basedir: 'spec/fixtures', implementor: implementor)
     end
 
     describe '#run_challenge' do
       it 'executes a challenge' do
-        expect(runner.run_challenge challenge).to be_an_instance_of Challenge
+        expect(runner.run_challenge challenge).to be_an_instance_of Result
       end
     end
   end

data/spec/polytrix/challenge_spec.rb

@@ -5,14 +5,15 @@ module Polytrix
       implementor.build_challenge name: 'factorial', vars: {}
     end
 
-    describe '#run' do
+    describe '#exec' do
       it 'executes the challenge and returns itself' do
-        expect(challenge.run).to be_an_instance_of Challenge
-        expect(challenge.run).to eq(challenge)
+        expect(challenge.exec).to be_an_instance_of Challenge
+        expect(challenge.exec).to eq(challenge)
       end
 
       it 'stores the result' do
-        expect(challenge.run[:result]).to be_an_instance_of Result
+        result = challenge.exec[:result]
+        expect(result).to be_an_instance_of Result
       end
     end
   end

data/spec/polytrix/cli_spec.rb

@@ -2,36 +2,33 @@ require 'spec_helper'
 require 'polytrix/cli'
 
 module Polytrix
-  module CLI
-    describe Main do
-      let(:kernel) { double(:kernel) }
-      subject { ThorSpy.on(described_class, kernel) }
-      describe 'bootstrap' do
-        context 'with no args' do
-          it 'calls Polytrix.bootstrap' do
-            expect(kernel).to receive(:exit).with(0)
-            expect(Polytrix).to receive(:bootstrap)
-            subject.bootstrap
-          end
+  describe CLI do
+    let(:kernel) { double(:kernel) }
+    subject { ThorSpy.on(described_class, kernel) }
+    describe 'bootstrap' do
+      context 'with no args' do
+        it 'calls bootstrap on each implementor' do
+          expect(kernel).to receive(:exit).with(0)
+          # TODO: Any way to test each implementor is called? We can't use
+          # `Polytrix.implementors` because it will be reloaded.
+          subject.bootstrap
         end
+      end
 
-        context 'with an existing SDK' do
-          before do
-            @implementor = Polytrix.configuration.implementor name: 'test', basedir: '.'
-          end
-
-          it 'calls bootstrap on the SDK' do
-            expect(@implementor).to receive(:bootstrap)
-            expect(kernel).to receive(:exit).with(0)
-            expect(subject.stderr.string).to eq('')
-            subject.bootstrap('test')
-          end
+      context 'with an existing SDK' do
+        xit 'calls bootstrap on the SDK' do
+          # expect(@implementor).to receive(:bootstrap)
+          expect(kernel).to receive(:exit).with(0)
+          expect(subject.stderr.string).to eq('')
+          subject.bootstrap('test')
         end
+      end
 
-        context 'with an non-existant SDK' do
-          it 'fails' do
-            expect { subject.bootstrap('missing') }.to raise_error(SystemExit, 'SDK missing not found')
-          end
+      context 'with an non-existant SDK' do
+        it 'fails' do
+          expect(kernel).to receive(:exit).with(1)
+          subject.bootstrap('missing')
+          expect(subject.stdout.string).to include('No scenarios for regex')
         end
       end
     end