polytrix 0.1.2 → 0.1.3

data/lib/polytrix/documentation/view_helper.rb

@@ -1,21 +0,0 @@
-module Polytrix
-  module Documentation
-    module ViewHelper
-      def polytrix_toc
-        buffer = StringIO.new
-        buffer.puts '<ul>'
-        Polytrix.manifest.suites.each do |suite_name, suite|
-          buffer.puts "<li>#{suite_name}</li>"
-          buffer.puts '<ul>'
-          suite.samples.each do |challenge_name|
-            buffer.puts "<li>#{challenge_name}</li>"
-          end
-          buffer.puts '</ul>'
-        end
-        buffer.puts '</ul>'
-
-        buffer.string
-      end
-    end
-  end
-end

data/lib/polytrix/rspec/documentation_formatter.rb

@@ -1,66 +0,0 @@
-require 'polytrix/rspec'
-require 'hashie/mash'
-require 'yaml'
-require 'fileutils'
-
-module Polytrix
-  module RSpec
-    class DocumentationFormatter < ::RSpec::Core::Formatters::BaseFormatter
-      include Polytrix::Core::FileSystemHelper
-
-      def initialize(output)
-        @templates_dir = 'doc-src'
-        @output_dir = 'docs'
-        @results = Hashie::Mash.new
-        @summary_files = %w(index)
-        super
-      end
-
-      def example_group_finished(example_group)
-        polytrix_challenges = example_group.examples.map { |e| e.metadata[:polytrix_challenge] }
-        target_file = target_file_for example_group
-        template_file = template_for example_group
-        produce_doc template_file, target_file, example_group.description, polytrix_challenges if template_file
-      end
-
-      def dump_summary(duration, example_count, failure_count, pending_count)
-        all_challenges = examples.map { |e| e.metadata[:polytrix_challenge] }
-        grouped_challenges = all_challenges.compact.group_by(&:name)
-        @summary_files.each do |summary_file|
-          template_file = template_for summary_file, use_default: false
-          next if template_file.nil?
-          target_file = target_file_for_summary(template_file)
-          produce_doc template_file, target_file, 'Summary', grouped_challenges
-        end
-      end
-
-      private
-
-      def template_for(name, opts = { use_default: true })
-        name = name.description if name.respond_to? :description
-        begin
-          find_file @templates_dir, name, ''
-        rescue Polytrix::Core::FileSystemHelper::FileNotFound
-          Polytrix.configuration.default_doc_template if opts[:use_default] == true
-        end
-      end
-
-      def target_file_for(example_group)
-        names = [@output_dir].concat(example_group.parent_groups.reverse.map(&:description))
-        # Markdown format by default, but will be overridden to match the template
-        slugify(names.join File::SEPARATOR) + '.md'
-      end
-
-      def target_file_for_summary(template_file)
-        name = File.basename(template_file)
-        slugify("docs/#{name}")
-      end
-
-      def produce_doc(template_file, target_file, scenario, data)
-        doc_gen = Polytrix::DocumentationGenerator.new template_file, scenario
-        doc_gen.process data
-        doc_gen.save target_file
-      end
-    end
-  end
-end

data/lib/polytrix/rspec/yaml_report.rb

@@ -1,51 +0,0 @@
-require 'polytrix/rspec'
-require 'hashie/mash'
-require 'yaml'
-require 'fileutils'
-
-module Polytrix
-  module RSpec
-    class YAMLReport < ::RSpec::Core::Formatters::BaseFormatter
-      def example_passed(example)
-        add_implementation_result example, :passed
-      end
-
-      def example_failed(example)
-        add_implementation_result example, :failed
-      end
-
-      def example_pending(example)
-        add_implementation_result example, :pending
-      end
-
-      def dump_summary(duration, example_count, failure_count, pending_count)
-        results = Hashie::Mash.new(Polytrix.manifest.dup.to_hash)
-        all_challenges = examples.map { |e| e.metadata[:polytrix_challenge] }
-        grouped_challenges = all_challenges.compact.group_by(&:name)
-        results.suites.each do |suite_name, suite|
-          suite.samples = suite.samples.each_with_object({}) do |sample_name, sample_results|
-            sample_results[sample_name] ||= {}
-            if grouped_challenges[sample_name]
-              challenge_results = grouped_challenges[sample_name]
-              challenge_results.each do |challenge|
-                sample_results[sample_name][challenge.implementor.name] = challenge.result
-              end
-            end
-          end
-        end
-        @output.puts YAML.dump(results.to_hash)
-      end
-
-      private
-
-      def add_implementation_result(example, state)
-        validation = Validation.new(
-          validated_by: 'polytrix',
-          result: state.to_s
-        )
-        challenge = example.metadata[:polytrix_challenge]
-        challenge.result.validations << validation unless challenge.nil? || challenge.result.nil?
-      end
-    end
-  end
-end

data/lib/polytrix/rspec.rb

@@ -1,56 +0,0 @@
-require 'polytrix'
-begin
-  require 'rspec/core'
-  require 'rspec/expectations'
-  require 'rspec/core/formatters/base_text_formatter'
-rescue LoadError
-  raise 'polytrix/rspec requires rspec 2 or later'
-end
-
-module Polytrix
-  module RSpec
-    class << self
-      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|
-            describe suite_name do
-              samples = suite_config.samples || []
-              samples.each do |scenario|
-                describe scenario.name do
-                  Polytrix.implementors.each do |sdk|
-                    it sdk.name, sdk.name.to_sym => true do | example |
-                      begin
-                        skip "#{sdk.name} is not setup" unless File.directory? sdk.basedir
-                        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.exec
-                        validators = Polytrix::ValidatorRegistry.validators_for challenge
-                        validators.each do |validator|
-                          instance_exec challenge, &validator.callback
-                        end
-                      rescue Polytrix::FeatureNotImplementedError => e
-                        skip e.message
-                      rescue ThreadError => e
-                        # Extra debug info for ThreadError
-                        $stderr.puts "ThreadError detected: #{e.message}"
-                        $stderr.puts "ThreadError backtrace: #{e.backtrace}"
-                        fail e
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def run_manifest(manifest)
-        shared_examples(self)
-      end
-    end
-  end
-end

data/lib/polytrix/runners/executor.rb

@@ -1,34 +0,0 @@
-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
-      attr_accessor :env
-
-      def executor
-        @executor ||= if RUBY_PLATFORM == 'java'
-                        Polytrix::Runners::BuffShellOutExecutor.new
-                      else
-                        Polytrix::Runners::MixlibShellOutExecutor.new
-                      end
-      end
-
-      def execute(command, opts = {})
-        opts[:env] = env unless env.nil?
-        executor.execute(command, opts)
-      end
-    end
-  end
-end

data/lib/polytrix/runners/linux_challenge_runner.rb

@@ -1,23 +0,0 @@
-module Polytrix
-  module Runners
-    class LinuxChallengeRunner < ChallengeRunner
-      def script_extension
-        'sh'
-      end
-
-      def challenge_command(env_file, challenge_script)
-        challenge_script = "./#{challenge_script}" unless challenge_script.to_s.start_with? '/'
-        if File.exist? 'scripts/wrapper'
-          # ". #{env_file} && scripts/wrapper #{challenge_script}"
-          "scripts/wrapper #{challenge_script}"
-        else
-          "#{challenge_script}"
-        end
-      end
-
-      def save_environment_variable(key, value)
-        "export #{key}=\"#{value}\""
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Polytrix
-  module Runners
-    module Middleware
-      class ChangeDirectory
-        def initialize(app)
-          @app   = app
-        end
-
-        def call(env)
-          sdk_dir = env[:basedir]
-          Bundler.with_clean_env do
-            Dir.chdir sdk_dir do
-              @app.call env
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Polytrix
-  module Runners
-    module Middleware
-      class FeatureExecutor
-        include Polytrix::Core::FileSystemHelper
-        def initialize(app)
-          @app   = app
-        end
-
-        def call(env)
-          challenge_runner = env[:challenge_runner]
-          env_file = env[:env_file]
-          source_file = env[:source_file]
-          relative_source_file = relativize(source_file, env[:basedir])
-          command = challenge_runner.challenge_command(env_file, relative_source_file)
-          execution_result = challenge_runner.run_command command
-          env[:result] = Result.new(execution_result: execution_result, source_file: env[:source_file].to_s)
-          @app.call env
-          env[:result]
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'fileutils'
-
-module Polytrix
-  module Runners
-    module Middleware
-      class SetupEnvVars
-        include Polytrix::Core::FileSystemHelper
-
-        def initialize(app)
-          @app   = app
-        end
-
-        def call(env)
-          vars = begin
-            Polytrix.manifest[:global_env].dup
-          rescue
-            {}
-          end
-          vars = vars.merge env[:vars].dup
-
-          setup_env_vars(env[:name], vars, env[:challenge_runner])
-          # env[:env_file] = setup_env_vars(env[:name], vars, env[:challenge_runner])
-          @app.call env
-        end
-
-        private
-
-        def setup_env_vars(challenge_name, vars, challenge_runner)
-          challenge_runner.env = vars.to_hash
-          # FileUtils.mkdir_p 'tmp'
-          # 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
-          # file.close
-          # file.path
-        end
-      end
-    end
-  end
-end

data/lib/polytrix/runners/mixlib_shellout_executor.rb

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

data/lib/polytrix/validations.rb

@@ -1,23 +0,0 @@
-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/samples/scripts/wrapper

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

data/spec/polytrix/middleware/feature_executor_spec.rb

@@ -1,48 +0,0 @@
-module Polytrix
-  module Runners
-    module Middleware
-      describe FeatureExecutor do
-        let(:app) { double('Middleware Chain') }
-        let(:challenge_runner) { double('ChallengeRunner') }
-        subject(:middleware) { described_class.new app }
-
-        describe '#call' do
-          let(:env) do
-            {
-              basedir: Pathname.new('spec/fixtures'),
-              env_file: 'tmp/vars.sh',
-              source_file: Pathname.new('spec/fixtures/test.js'),
-              command: 'some command to execute',
-              challenge_runner: challenge_runner
-            }
-          end
-
-          before do
-            allow(challenge_runner).to receive(:challenge_command).with(env[:env_file], Pathname.new('test.js')).and_return('some command to execute')
-            allow(challenge_runner).to receive(:run_command).with('some command to execute').and_return Polytrix::Result.new(execution_result: 'a', source_file: 'b')
-            allow(app).to receive(:call).with(env)
-          end
-
-          # Most of this belongs in the ChallengeRunner...
-          xit 'finds the challenge' do
-          end
-
-          xit 'setups the env vars' do
-          end
-
-          xit 'gets the command' do
-          end
-
-          it 'returns a result' do
-            expect(middleware.call(env)).to be_an_instance_of Polytrix::Result
-          end
-
-          it 'continues the middleware chain' do
-            expect(app).to receive(:call).with env
-            middleware.call(env)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/polytrix/validations_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-module Polytrix
-  describe Validations do
-    describe '#coerce' do
-      it 'accepts an array when built via Result' do
-        Polytrix::Result.new(
-          validations: [
-            { validated_by: 'max', result: 'passed' },
-            { validated_by: 'polytrix', result: 'skipped' }
-          ]
-        )
-      end
-    end
-  end
-end