omnitest-psychic 0.0.9

data/lib/omnitest/shell/buff_shellout_executor.rb

@@ -0,0 +1,41 @@
+require 'buff/shell_out'
+
+module Omnitest
+  module Shell
+    class BuffShellOutExecutor
+      include Omnitest::Core::Logger
+      attr_reader :shell
+
+      def execute(command, opts) # rubocop:disable Metrics/AbcSize
+        @logger = opts.delete(:logger) || logger
+        cwd = opts[:cwd] || Dir.pwd
+        env = opts[:env] || {}
+        # @shell.live_stream = IOToLog.new(@logger)
+        shell_result = Dir.chdir(cwd) do
+          Bundler.with_clean_env do
+            Buff::ShellOut.shell_out(command, env)
+          end
+        end
+        fail Errno::ENOENT, shell_result.stderr if shell_result.exitstatus == 127
+        execution_result(command, shell_result)
+      rescue SystemCallError => e
+        execution_error = ExecutionError.new(e)
+        execution_error.execution_result = execution_result(command, shell_result)
+        raise execution_error
+      end
+
+      private
+
+      def execution_result(command, shell_result)
+        return nil if shell_result.nil?
+
+        ExecutionResult.new(
+          command: command,
+          exitstatus: shell_result.exitstatus,
+          stdout: shell_result.stdout,
+          stderr: shell_result.stderr
+        )
+      end
+    end
+  end
+end

data/lib/omnitest/shell/execution_result.rb

@@ -0,0 +1,61 @@
+require 'English'
+
+module Omnitest
+  module Shell
+    class ExecutionError < StandardError
+      attr_accessor :execution_result
+    end
+
+    # Stores the result of running a command
+    class ExecutionResult
+      # @return [String] the command that was executed
+      attr_reader :command
+      # @return [Integer] the exit code of the process
+      attr_reader :exitstatus
+      # @return [String] the captured standard output
+      attr_reader :stdout
+      # @return [String] the captured standard error
+      attr_reader :stderr
+
+      include Omnitest::Core::Util::Hashable
+
+      # @api private
+      def initialize(results)
+        @command = results.fetch(:command)
+        @exitstatus = results.fetch(:exitstatus)
+        # Needs to be UTF-8 to serialize as YAML
+        # FIXME: But is serializing to YAML still necessary? Have been using PStore.
+        @stdout = results.fetch(:stdout).force_encoding('utf-8')
+        @stderr = results.fetch(:stderr).force_encoding('utf-8')
+      end
+
+      # @return [Boolean] true if the command succeeded (exit code 0)
+      def successful?
+        @exitstatus == 0
+      end
+
+      # Check if the command succeeded and raises and error if it did not.
+      # @raises [ExecutionError] if the command did not succeed
+      def error!
+        unless successful?
+          error = ExecutionError.new "#{command} returned exit code #{exitstatus}"
+          error.execution_result = self
+          fail error
+        end
+      end
+
+      # @return [String] a textual summary of the results
+      def to_s
+        ''"
+        Execution Result:
+          command: #{command}
+          exitstatus: #{exitstatus}
+          stdout:
+        #{stdout}
+          stderr:
+        #{stderr}
+        "''
+      end
+    end
+  end
+end

data/lib/omnitest/shell/mixlib_shellout_executor.rb

@@ -0,0 +1,66 @@
+require 'mixlib/shellout'
+
+module Omnitest
+  module Shell
+    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 Omnitest::Core::Logger
+      attr_reader :shell
+
+      MIXLIB_SHELLOUT_EXCEPTION_CLASSES = Mixlib::ShellOut.constants.map do|name|
+        klass = Mixlib::ShellOut.const_get(name)
+        if klass.is_a?(Class) && klass <= RuntimeError
+          klass
+        else
+          nil
+        end
+      end.compact
+
+      def execute(command, opts = {}) # rubocop:disable Metrics/AbcSize
+        opts[:cwd] = (opts[:cwd] || Dir.pwd).to_s
+        @logger = opts.delete(:logger) || logger
+        @shell = Mixlib::ShellOut.new(command, opts)
+        @shell.live_stream = IOToLog.new(@logger)
+        Bundler.with_clean_env do
+          @shell.run_command
+        end
+        execution_result
+      rescue SystemCallError, *MIXLIB_SHELLOUT_EXCEPTION_CLASSES, TypeError => e
+        # See https://github.com/opscode/mixlib-shellout/issues/62
+        execution_error = ExecutionError.new(e)
+        execution_error.execution_result = execution_result
+        raise execution_error
+      end
+
+      private
+
+      def execution_result
+        return nil if shell.nil?
+
+        ExecutionResult.new(
+          command: shell.command,
+          exitstatus: shell.exitstatus,
+          stdout: shell.stdout,
+          stderr: shell.stderr
+        )
+      end
+    end
+  end
+end

data/mkdocs.yml

@@ -0,0 +1,6 @@
+site_name: Omnitest::Psychic
+pages:
+- getting_started.md
+- running_tasks.md
+- running_scripts.md
+

data/omnitest-psychic.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'omnitest/psychic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'omnitest-psychic'
+  spec.version       = Omnitest::Psychic::VERSION
+  spec.authors       = ['Max Lincoln']
+  spec.email         = ['max@devopsy.com']
+  spec.summary       = 'Psychic runs anything.'
+  spec.description   = 'Provides cross-project aliases for running tasks or similar code samples.'
+  # spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'omnitest-core', '~> 0'
+  spec.add_dependency 'mixlib-shellout', '~> 1.3' # Used for MRI
+  spec.add_dependency 'buff-shell_out', '~> 0.2'  # Used for JRuby
+  spec.add_dependency 'mustache', '~> 0.99'
+  spec.add_dependency 'rouge', '~> 1.0'
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake-notes'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.18', '<= 0.27'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.2'
+  spec.add_development_dependency 'aruba'
+  spec.add_development_dependency 'fabrication'
+  spec.add_development_dependency 'inch'
+end

data/spec/fabricators/shell_fabricator.rb

@@ -0,0 +1,9 @@
+Fabricator(:execution_result, from: Omnitest::Shell::ExecutionResult) do
+  initialize_with do
+    @_klass.new @_transient_attributes
+  end # Hash based initialization
+  transient command: 'sample command'
+  transient exitstatus: 0
+  transient stdout: ''
+  transient stderr: ''
+end

data/spec/omnitest/psychic/code2doc/code_helper_spec.rb

@@ -0,0 +1,123 @@
+module Omnitest
+  class Psychic
+    module Code2Doc
+      RSpec.describe CodeHelper do
+        let(:psychic) { Psychic.new(cwd: current_dir) }
+        let(:script) do
+          Script.new(psychic, 'test', @source_file)
+        end
+        let(:source) do
+          <<-'eos'
+# This snippet should not be in the output.
+puts "Random: #{rand}"
+
+# Snippet: Hello, world!
+puts 'Hello, world!'
+
+# Nor should this snippet
+puts 'Done'
+eos
+        end
+        let(:expected_snippet) do
+          <<-'eos'
+puts 'Hello, world!'
+eos
+        end
+
+        around do | example |
+          with_files(source: source) do | files |
+            @source_file = files.first
+            example.run
+          end
+        end
+
+        describe '#snippet_after' do
+          it 'returns the code block after the match (string)' do
+            snippet = script.snippet_after 'Snippet: Hello, world!'
+            expect(snippet.strip).to eq(expected_snippet.strip)
+          end
+
+          it 'returns the code block after the match (regex)' do
+            snippet = script.snippet_after(/Snippet: .*/)
+            expect(snippet.strip).to eq(expected_snippet.strip)
+          end
+
+          it 'returns nothing if no match is found' do
+            snippet = script.snippet_after 'Nothing matches'
+            expect(snippet).to be_empty
+          end
+        end
+
+        describe '#snippet_between' do
+          # Yes, whitespace doesn't work very well w/ snippet_between
+          let(:expected_snippet) do
+            <<-'eos'
+puts "Random: #{rand}"
+# Snippet: Hello, world!
+puts 'Hello, world!'
+eos
+          end
+
+          it 'inserts all code blocks between the matching regexes' do
+            snippet = script.snippet_between 'This snippet should not be in the output', 'Nor should this snippet'
+            expect(snippet.strip).to eq(expected_snippet.strip)
+          end
+
+          it 'inserts nothing unless both matches are found' do
+            # Neither match
+            snippet = script.snippet_between 'foo', 'bar'
+            expect(snippet.strip).to be_empty
+
+            # First matches
+            snippet = script.snippet_between 'This snippet should not be in the output', 'foo'
+            expect(snippet.strip).to be_empty
+
+            # Last matches
+            snippet = script.snippet_between 'foo', 'Nor should this snippet'
+            expect(snippet.strip).to be_empty
+          end
+
+        end
+
+        describe '#code_block' do
+          it 'generates markdown code blocks by default' do
+            expected = "```ruby\n" + source + "```\n"
+            code_block = script.code_block(script.source, 'ruby')
+            expect(code_block).to eq(expected)
+          end
+
+          it 'generates rst for format :rst' do
+            indented_source = source.lines.map do|line|
+              "  #{line}"
+            end.join("\n")
+            expected = ".. code-block:: ruby\n" + indented_source
+            code_block = script.code_block(script.source, 'ruby', format: :rst)
+            expect(code_block).to eq(expected)
+          end
+        end
+
+        def generate_doc_for(template_file, source_file)
+          doc_gen = DocumentationGenerator.new(template_file, 'testing')
+          script = Script.new(psychic, 'test', source_file)
+          script.source_file = source_file
+          doc_gen.process(script)
+        end
+
+        def with_files(files)
+          tmpfiles = []
+          begin
+            files.each do |k, v|
+              file = Tempfile.new(k.to_s)
+              file.write(v)
+              file.close
+              tmpfiles << file
+            end
+            yield tmpfiles.map(&:path)
+          ensure
+            tmpfiles.each(&:unlink)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/omnitest/psychic/execution/default_strategy_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'replaces tokens' do
+  let(:script) { Omnitest::Psychic.new(cwd: current_dir).script('sample.rb') }
+  let(:subject) { described_class.new(script) }
+
+  describe '#execute' do
+    it 'replaces the token with an empty value the param is not set' do
+      expect(subject.execute.stdout.strip).to be_empty
+    end
+
+    it 'replaces the token with the value of the param' do
+      script.params['token'] = 'foo'
+      expect(subject.execute.stdout).to include 'foo'
+    end
+  end
+end

data/spec/omnitest/psychic/execution/env_strategy_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Omnitest
+  class Psychic
+    module Execution
+      RSpec.describe EnvStrategy do
+        before(:each) do
+          write_file 'sample.rb', <<-eos
+          puts ENV['token']
+          eos
+        end
+
+        include_examples 'replaces tokens'
+      end
+    end
+  end
+end

data/spec/omnitest/psychic/execution/flag_strategy_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Omnitest
+  class Psychic
+    module Execution
+      RSpec.describe FlagStrategy do
+        before(:each) do
+          write_file 'sample.rb', <<-eos
+          require 'optparse'
+
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--token=TOKEN", "The token") do |v|
+              options[:token] = v
+            end
+          end.parse!
+
+          puts options[:token]
+          eos
+        end
+
+        include_examples 'replaces tokens'
+      end
+    end
+  end
+end

data/spec/omnitest/psychic/execution/token_strategy_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Omnitest
+  class Psychic
+    module Execution
+      RSpec.describe TokenStrategy do
+        before(:each) do
+          write_file 'sample.rb', <<-eos
+          puts '{token}'
+          eos
+        end
+
+        let(:script) { Psychic.new(cwd: current_dir).script('sample') }
+        let(:subject) { described_class.new(script) }
+
+        include_examples 'replaces tokens'
+
+        describe '#execute' do
+          it 'does not permanently alter the file' do
+            expect { subject.execute }.to_not change { File.read("#{current_dir}/sample.rb") }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/omnitest/psychic/factories/java_factories_spec.rb

@@ -0,0 +1,35 @@
+module Omnitest
+  class Psychic
+    module Factories
+      RSpec.describe JavaFactory do
+        let(:psychic) { Psychic.new(cwd: current_dir) }
+        let(:shell) { Omnitest::Shell.shell = double('shell') }
+        subject { described_class.new(psychic, cwd: current_dir) }
+
+        before(:each) do
+          write_file('src/main/java/HelloWorld.java', '')
+          write_file('src/main/java/org/mycompany/FQ.java', '')
+          write_file('src/test/java/org/mycompany/FQTest.java', '')
+        end
+
+        describe '#script' do
+          let(:hello_world) { psychic.script('hello world') }
+          let(:fq) { psychic.script('fq') }
+          let(:fqtest) { psychic.script('fqtest') }
+
+          it 'converts files without a package to a classname only' do
+            expect(subject.script hello_world).to eq('java -classpath build/libs/* HelloWorld')
+          end
+
+          it 'converts files with a package to a fully qualified name' do
+            expect(subject.script fq).to eq('java -classpath build/libs/* org.mycompany.FQ')
+          end
+
+          it 'converts files with a package to a fully qualified name' do
+            expect(subject.script fqtest).to eq('java -classpath build/libs/* org.mycompany.FQTest')
+          end
+        end
+      end
+    end
+  end
+end