polytrix 0.0.1 → 0.1.0.pre

data/lib/polytrix/runners/middleware/setup_env_vars.rb

@@ -4,12 +4,13 @@ module Polytrix
   module Runners
     module Middleware
       class SetupEnvVars
+        include Polytrix::Core::FileSystemHelper
+
         def initialize(app)
           @app   = app
         end
 
         def call(env)
-          challenge_runner = env[:challenge_runner]
           vars = begin
             Polytrix.manifest[:global_env].dup
           rescue
@@ -17,15 +18,16 @@ module Polytrix
           end
           vars = vars.merge env[:vars].dup
 
-          env[:env_file] = setup_env_vars(vars, challenge_runner)
+          env[:env_file] = setup_env_vars(env[:name], vars, env[:challenge_runner])
           @app.call env
         end
 
         private
 
-        def setup_env_vars(vars, challenge_runner)
+        def setup_env_vars(challenge_name, vars, challenge_runner)
           FileUtils.mkdir_p 'tmp'
-          file = File.open("tmp/vars.#{challenge_runner.script_extension}", 'w')
+          extension = challenge_runner.script_extension
+          file = File.open(slugify("tmp/#{challenge_name}_vars.#{extension}"), 'w')
           vars.each do |key, value|
             file.puts challenge_runner.save_environment_variable(key, value)
           end

data/lib/polytrix/validation.rb

@@ -0,0 +1,20 @@
+require 'hashie/dash'
+
+module Polytrix
+  class Validation < Hashie::Dash
+    ALLOWABLE_STATES = %w(passed pending failed skipped)
+    property :validated_by, required: true
+    property :result
+
+    def result=(state)
+      fail invalidate_state_error unless ALLOWABLE_STATES.include? state
+      super
+    end
+
+    protected
+
+    def invalidate_state_error(state)
+      ArgumentError.new "Invalid result state: #{state}, should be one of #{ALLOWABLE_STATES.inspect}"
+    end
+  end
+end

data/lib/polytrix/validations.rb

@@ -0,0 +1,23 @@
+require 'hashie/dash'
+
+module Polytrix
+  class Validations < Set
+    def to_hash
+      map do |v|
+        v.to_hash
+      end
+    end
+
+    def to_yaml
+      to_hash.to_yaml
+    end
+
+    # Hashie Coercion - automatically treat all values as Validation
+    def self.coerce(obj)
+      data = obj.map do |value|
+        Validation.new(value)
+      end
+      new data
+    end
+  end
+end

data/lib/polytrix/validator.rb

@@ -0,0 +1,20 @@
+module Polytrix
+  class Validator
+    UNIVERSAL_MATCHER = //
+    attr_reader :suite, :sample, :callback
+
+    def initialize(scope = {}, &validator)
+      @suite = scope[:suite] ||= UNIVERSAL_MATCHER
+      @sample = scope[:sample] ||= UNIVERSAL_MATCHER
+      @callback = validator
+    end
+
+    def should_validate?(challenge)
+      !!(@suite.match(challenge.suite) && @sample.match(challenge.name))
+    end
+
+    # def validate(challenge)
+    #   instance_exec challenge, @callback if should_validate?(challenge)
+    # end
+  end
+end

data/lib/polytrix/validator_registry.rb

@@ -0,0 +1,34 @@
+require 'singleton'
+
+module Polytrix
+  class ValidatorRegistry
+    include Singleton
+
+    def validators
+      @validator ||= []
+    end
+
+    class << self
+      def validators
+        instance.validators
+      end
+
+      def register(validator, &callback)
+        if block_given?
+          match_rules = validator
+          validator = Validator.new(match_rules, &callback)
+        end
+        validators << validator
+      end
+
+      def validators_for(challenge)
+        selected_validators = validators.select { |v| v.should_validate? challenge }
+        selected_validators.empty? ? [Polytrix.configuration.default_validator] : selected_validators
+      end
+
+      def clear
+        validators.clear
+      end
+    end
+  end
+end

data/lib/polytrix/version.rb

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

data/lib/polytrix.rb

@@ -1,56 +1,159 @@
+require 'pathname'
+require 'hashie/dash'
+require 'hashie/mash'
+require 'hashie/extensions/coercion'
 require 'polytrix/version'
-require 'polytrix/manifest'
+require 'polytrix/logger'
+require 'polytrix/core/file_system_helper'
+require 'polytrix/executor'
 require 'polytrix/core/implementor'
-require 'polytrix/core/result_tracker'
-require 'polytrix/core/file_finder'
 require 'polytrix/challenge_runner'
 require 'polytrix/challenge'
-require 'polytrix/challenge_builder'
+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::Logger
+
   class << self
-    attr_accessor :implementors
-    attr_accessor :manifest
-    attr_accessor :default_validator_callback
+    include Polytrix::Core::FileSystemHelper
+
+    def reset
+      @configuration = nil
+      Polytrix::ValidatorRegistry.clear
+    end
+
+    # The {Polytrix::Manifest} that describes the test scenarios known to Polytrix.
+    def manifest
+      configuration.test_manifest
+    end
+
+    # The set of {Polytrix::Implementor}s registered with Polytrix.
+    def implementors
+      configuration.implementors
+    end
+
+    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
+
+      implementor_basedir = recursive_parent_search(File.dirname(file), 'polytrix.yml')
+      return Polytrix.configuration.implementor implementor_basedir if implementor_basedir
+
+      nil
+    end
 
-    def default_validator_callback
-      @default_validator_callback ||= proc{ |challenge|
-        expect(challenge[:result].process.exitstatus).to eq(0)
+    # Invokes the bootstrap  action for each SDK.
+    # @see Polytrix::Implementor#bootstrap
+    def bootstrap(*sdks)
+      select_implementors(sdks).each do |implementor|
+        implementor.bootstrap
+      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
     end
 
-    def default_validator_callback=(callback)
-      @default_validator_callback = callback
+    # Registers a {Polytrix::Validator} that will be used during test
+    # execution on matching {Polytrix::Challenge}s.
+    def validate(scope = { suite: //, sample: // }, validator = nil, &block)
+      if block_given?
+        validator = Polytrix::Validator.new(scope, &block)
+      elsif validator.nil?
+        fail ArgumentError 'You must a block or a Validator as the second argument'
+      end
+
+      Polytrix::ValidatorRegistry.register validator
+      validator
     end
 
+    def load_tests
+      Polytrix::RSpec.run_manifest(manifest)
+    end
+
+    # Runs all of the tests described in the {manifest}
+    def run_tests(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
+
+      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"
+    end
+
+    def reset
+      @configuration = nil
+    end
+
+    # @see Polytrix::Configuration
     def configuration
       fail "configuration doesn't take a block, use configure" if block_given?
       @configuration ||= Configuration.new
     end
 
+    # @see Polytrix::Configuration
     def configure
       yield(configuration)
     end
 
-    def sdk_dir(sdk)
-      "sdks/#{sdk}"
+    # 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)
     end
 
-    def load_manifest(yaml_file)
-      @manifest = Polytrix::Manifest.from_yaml yaml_file
-    end
+    protected
 
-    def results
-      Polytrix::ResultTracker.instance
-    end
+    def select_implementors(sdks)
+      return implementors if sdks.empty?
 
-    def run_tests
-      Polytrix::RSpec.run_manifest(@manifest)
+      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 == sdk }
+          fail ArgumentError, "SDK #{sdk} not found" if implementor.nil?
+          implementor
+        end
+      end
     end
   end
 end

data/polytrix.gemspec

@@ -18,10 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "thor", "~> 0.19"
   spec.add_dependency "mixlib-shellout", "~> 1.3"
   spec.add_dependency "middleware", "~> 0.1"
-  spec.add_dependency "rspec", "~> 2.14"
-  spec.add_dependency "hashie", "~> 2.0"
+  spec.add_dependency "rspec", "~> 2.99"
+  spec.add_dependency "hashie", "~> 2.1"
+  spec.add_dependency "padrino-helpers", "~> 0.12"
   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 'fabrication', '~> 2.11'
 end

data/polytrix.rb

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,20 @@
+---
+global_env:                          # global_env defines input available for all scenarios
+  LOCALE: <%= ENV['LANG'] %>         # templating is allowed
+  FAVORITE_NUMBER: 5
+suites:
+  Bootstrapping:
+    samples:
+      - default bootstrap
+      - custom bootstrap
+  Testing:                           # "Katas" is the name of the first suite
+    env:                             # These "env" values are only available within the "Katas" suite
+      NAME: 'Max'
+    samples:                         # samples defines the individual tests in a suite
+      - default validation
+      - custom validation
+  Plugins:                           # "Tutorials" is the name of the second suite
+        env:
+        samples:
+          - validating
+          - reporting

data/resources/code_sample.tt

@@ -0,0 +1,2 @@
+<%= commented "Sample for #{@scenario.name}" %>
+<%= commented @scenario.description if @scenario.description %>

data/samples/.gitignore

@@ -0,0 +1,2 @@
+reports/
+tmp/

data/samples/_markdown.md

@@ -0,0 +1,5 @@
+<% challenges.compact.each do |challenge| %>
+``` <%= challenge.implementor.language %>
+<%= File.read(challenge.source_file) %>
+```
+<% end %>

data/samples/default_bootstrap.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+# 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

@@ -0,0 +1,28 @@
+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
+
+Polytrix.validate suite: 'Katas', sample: 'hello world' do |challenge|
+  expect(challenge.result.stdout).to eq "Hello, world!\n"
+end
+
+Polytrix.validate suite: 'Katas', sample: 'quine' do |challenge|
+  expect(challenge.result.stdout).to eq(challenge.source)
+end
+
+Polytrix.validate do |challenge|
+  expect(challenge.result.exitstatus).to eq(0)
+  expect(challenge.result.stderr).to be_empty
+  expect(challenge.result.stdout).to end_with "\n"
+end

data/samples/polytrix_cli.sh

@@ -0,0 +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 report summary
+bundle exec polytrix report summary --format=markdown
+bundle exec polytrix report summary --format=yaml

data/samples/polytrix_tests.yml

@@ -0,0 +1,10 @@
+---
+  global_env:                          # global_env defines input available for all scenarios
+    LOCALE: <%= ENV['LANG'] %>         # templating is allowed
+  suites:
+    Katas:                             # "Katas" is the name of the first test suite
+      env:                             # Unlike global_env, these variables are only for the Katas suite
+        COLOR: red
+      samples:                         # Test scenarios within Katas
+        - hello world
+        - quine

data/{sdks/fog → samples}/scripts/bootstrap

@@ -1,4 +1,2 @@
 #!/bin/bash
-
 bundle install
-

data/samples/scripts/wrapper

@@ -0,0 +1,7 @@
+#!/bin/bash
+if [[ "$1" == *.rb ]]
+then
+  bundle exec ruby "$@"
+else
+  bundle exec "$@"
+fi

data/samples/sdks/custom/polytrix.yml

@@ -0,0 +1,2 @@
+---
+name: My Custom project

data/samples/sdks/java/.gitignore

@@ -0,0 +1,2 @@
+.gradle/
+build/

data/samples/sdks/java/build.gradle

@@ -0,0 +1,14 @@
+apply plugin: 'java'
+sourceSets {
+    main {
+        java {
+            srcDir 'challenges'
+        }
+    }
+}
+version = '1.0'
+jar {
+    manifest {
+        attributes 'Implementation-Title': 'Java Samples', 'Implementation-Version': version
+    }
+}

data/samples/sdks/java/challenges/HelloWorld.java

@@ -0,0 +1,10 @@
+// This is an example of the standard [Hello World](http://en.wikipedia.org/wiki/Hello_world_program)
+// program written in [Java][java].
+public class HelloWorld {
+  // A Java CLI application is defined by creating a main method with this signature:
+  public static void main(String[] args) {
+    System.out.println("Hello, world!");
+  }
+}
+
+// [java]: http://en.wikipedia.org/wiki/Java_(programming_language)

data/samples/sdks/java/challenges/Quine.java

@@ -0,0 +1,31 @@
+public class Quine
+{
+  public static void main(String[] args)
+  {
+    char q = 34;      // Quotation mark character
+    String[] l = {    // Array of source code
+    "public class Quine",
+    "{",
+    "  public static void main(String[] args)",
+    "  {",
+    "    char q = 34;      // Quotation mark character",
+    "    String[] l = {    // Array of source code",
+    "    ",
+    "    };",
+    "    for(int i = 0; i < 6; i++ )          // Print opening code",
+    "        System.out.println(l[i]);",
+    "    for(int i = 0; i < l.length; i++)    // Print string array",
+    "        System.out.println( l[6] + q + l[i] + q + ',' );",
+    "    for(int i = 7; i < l.length; i++)    // Print this code",
+    "        System.out.println( l[i] );",
+    "  }",
+    "}",
+    };
+    for(int i = 0; i < 6; i++ )          // Print opening code
+        System.out.println(l[i]);
+    for(int i = 0; i < l.length; i++)    // Print string array
+        System.out.println( l[6] + q + l[i] + q + ',' );
+    for(int i = 7; i < l.length; i++)    // Print this code
+        System.out.println( l[i] );
+  }
+}

data/samples/sdks/java/code_sample.tt

@@ -0,0 +1,11 @@
+public class <%= @scenario.name %> {
+  public static void main(String[] args) {
+    <%= commented @scenario.name %>
+    <%= commented """
+    This is
+    a multi line
+    test
+    """ %>
+    <%= commented "This is\nanother multi line\ntest\n" %>
+  }
+}

data/samples/sdks/java/scripts/bootstrap

@@ -0,0 +1,2 @@
+#!/bin/bash
+gradle build

data/samples/sdks/java/scripts/wrapper

@@ -0,0 +1,8 @@
+#!/bin/bash
+SOURCE_FILE=$1
+CLASSNAME=`basename $SOURCE_FILE .java`
+#NAMESPACE=org.example.
+CLASS="${NAMESPACE}${CLASSNAME}"
+gradle assemble --quiet
+java -classpath build/libs/java-1.0.jar $CLASS
+

data/samples/sdks/python/challenges/hello_world.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python
+print 'Hello, world!'

data/samples/sdks/python/challenges/quine.py

@@ -0,0 +1,2 @@
+s = 's = %r\nprint(s%%s)'
+print(s%s)

data/{sdks/pkgcloud → samples/sdks/python}/scripts/wrapper

@@ -1,2 +1,2 @@
 #!/bin/bash
-node "$@"
+python "$@"

data/samples/sdks/ruby/challenges/hello_world.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+name = 'world'
+# This will print Hello, world!
+puts "Hello, #{name}!"

data/scripts/bootstrap

@@ -1,10 +1,2 @@
 #!/bin/bash
-gem install bundler --no-ri --no-rdoc
-rbenv rehash
-bundle update
-virtualenv polytrix
-source polytrix/bin/activate
-pip install pygments
-npm install groc
-export PATH="$PATH:`pwd`/node_modules/.bin"
-bundle exec rake bootstrap
+bundle install

data/scripts/wrapper

@@ -0,0 +1,7 @@
+#!/bin/bash
+if [[ "$1" == *.rb ]]
+then
+  bundle exec ruby "$@"
+else
+  bundle exec "$@"
+fi

data/spec/fabricators/challenge_fabricator.rb

@@ -0,0 +1,17 @@
+require 'hashie/mash'
+
+# Fabricates test manifests (.polytrix_tests.yml files)
+LANGUAGES = %w(java ruby python nodejs c# golang php)
+SAMPLE_NAMES = [
+  'hello world',
+  'quine',
+  'my_kata'
+]
+
+Fabricator(:challenge, from: Polytrix::Challenge) do
+  initialize_with { @_klass.new to_hash } # Hash based initialization
+  name { SAMPLE_NAMES.sample }
+  suite { LANGUAGES.sample }
+  source_file { 'spec/fixtures/factorial.py' }
+  basedir { 'spec/fixtures' }
+end