polytrix 0.1.2 → 0.1.3

data/lib/polytrix/command/list.rb

@@ -1,52 +1,63 @@
+require 'polytrix/reporters'
 module Polytrix
   module Command
     class List < Polytrix::Command::Base
-      def call
-        # Logging.mdc['command'] = 'list'
+      include Polytrix::Reporters
 
+      def call
         setup
-        tests = parse_subcommand(args.first)
-
-        table = [
-          [
-            colorize('Suite', :green), colorize('Scenario', :green),
-            colorize('Implementor', :green), colorize('Status', :green)
-          ]
-        ]
+        @reporter = Polytrix::Reporters.reporter(options[:format], shell)
+        tests = parse_subcommand(args.pop)
+
+        table = [header_row]
         table += tests.map do | challenge |
-          [
-            color_pad(challenge.suite),
-            color_pad(challenge.name),
-            color_pad(challenge.implementor.name),
-            format_last_action(challenge)
-          ]
+          row(challenge)
         end
-        shell.print_table table
+        print_table(table)
       end
 
       private
 
+      def header_row
+        row = []
+        row << colorize('Test ID', :green)
+        row << colorize('Suite', :green)
+        row << colorize('Scenario', :green)
+        row << colorize('Implementor', :green)
+        row << colorize('Status', :green)
+        row << colorize('Source', :green) if options[:source]
+        row
+      end
+
+      def row(challenge)
+        row = []
+        row << color_pad(challenge.slug)
+        row << color_pad(challenge.suite)
+        row << color_pad(challenge.name)
+        row << color_pad(challenge.implementor.name)
+        row << format_status(challenge)
+        if options[:source]
+          source_file = challenge.absolute_source_file ? relativize(challenge.absolute_source_file, Dir.pwd) : colorize('<No code sample>', :red)
+          row << source_file
+        end
+        row
+      end
+
       def print_table(*args)
-        shell.print_table(*args)
+        @reporter.print_table(*args)
       end
 
       def colorize(string, *args)
-        shell.set_color(string, *args)
+        return string unless @reporter.respond_to? :set_color
+        @reporter.set_color(string, *args)
       end
 
       def color_pad(string)
         string + colorize('', :white)
       end
 
-      def format_last_action(challenge)
-        case challenge.last_action
-        when 'clone' then colorize('Cloned', :cyan)
-        when 'bootstrap' then colorize('Bootstrapped', :magenta)
-        when 'exec' then colorize('Executed', :blue)
-        when 'verify' then colorize("Verified (x#{challenge.validations.count})", :yellow)
-        when nil then colorize('<Not Found>', :red)
-        else colorize("<Unknown (#{challenge.last_action})>", :white)
-        end
+      def format_status(challenge)
+        colorize(challenge.status_description, challenge.status_color)
       end
     end
   end

data/lib/polytrix/command/report.rb

@@ -1,94 +1,17 @@
 module Polytrix
-  module Reports
-    # autoload :TextReporter, 'polytrix/cli/reports/text_reporter'
-    autoload :MarkdownReporter, 'polytrix/cli/reports/markdown_reporter'
-    # autoload :HTMLReporter, 'polytrix/cli/reports/html_reporter'
-    autoload :JSONReporter, 'polytrix/cli/reports/json_reporter'
-    autoload :YAMLReporter, 'polytrix/cli/reports/yaml_reporter'
-  end
   module Command
-    class Report < Polytrix::Command::Base
-      def call
-        fail StandardError, 'Report command not yet implemented - work in progress'
-        # setup
-        # @tests = parse_subcommand(args.first)
-        # tests_by_implementor = @tests.group_by(&:implementor)
-
-        # table = [
-        #   [
-        #     colorize('SDK', :green), colorize('Passed', :green),
-        #     colorize('Failed', :red), colorize('Pending', :yellow),
-        #     colorize('Skipped', :cyan)
-        #   ]
-        # ]
-        # load_results.each do |sdk, sdk_summary|
-        #   table << [sdk, sdk_summary[:passed], sdk_summary[:failed], sdk_summary[:pending], sdk_summary[:skipped]]
-        # end
-        # shell.print_table table
-      end
-
-      private
-
-      def count(results, state)
-        results.count do |r|
-          result.last_action.to_s == state.to_s
-        end
-      end
-
-      def load_results
-        result_stats = Hash.new do |hash, sdk|
-          hash[sdk] = { passed: 0, failed: 0, pending: 0, skipped: 0 }
-        end
-        Polytrix.manifest.suites.reduce(result_stats) do |hash, (suite_name, suite)|
-          suite.samples.each do |sample, suite_results|
-            Polytrix.implementors.map(&:name).each do |sdk|
-              result = Result.new(suite_results[sdk])
-              result.validations << Validation.new(validated_by: 'polytrix', result: 'skipped')
-              hash[sdk][result.status.to_sym] += 1
-            end
-          end
-          hash
-        end
-        result_stats
-      end
-
-      def reporter
-        @reporter ||= case options[:format]
-                      when 'text'
-                        self
-                      when 'markdown'
-                        Polytrix::CLI::Reports::MarkdownReporter.new
-                      when 'json'
-                        Polytrix::CLI::Reports::JSONReporter.new
-                      when 'yaml'
-                        Polytrix::CLI::Reports::YAMLReporter.new
-                      else
-                        fail "Unknown report format #{options[:format]}"
-                      end
-      end
-
-      def print_table(*args)
-        shell.print_table(*args)
-      end
+    class Report < Thor
+      namespace :report
 
-      def colorize(string, *args)
-        shell.set_color(string, *args)
-      end
+      autoload :Dashboard, 'polytrix/command/reports/dashboard'
+      register Dashboard, 'dashboard', 'dashboard', 'Create a report dashboard'
+      tasks['dashboard'].options = Dashboard.class_options
 
-      def color_pad(string)
-        string + colorize('', :white)
-      end
+      autoload :Code2Doc, 'polytrix/command/reports/code2doc'
+      register Code2Doc, 'code2doc', 'code2doc [INSTANCE|REGEXP|all]', 'Generates documenation from sample code for one or more scenarios'
+      tasks['code2doc'].options = Code2Doc.class_options
 
-      def format_last_action(challenge)
-        case challenge.last_action
-        when 'clone' then colorize('Cloned', :cyan)
-        when 'bootstrap' then colorize('Bootstrapped', :magenta)
-        when 'exec' then colorize('Executed', :blue)
-        when 'verify' then colorize("Verified (Level #{challenge.verification_level})", :yellow)
-        when nil then colorize('<Not Found>', :red)
-        else colorize("<Unknown (#{challenge.last_action})>", :white)
-        end
-      end
+      # FIXME: Help shows unwanted usage, e.g. "polytrix polytrix:command:report:code2_doc"
     end
   end
 end

data/lib/polytrix/command/reports/code2doc.rb

@@ -0,0 +1,72 @@
+require 'json'
+require 'polytrix/reporters'
+
+module Polytrix
+  module Command
+    class Report
+      class Code2Doc < Thor::Group
+        include Polytrix::DefaultLogger
+        include Polytrix::Logging
+        include Thor::Actions
+        include Polytrix::Util::FileSystem
+
+        class_option :log_level,
+                     aliases: '-l',
+                     desc: 'Set the log level (debug, info, warn, error, fatal)'
+        class_option :manifest,
+                     aliases: '-m',
+                     desc: 'The Polytrix test manifest file location',
+                     default: 'polytrix.yml'
+        class_option :solo,
+                     desc: 'Enable solo mode - Polytrix will auto-configure a single implementor and its scenarios'
+        # , default: 'polytrix.yml'
+        class_option :solo_glob,
+                     desc: 'The globbing pattern to find code samples in solo mode'
+        class_option :format,
+                     aliases: '-f',
+                     enum: %w(md rst),
+                     default: 'md',
+                     desc: 'Target documentation format'
+        class_option :target_dir,
+                     aliases: '-d',
+                     default: 'docs/',
+                     desc: 'The target directory where documentation for generated documentation.'
+
+        class_option :destination, default: 'docs/'
+
+        def setup
+          # HACK: Need to make Command setup/parse_subcommand easily re-usable in Thor::Group actions
+          command_options = {
+            shell: shell
+          }.merge(options)
+          command = Polytrix::Command::Base.new(args, options, command_options)
+          command.send(:setup)
+          @scenarios = command.send(:parse_subcommand, args.pop)
+        end
+
+        def set_destination_root
+          self.destination_root = options[:destination]
+        end
+
+        def code2doc
+          @scenarios.each do | scenario |
+            source_file = scenario.source_file
+            if source_file.nil?
+              warn "No code sample available for #{scenario.slug}, no documentation will be generated."
+              next
+            end
+
+            target_file_name = scenario.slug + ".#{options[:format]}"
+
+            begin
+              doc = Polytrix::DocumentationGenerator.new.code2doc(scenario.absolute_source_file)
+              create_file(target_file_name, doc)
+            rescue Polytrix::Documentation::CommentStyles::UnknownStyleError
+              warn "Could not generated documentation for #{source_file}, because the language couldn't be detected."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/polytrix/command/reports/dashboard.rb

@@ -0,0 +1,125 @@
+require 'json'
+require 'polytrix/reporters'
+
+module Polytrix
+  module Command
+    class Report
+      class Dashboard < Thor::Group
+        include Thor::Actions
+        include Polytrix::Util::FileSystem
+        module Helpers
+          include Polytrix::Util::String
+          include Padrino::Helpers::TagHelpers
+          include Padrino::Helpers::OutputHelpers
+          include Padrino::Helpers::AssetTagHelpers
+
+          def implementors
+            Polytrix.implementors.map do |implementor|
+              slugify(implementor.name)
+            end
+          end
+
+          def results
+            manifest = Polytrix.manifest
+            rows = []
+            grouped_challenges = manifest.challenges.values.group_by { |challenge| [challenge.suite, challenge.name] }
+            grouped_challenges.each do |(suite, name), challenges|
+              row = {
+                slug_prefix: slugify(suite, name),
+                suite: suite,
+                scenario: name
+              }
+              Polytrix.implementors.each do |implementor|
+                challenge = challenges.find { |c| c.implementor == implementor }
+                row[slugify(implementor.name)] = challenge.status_description
+              end
+              rows << row
+            end
+            rows
+          end
+
+          def as_json(table)
+            JSON.dump(table)
+          end
+
+          def status(status, msg = nil, _color = :cyan)
+            "<strong>#{status}</strong> <em>#{msg}</em>"
+          end
+
+          def bootstrap_color(color)
+            bootstrap_classes = {
+              green: 'success',
+              cyan: 'primary',
+              red: 'danger',
+              yellow: 'warning'
+            }
+            bootstrap_classes.key?(color) ? bootstrap_classes[color] : color
+          end
+        end
+
+        include Helpers
+
+        class_option :destination, default: 'reports/'
+        class_option :code_style, default: 'github'
+
+        def self.source_root
+          Polytrix::Reporters::TEMPLATE_DIR
+        end
+
+        def report_name
+          @report_name ||= self.class.name.downcase.split('::').last
+        end
+
+        def add_framework_to_source_root
+          source_paths.map do | path |
+            path << "/#{report_name}"
+          end
+        end
+
+        def set_destination_root
+          self.destination_root = options[:destination]
+        end
+
+        # def load_helpers
+        #   framework_root = source_paths.first
+        #   Dir["#{report_name}/helpers/**/*.rb"].each do |helper|
+        #     load helper
+        #   end
+        # end
+
+        def setup
+          Polytrix.manifest.build_challenges
+          test_dir = 'tests/polytrix' # @test_dir.nil? ? nil : File.expand_path(@test_dir)
+          return nil unless test_dir && File.directory?(test_dir)
+
+          $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
+
+        def copy_assets
+          directory Polytrix::Reporters::ASSETS_DIR, 'assets'
+        end
+
+        def copy_base_structure
+          directory 'files', '.'
+        end
+
+        def create_test_reports
+          Polytrix.manifest.challenges.values.each do |challenge|
+            @challenge = challenge
+            template 'templates/_test_report.html.tt', "details/#{challenge.slug}.html"
+          end
+        end
+
+        def create_spy_reports
+          reports = Polytrix::Spies.reports[:dashboard]
+          reports.each do | report_class |
+            invoke report_class, args, options
+          end if reports
+        end
+      end
+    end
+  end
+end

data/lib/polytrix/command/show.rb

@@ -0,0 +1,148 @@
+require 'polytrix/reporters'
+
+module Polytrix
+  module Command
+    class Show < Polytrix::Command::Base
+      include Polytrix::Reporters
+      include Polytrix::Util::String
+      include Polytrix::Util::FileSystem
+
+      def initialize(cmd_args, cmd_options, options = {})
+        @indent_level = 0
+        super
+      end
+
+      def call
+        setup
+        @reporter = Polytrix::Reporters.reporter(options[:format], shell)
+        challenges = parse_subcommand(args.pop)
+
+        challenges.each do | challenge |
+          status_color = challenge.status_color.to_sym
+          status(challenge.slug, colorize(challenge.status_description, status_color), status_color)
+          indent do
+            status('Test suite', challenge.suite)
+            status('Test scenario', challenge.name)
+            status('Implementor', challenge.implementor.name)
+            source_file = challenge.absolute_source_file ? relativize(challenge.absolute_source_file, Dir.pwd) : colorize('<No code sample>', :red)
+            status('Source', source_file)
+            display_source(challenge)
+            display_execution_result(challenge)
+            display_validations(challenge)
+            display_spy_data(challenge)
+          end
+        end
+      end
+
+      private
+
+      def reformat(string)
+        return if string.nil? || string.empty?
+
+        indent do
+          string.gsub(/^/, indent)
+        end
+      end
+
+      def indent
+        if block_given?
+          @indent_level += 2
+          result = yield
+          @indent_level -= 2
+          result
+        else
+          ' ' * @indent_level
+        end
+      end
+
+      def display_source(test)
+        return if !options[:source] || !test.source?
+
+        shell.say test.highlighted_code
+      end
+
+      def display_execution_result(test)
+        return if test.result.nil? || test.result.execution_result.nil?
+
+        execution_result = test.result.execution_result
+        status 'Execution result'
+        indent do
+          status('Exit Status', execution_result.exitstatus)
+          status 'Stdout'
+          say reformat(execution_result.stdout)
+          status 'Stderr'
+          say reformat(execution_result.stderr)
+        end
+      end
+
+      def display_validations(test)
+        return if test.validations.nil?
+
+        status 'Validations'
+        indent do
+          test.validations.each do | name, validation |
+            status(name, indicator(validation))
+            indent do
+              status 'Error message', validation.error if validation.error
+              unless !options[:source] || !validation.error_source?
+                status 'Validator source'
+                say highlight(validation.error_source, language: 'ruby')
+              end
+            end
+          end
+        end
+      end
+
+      def display_spy_data(test)
+        return if test.spy_data.nil?
+
+        status 'Data from spies'
+        indent do
+          test.spy_data.each do |_spy, data|
+            indent do
+              data.each_pair do |k, v|
+                status(k, v)
+              end
+            end
+          end
+        end
+      end
+
+      def say(msg)
+        shell.say msg if msg
+      end
+
+      def status(status, msg = nil, color = :cyan, colwidth = 50)
+        msg = yield if block_given?
+        shell.say(indent)
+        status = shell.set_color("#{status}:", color, true)
+        # The built-in say_status is right-aligned, we want left-aligned
+        shell.say format("%-#{colwidth}s %s", status, msg).rstrip
+      end
+
+      def print_table(*args)
+        @reporter.print_table(*args)
+      end
+
+      def colorize(string, *args)
+        return string unless @reporter.respond_to? :set_color
+        @reporter.set_color(string, *args)
+      end
+
+      def color_pad(string)
+        string + colorize('', :white)
+      end
+
+      def indicator(validation)
+        case validation.result
+        when :passed
+          colorize('✓ Passed', :green)
+        when :failed
+          colorize('x Failed', :red)
+        else
+          colorize(validation.result, :yellow)
+        end
+      end
+    end
+  end
+end