omnitest-psychic 0.0.9

data/lib/omnitest/psychic/cli.rb

@@ -0,0 +1,171 @@
+require 'omnitest/core'
+require 'omnitest/psychic'
+
+# rubocop:disable Metrics/LineLength
+
+module Omnitest
+  class Psychic
+    class BaseCLI < Omnitest::Core::CLI
+      include Thor::Actions
+
+      no_commands do
+        def psychic
+          @psychic ||= setup_runner
+        end
+
+        def setup_runner
+          runner_opts = { cwd: Dir.pwd, cli: shell, parameters: options.parameters }
+          runner_opts.merge!(Omnitest::Core::Util.symbolized_hash(options))
+          Omnitest::Psychic.new(runner_opts)
+        end
+      end
+    end
+
+    class List < BaseCLI
+      desc 'scripts', 'Lists known scripts'
+      method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+      method_option :cwd, desc: 'Working directory for detecting and running commands'
+      def scripts
+        scripts = psychic.known_scripts.map do |script|
+          [set_color(script.name, :bold), script.source_file]
+        end
+        print_table scripts
+      end
+
+      desc 'tasks', 'List known tasks'
+      method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+      method_option :cwd, desc: 'Working directory for detecting and running commands'
+      def tasks # rubocop:disable Metrics/AbcSize
+        psychic.known_tasks.map do |task|
+          task_id = set_color(task, :bold)
+          if options[:verbose]
+            details = psychic.task(task)
+            details = "\n#{details}".lines.join('  ') if details.lines.size > 1
+            say "#{task_id}: #{details}"
+          else
+            say task_id
+          end
+        end
+      end
+    end
+
+    class Show < BaseCLI
+      desc 'script <name>', 'Show detailed information about a script'
+      method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+      method_option :cwd, desc: 'Working directory for detecting and running commands'
+      def script(script_name)
+        script = psychic.script(script_name)
+        say script.to_s(options[:verbose])
+      end
+    end
+
+    class CLI < BaseCLI
+      BUILT_IN_TASKS = %w(bootstrap unittest acceptancetest)
+
+      desc 'task <name>', 'Executes any task by name'
+      method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+      method_option :cwd, desc: 'Working directory for detecting and running commands'
+      method_option :os, desc: "Target OS (default value is `RbConfig::CONFIG['host_os']`)"
+      method_option :travis, type: :boolean, desc: "Enable/disable delegation to travis-build, if it's available"
+      method_option :print, aliases: '-p', desc: 'Print the command (or script) instead of running it'
+      def task(task_alias = nil) # rubocop:disable Metrics/AbcSize
+        abort 'You must specify a task name, run `psychic list tasks` for a list of known tasks' unless task_alias
+        command = psychic.task(task_alias)
+        if options[:print]
+          say command
+        else
+          psychic.execute(command, *extra_args)
+        end
+      rescue TaskNotImplementedError => e
+        abort "No usable command was found for task #{task_alias}"
+      rescue Omnitest::Shell::ExecutionError => e
+        say_status :failed, task_alias, :red
+        say e.execution_result if e.execution_result
+      end
+
+      BUILT_IN_TASKS.each do |task_alias|
+        desc task_alias, "Executes the #{task_alias} task"
+        method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+        method_option :cwd, desc: 'Working directory for detecting and running commands'
+        define_method(task_alias) do
+          task(task_alias)
+        end
+      end
+
+      desc 'script <name>', 'Executes a script'
+      method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+      method_option :cwd, desc: 'Working directory for detecting and running commands'
+      method_option :interactive, desc: 'Prompt for parameters?', enum: %w(always missing), lazy_default: 'missing'
+      method_option :parameters, desc: 'YAML file containing key/value parameters. Default: psychic-parameters.yaml'
+      method_option :parameter_mode, desc: 'How should the parameters be passed?', enum: %w(tokens arguments env)
+      method_option :os, desc: "Target OS (default value is `RbConfig::CONFIG['host_os']`)"
+      method_option :print, aliases: '-p', desc: 'Print the command (or script) instead of running it', lazy_default: true
+      def script(script_name = nil) # rubocop:disable Metrics/AbcSize
+        abort 'You must specify a script name, run `psychic list scripts` for a list of known scripts' unless script_name
+        command = psychic.script(script_name, *extra_args)
+        if options[:print]
+          say command.command(*extra_args) << "\n"
+        else
+          command.execute(*extra_args)
+        end
+      rescue ScriptNotRunnable => e
+        abort "No usable command was found for script #{script_name}"
+      rescue Omnitest::Shell::ExecutionError => e
+        say_status :failed, script_name, :red
+        say e.execution_result if e.execution_result
+      end
+
+      desc 'workflow [*tasks]', 'Executes multiple tasks together as a single workflow'
+      method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+      method_option :cwd, desc: 'Working directory for detecting and running commands'
+      method_option :os, desc: "Target OS (default value is `RbConfig::CONFIG['host_os']`)"
+      method_option :travis, type: :boolean, desc: "Enable/disable delegation to travis-build, if it's available"
+      method_option :print, aliases: '-p', desc: 'Print the command (or script) instead of running it'
+      method_option :name, desc: 'A display name for the workflow'
+      def workflow(*tasks)
+        abort 'Please specify at least one task' if tasks.empty?
+        workflow = psychic.workflow(options[:name], options) do
+          tasks.each do | task_alias |
+            begin
+              task task_alias
+            rescue TaskNotImplementedError => e
+              abort "No usable command was found for task #{task_alias}"
+            end
+          end
+        end
+        if options[:print]
+          say workflow.command
+        else
+          workflow.execute({}, {}, *extra_args)
+        end
+      rescue Omnitest::Shell::ExecutionError => e
+        say_status :failed, options[:name], :red
+        say e.execution_result if e.execution_result
+      end
+
+      desc 'code2doc', 'Convert script to lightweight markup'
+      method_option :format,
+                    enum: %w(md rst),
+                    default: 'md',
+                    desc: 'Target documentation format'
+      method_option :destination,
+                    aliases: '-d',
+                    default: 'docs/',
+                    desc: 'The target directory where documentation for generated documentation.'
+      def code2doc(*script_names)
+        script_names.each do | script_name |
+          script = psychic.script(script_name)
+          target_file = File.expand_path(script.name + ".#{options[:format]}", options[:destination])
+          create_file(target_file, script.code2doc(options))
+        end
+      end
+
+      desc 'list', 'List known tasks or scripts'
+      subcommand 'list', List
+      desc 'show', 'Show details about a task or script'
+      subcommand 'show', Show
+    end
+  end
+end
+
+# rubocop:enable Metrics/LineLength

data/lib/omnitest/psychic/code2doc.rb

@@ -0,0 +1,75 @@
+require 'omnitest/psychic/code2doc/code_helper'
+
+module Omnitest
+  class Psychic
+    module Code2Doc
+      module SnippetHelper
+        include CodeHelper
+
+        def file_snippet(file_name, opts = {})
+          file = expand_file(file_name)
+          snippet_opts = {
+            language: (opts[:language] || detect_language(file))
+          }.merge(opts)
+          content = file_content(file_name, snippet_opts)
+          snippetize(content, snippet_opts)
+        end
+
+        def exec_snippet(command, opts = {})
+          cwd = opts.delete(:cwd) || '.'
+          psychic = Omnitest::Psychic.new(cwd: cwd)
+          result = psychic.execute(command)
+          snippetize_output(result, opts)
+        end
+
+        def snippetize_output(result, opts)
+          include_command = (opts.key?(:include_command) ? opts.delete(:include_command) : true)
+          snippet = include_command ? "$ #{result.command}\n" : ''
+          snippet << result.stdout
+          snippetize(snippet, opts)
+        end
+
+        def snippetize(str, opts)
+          language = opts.delete(:language)
+          snippet_opts = {
+            format: (opts[:format] || :markdown)
+          }.merge(opts)
+          code_block(str, language, snippet_opts).rstrip
+        end
+
+        private
+
+        def file_content(file_name, opts = {})
+          file = expand_file(file_name)
+          content = file.read
+          after_pattern, before_pattern = [opts[:after], opts[:before]].map do | pattern |
+            case pattern
+            when nil
+              nil
+            when Regexp
+              pattern.source
+            else
+              Regexp.quote(pattern.to_s)
+            end
+          end
+          content = content.gsub(/\A.*#{after_pattern}\s*^(.*)\Z/m, '\1') if after_pattern
+          content = content.gsub(/\A(.*)#{before_pattern}.*\Z/m, '\1') if before_pattern
+          content.rstrip
+        end
+
+        def detect_language(file)
+          file = Pathname(file)
+          language, _comment_style = Code2Doc::CommentStyles.infer file.extname
+          language
+        rescue CommentStyles::UnknownStyleError
+          nil
+        end
+
+        def expand_file(file_name)
+          file = Pathname(file_name)
+          file.expand_path(Omnitest.basedir) unless file.absolute?
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/code2doc/code_helper.rb

@@ -0,0 +1,122 @@
+require 'omnitest/psychic/code2doc/code_segmenter'
+require 'rouge'
+
+module Omnitest
+  class Psychic
+    module Code2Doc
+      module CodeHelper
+        class ReStructuredTextHelper
+          def self.code_block(source, language)
+            buffer = StringIO.new
+            buffer.puts ".. code-block:: #{language}"
+            indented_source = source.lines.map do|line|
+              "  #{line}"
+            end.join("\n")
+            buffer.puts indented_source
+            buffer.string
+          end
+        end
+        class MarkdownHelper
+          def self.code_block(source, language)
+            buffer = StringIO.new
+            buffer.puts "```#{language}"
+            buffer.puts source
+            buffer.puts '```'
+            buffer.string
+          end
+        end
+
+        def source
+          File.read absolute_source_file
+        end
+
+        def source?
+          !absolute_source_file.nil?
+        end
+
+        def highlighted_code(formatter = 'terminal256')
+          language, _comment_style = Code2Doc::CommentStyles.infer source_file.extname
+          highlight(source, language: language, filename: absolute_source_file, formatter: formatter)
+        end
+
+        def code_block(source_code, language, opts = { format: :markdown })
+          case opts[:format].to_sym
+          when :rst
+            ReStructuredTextHelper.code_block source_code, language
+          when :md, :markdown
+            MarkdownHelper.code_block source_code, language
+          when :raw
+            source_code
+          else
+            fail ArgumentError, "Unknown format: #{opts[:format]}"
+          end
+        end
+
+        # Loses proper indentation on comments
+        def snippet_after(matcher)
+          segments = segmenter.segment(source)
+          buffer = StringIO.new
+          segment = segments.find do |s|
+            doc_segment_content = s.first.join
+            doc_segment_content.match matcher
+          end
+          buffer.print segment[1].join "\n" if segment # return code segment
+          buffer.string
+        end
+
+        def snippet_between(before_matcher, after_matcher)
+          segments = segmenter.segment(source)
+          start_segment = find_segment_index segments, before_matcher
+          end_segment   = find_segment_index segments, after_matcher
+          buffer = StringIO.new
+          if start_segment && end_segment
+            segments[start_segment...end_segment].each do |segment|
+              buffer.puts @segmenter.comment(segment[0]) unless segment == segments[start_segment]
+              buffer.puts segment[1].join
+            end
+          end
+          buffer.string
+        end
+
+        def code2doc(options = { format: :markdown })
+          source_code = File.read(absolute_source_file)
+          segmenter_language = infer_language(source_file)
+
+          buffer = StringIO.new
+          segmenter_options = {
+            language: segmenter_language
+          }
+          segmenter = Omnitest::Psychic::Code2Doc::CodeSegmenter.new(segmenter_options)
+          segments = segmenter.segment source_code
+          segments.each do |comment, code|
+            comment = comment.join("\n")
+            code = code.join("\n")
+            code = code_block(code, segmenter_language, options) unless code.empty?
+            next if comment.empty? && code.empty?
+            code = "\n#{code}\n" if !comment.empty? && !code.empty? # Markdown needs separation
+            buffer.puts [comment, code].join("\n")
+          end
+          buffer.string
+        end
+
+        def infer_language(file)
+          language, comment_style = Psychic::Code2Doc::CommentStyles.infer File.extname(file)
+          segmenter_language = comment_style[:language] || language
+        end
+
+        private
+
+        def segmenter
+          @segmenter ||= Code2Doc::CodeSegmenter.new
+        end
+
+        def find_segment_index(segments, matcher)
+          segments.find_index do |s|
+            doc_segment_content = s.first.join
+            doc_segment_content.match matcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/code2doc/code_segmenter.rb

@@ -0,0 +1,170 @@
+require 'omnitest/psychic/code2doc/comment_styles'
+
+module Omnitest
+  class Psychic
+    module Code2Doc
+      # This class was extracted from the [Rocco](http://rtomayko.github.com/rocco/) project
+      # which was in turn based on the [Docco](http://jashkenas.github.com/docco/).
+      class CodeSegmenter # rubocop:disable all
+        # Cops are disabled because the code is from Rocco
+        include CommentStyles
+
+        DEFAULT_OPTIONS = {
+          language: 'rb',
+          comment_chars: '#'
+        }
+
+        def initialize(options = {})
+          @options = DEFAULT_OPTIONS.merge options
+          @options[:comment_chars] = generate_comment_chars if @options[:comment_chars].is_a? String
+        end
+        # Internal Parsing and Highlighting
+        # ---------------------------------
+
+        # Parse the raw file source_code into a list of two-tuples. Each tuple has the
+        # form `[docs, code]` where both elements are arrays containing the
+        # raw lines parsed from the input file, comment characters stripped.
+        def segment(source_code) # rubocop:disable all
+          sections, docs, code = [], [], []
+          lines = source_code.split("\n")
+
+          # The first line is ignored if it is a shebang line.  We also ignore the
+          # PEP 263 encoding information in python sourcefiles, and the similar ruby
+          # 1.9 syntax.
+          lines.shift if lines[0] =~ /^\#\!/
+          lines.shift if lines[0] =~ /coding[:=]\s*[-\w.]+/ &&
+                         %w(python rb).include?(@options[:language])
+
+          # To detect both block comments and single-line comments, we'll set
+          # up a tiny state machine, and loop through each line of the file.
+          # This requires an `in_comment_block` boolean, and a few regular
+          # expressions for line tests.  We'll do the same for fake heredoc parsing.
+          in_comment_block = false
+          in_heredoc = false
+          single_line_comment, block_comment_start, block_comment_mid, block_comment_end =
+            nil, nil, nil, nil
+          unless @options[:comment_chars][:single].nil?
+            single_line_comment = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:single])}\\s?")
+          end
+          unless @options[:comment_chars][:multi].nil?
+            block_comment_start = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*$")
+            block_comment_end   = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$")
+            block_comment_one_liner = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*(.*?)\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$") # rubocop:disable Metrics/LineLength
+            block_comment_start_with = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:start])}\\s*(.*?)$")
+            block_comment_end_with = Regexp.new("\\s*(.*?)\\s*#{Regexp.escape(@options[:comment_chars][:multi][:end])}\\s*$")
+            if @options[:comment_chars][:multi][:middle]
+              block_comment_mid = Regexp.new("^\\s*#{Regexp.escape(@options[:comment_chars][:multi][:middle])}\\s?")
+            end
+          end
+          unless @options[:comment_chars][:heredoc].nil?
+            heredoc_start = Regexp.new("#{Regexp.escape(@options[:comment_chars][:heredoc])}(\\S+)$")
+          end
+          lines.each do |line|
+            # If we're currently in a comment block, check whether the line matches
+            # the _end_ of a comment block or the _end_ of a comment block with a
+            # comment.
+            if in_comment_block
+              if block_comment_end && line.match(block_comment_end)
+                in_comment_block = false
+              elsif block_comment_end_with && line.match(block_comment_end_with)
+                in_comment_block = false
+                docs << line.match(block_comment_end_with).captures.first
+                  .sub(block_comment_mid || '', '')
+              else
+                docs << line.sub(block_comment_mid || '', '')
+              end
+            # If we're currently in a heredoc, we're looking for the end of the
+            # heredoc, and everything it contains is code.
+            elsif in_heredoc
+              if line.match(Regexp.new("^#{Regexp.escape(in_heredoc)}$"))
+                in_heredoc = false
+              end
+              code << line
+            # Otherwise, check whether the line starts a heredoc. If so, note the end
+            # pattern, and the line is code.  Otherwise check whether the line matches
+            # the beginning of a block, or a single-line comment all on it's lonesome.
+            # In either case, if there's code, start a new section.
+            else
+              if heredoc_start && line.match(heredoc_start)
+                in_heredoc = Regexp.last_match[1]
+                code << line
+              elsif block_comment_one_liner && line.match(block_comment_one_liner)
+                if code.any?
+                  sections << [docs, code]
+                  docs, code = [], []
+                end
+                docs << line.match(block_comment_one_liner).captures.first
+              elsif block_comment_start && line.match(block_comment_start)
+                in_comment_block = true
+                if code.any?
+                  sections << [docs, code]
+                  docs, code = [], []
+                end
+              elsif block_comment_start_with && line.match(block_comment_start_with)
+                in_comment_block = true
+                if code.any?
+                  sections << [docs, code]
+                  docs, code = [], []
+                end
+                docs << line.match(block_comment_start_with).captures.first
+              elsif single_line_comment && line.match(single_line_comment)
+                if code.any?
+                  sections << [docs, code]
+                  docs, code = [], []
+                end
+                docs << line.sub(single_line_comment || '', '')
+              else
+                code << line
+              end
+            end
+          end
+          sections << [docs, code] if docs.any? || code.any?
+          normalize_leading_spaces(sections)
+        end
+
+        # Normalizes documentation whitespace by checking for leading whitespace,
+        # removing it, and then removing the same amount of whitespace from each
+        # succeeding line.  That is:
+        #
+        #     def func():
+        #       """
+        #         Comment 1
+        #         Comment 2
+        #       """
+        #       print "omg!"
+        #
+        # should yield a comment block of `Comment 1\nComment 2` and code of
+        # `def func():\n  print "omg!"`
+        def normalize_leading_spaces(sections)
+          sections.map do |section|
+            if section.any? && section[0].any?
+              leading_space = section[0][0].match("^\s+")
+              if leading_space
+                section[0] =
+                  section[0].map { |line| line.sub(/^#{leading_space.to_s}/, '') }
+              end
+            end
+            section
+          end
+        end
+
+        def comment(lines)
+          lines.map do | line |
+            "#{@options[:comment_chars][:single]} #{line}"
+          end.join "\n"
+        end
+
+        private
+
+        def generate_comment_chars
+          @_commentchar ||=
+            if COMMENT_STYLES[@options[:language]]
+              COMMENT_STYLES[@options[:language]]
+            else
+              { single: @options[:comment_chars], multi: nil, heredoc: nil }
+            end
+        end
+      end # rubocop:enable all
+    end
+  end
+end