omnitest-psychic 0.0.9

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

@@ -0,0 +1,92 @@
+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/).
+      module CommentStyles
+        class UnknownStyleError < StandardError
+          attr_accessor :extension
+
+          def initialize(extension)
+            @extension = extension
+          end
+        end
+
+        def self.infer(extension)
+          extension.tr! '.', ''
+          return extension, COMMENT_STYLES[extension] if COMMENT_STYLES.key? extension
+
+          COMMENT_STYLES.each do | _style_name, style |
+            return extension, style if style[:extensions].include? extension
+          end
+
+          fail UnknownStyleError, extension
+        end
+
+        # TODO: This should be YAML, more easily shared with other projects like groc, docco and linguist.
+
+        C_STYLE_COMMENTS = {
+          single: '//',
+          multi: { start: '/**', middle: '*', end: '*/' },
+          heredoc: nil,
+          extensions: %w(c cpp cs java js php scala go)
+        }
+
+        COMMENT_STYLES  = {
+          'bash'          =>  { single: '#', multi: nil, extensions: %w(sh) },
+          'c'             =>  C_STYLE_COMMENTS,
+          'coffee-script' =>  {
+            single: '#',
+            multi: { start: '###', middle: nil, end: '###' },
+            heredoc: nil,
+            extensions: %w(coffee)
+          },
+          'cpp' =>  C_STYLE_COMMENTS,
+          'csharp' => C_STYLE_COMMENTS,
+          'css'           =>  {
+            single: nil,
+            multi: { start: '/**', middle: '*', end: '*/' },
+            heredoc: nil,
+            extensions: %w(css scss sass)
+          },
+          'html'           =>  {
+            single: nil,
+            multi: { start: '<!--', middle: nil, end: '-->' },
+            heredoc: nil,
+            extensions: %w(html htm)
+          },
+          'java'          =>  C_STYLE_COMMENTS,
+          'js'            =>  C_STYLE_COMMENTS,
+          'lua'           =>  {
+            single: '--',
+            multi: nil,
+            heredoc: nil,
+            extensions: %w(lua)
+          },
+          'php' => C_STYLE_COMMENTS,
+          'python'        =>  {
+            single: '#',
+            multi: { start: '"""', middle: nil, end: '"""' },
+            heredoc: nil,
+            extensions: %w(py)
+          },
+          'rb'            =>  {
+            single: '#',
+            multi: { start: '=begin', middle: nil, end: '=end', idiomatic: false },
+            heredoc: '<<-',
+            extensions: %w(rb)
+          },
+          'scala'         =>  C_STYLE_COMMENTS,
+          'scheme'        =>  { single: ';;',  multi: nil, heredoc: nil, extensions: %w(scheme) },
+          'yaml'        =>  { single: '#',  multi: nil, heredoc: nil, extensions: %w(yaml) },
+          'xml'           =>  {
+            single: nil,
+            multi: { start: '<!--', middle: nil, end: '-->' },
+            heredoc: nil,
+            extensions: %w(xml xsl xslt)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/command_template.rb

@@ -0,0 +1,35 @@
+module Omnitest
+  class Psychic
+    class CommandTemplate
+      attr_reader :psychic
+
+      def initialize(psychic, template)
+        @psychic = psychic
+        fail ArgumentError, 'Cannot create a nil command' if template.nil?
+        @template = template
+      end
+
+      def command(params = {})
+        Tokens.replace_tokens(build_command, params)
+      end
+
+      def execute(params = {}, *args)
+        shell_opts = args.shift if args.first.is_a? Hash
+        shell_opts ||= {}
+        @psychic.execute(command(params), shell_opts, *args)
+      end
+
+      alias_method :to_s, :command
+
+      private
+
+      def build_command
+        @command ||= if @template.respond_to?(:call)
+                       @template.call
+                     else
+                       @template
+                     end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/error.rb

@@ -0,0 +1,15 @@
+module Omnitest
+  class Psychic
+    class TaskNotImplementedError < NotImplementedError
+      def initialize(task_alias)
+        super("no active task factories can run a task named #{task_alias}")
+      end
+    end
+
+    class ScriptNotRunnable < NotImplementedError
+      def initialize(script)
+        super("no active script factories no how to run #{script.source_file}")
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/execution/default_strategy.rb

@@ -0,0 +1,82 @@
+module Omnitest
+  class Psychic
+    module Execution
+      class DefaultStrategy < CommandTemplate
+        attr_reader :script
+
+        def initialize(script)
+          @script = script
+          @psychic = script.psychic
+          super(script.psychic, build_command)
+        end
+
+        def execute(*args)
+          shell_opts = args.shift if args.first.is_a? Hash
+          shell_opts ||= { env: script.env }
+          expand_parameters
+          params = script.params
+          command_params = { script: script.name, script_file: script.source_file }
+          command_params.merge!(params) unless params.nil?
+          super(command_params, shell_opts, *args)
+        end
+
+        def build_command # rubocop:disable Metrics/AbcSize
+          return @command if defined? @command
+
+          script_factory = psychic.script_factory_manager.factories_for(script).last
+          fail Omnitest::Psychic::ScriptNotRunnable, script if script_factory.nil?
+
+          @command = script_factory.script(script)
+          if script.arguments
+            arguments = script.arguments.map do | arg |
+              Tokens.replace_tokens(arg, script.params)
+            end
+            @arguments = quote(arguments)
+          end
+          @command = "#{@command}" if script.arguments
+          @command = @command.call if @command.respond_to? :call
+          @command = [@command, @arguments].join(' ')
+        end
+
+        def prompt(key)
+          value = script.params[key]
+          if value
+            return value unless  psychic.opts[:interactive] == 'always'
+            new_value = cli.ask "Please set a value for #{key} (or enter to confirm #{value.inspect}): "
+            new_value.empty? ? value : new_value
+          else
+            cli.ask "Please set a value for #{key}: "
+          end
+        end
+
+        def confirm_or_update_parameters(required_parameters)
+          required_parameters.each do | key |
+            script.params[key] = prompt(key)
+          end if interactive?
+        end
+
+        def expand_parameters
+          if script.params.is_a? String
+            script.params = YAML.load(Tokens.replace_tokens(script.params, script.env))
+          end
+        end
+
+        private
+
+        def quote(values)
+          values.map do | value |
+            value.split.size > 1 ? "\"#{value}\"" : value
+          end
+        end
+
+        def cli
+          psychic.cli
+        end
+
+        def interactive?
+          psychic.interactive?
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/execution/env_strategy.rb

@@ -0,0 +1,12 @@
+module Omnitest
+  class Psychic
+    module Execution
+      class EnvStrategy < DefaultStrategy
+        def execute(*extra_args)
+          script.env.merge!(script.params)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/execution/flag_strategy.rb

@@ -0,0 +1,14 @@
+module Omnitest
+  class Psychic
+    module Execution
+      class FlagStrategy < DefaultStrategy
+        def execute(*extra_args)
+          script.params.each do |key, value |
+            extra_args << "--#{key}=#{value}"
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/execution/token_strategy.rb

@@ -0,0 +1,68 @@
+module Omnitest
+  class Psychic
+    module Execution
+      class TokenStrategy < DefaultStrategy
+        def execute(*extra_args)
+          template = File.read(absolute_file)
+          # Default token pattern/replacement (used by php-opencloud) should be configurable
+          token_handler = Tokens::RegexpTokenHandler.new(template, /["']\{(\w+)\}(["'])/, '\2\1\2')
+          confirm_or_update_parameters(token_handler.tokens)
+          content = token_handler.render(script.params)
+          temporarily_overwrite(absolute_file, content) do
+            super(*extra_args)
+          end
+        end
+
+        private
+
+        def temporarily_overwrite(file, content)
+          backup_file = "#{file}.bak"
+          logger.info("Temporarily replacing tokens in #{file} with actual values")
+          FileUtils.cp(file, backup_file)
+          File.write(file, content)
+          yield
+        ensure
+          if File.exist? backup_file
+            logger.info("Restoring #{file}")
+            FileUtils.mv(backup_file, absolute_file)
+          end
+        end
+
+        def logger
+          psychic.logger
+        end
+
+        def file
+          script.source_file
+        end
+
+        def absolute_file
+          script.absolute_source_file
+        end
+
+        def backup_file
+          "#{absolute_file}.bak"
+        end
+
+        def should_restore?(file, orig, timing = :before)
+          return true if [timing, 'always']. include? opts[:restore_mode]
+          if interactive?
+            cli.yes? "Would you like to #{file} to #{orig} before running the script?"
+          end
+        end
+
+        def backup_and_overwrite(file)
+          backup_file = "#{file}.bak"
+          if File.exist? backup_file
+            if should_restore?(backup_file, file)
+              FileUtils.mv(backup_file, file)
+            else
+              fail 'Please clear out old backups before rerunning' if File.exist? backup_file
+            end
+          end
+          FileUtils.cp(file, backup_file)
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/factories/go_factories.rb

@@ -0,0 +1,14 @@
+module Omnitest
+  class Psychic
+    module Factories
+      class GoFactory < ScriptFactory
+        register_script_factory
+        runs '**.go', 7
+
+        def script(_script)
+          'go run {{source_file}}'
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/factories/hot_read_task_factory.rb

@@ -0,0 +1,54 @@
+module Omnitest
+  class Psychic
+    module Factories
+      class HotReadTaskFactory < MagicTaskFactory
+        register_task_factory
+
+        def initialize(psychic, opts = {})
+          super
+          @tasks = psychic.hints.tasks || {}
+          @known_tasks = @tasks.keys || {}
+        end
+
+        def active?
+          !@tasks.empty?
+        end
+
+        def task(task_alias)
+          return @tasks[task_alias.to_s] if @tasks.include? task_alias.to_s
+          super
+        end
+      end
+
+      class HotReadScriptFactory < ScriptFactory
+        register_script_factory
+
+        def script_hints
+          psychic.hints.scripts
+        end
+
+        def known_script?(script)
+          script_hints.key? script
+        end
+
+        def hot_task_factory
+          psychic.task_factory_manager.active? HotReadTaskFactory
+        end
+
+        def priority_for_script(script)
+          if known_script? script
+            9
+          elsif hot_task_factory.known_task? :run_script
+            7
+          else
+            nil
+          end
+        end
+
+        def script(script)
+          script_hints[script] || hot_task_factory.task(:run_script)
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/factories/java_factories.rb

@@ -0,0 +1,81 @@
+module Omnitest
+  class Psychic
+    module Factories
+      class GradleFactory < MagicTaskFactory
+        TASK_PRIORITY = 6
+        magic_file 'build.gradle'
+        register_task_factory
+
+        task :compile do
+          'gradle assemble'
+        end
+
+        task :test do
+          'gradle test'
+        end
+
+        task :integration do
+          'gradle check'
+        end
+
+        task :bootstrap do
+          # This is for projects using the maven plugin, may need to detect available
+          # tasks w/ gradle install first
+          'gradle assemble'
+        end
+      end
+
+      class MavenFactory < MagicTaskFactory
+        TASK_PRIORITY = 6
+        magic_file 'pom.xml'
+        register_task_factory
+
+        task :compile do
+          'mvn compile'
+        end
+
+        task :test do
+          'mvn test'
+        end
+
+        task :integration do
+          'mvn integration-test'
+        end
+
+        task :bootstrap do
+          # Would compile or something else be more appropriate? install will run tests...
+          'mvn install'
+        end
+      end
+
+      class JavaFactory < ScriptFactory
+        register_script_factory
+        runs '**.java', 7
+
+        def script(script)
+          fully_qualified_name = file_to_fully_qualified_name(script.source_file)
+          "java #{java_opts} #{fully_qualified_name}"
+        end
+
+        protected
+
+        def file_to_fully_qualified_name(source_file)
+          package = source_file.dirname.to_s
+          package.gsub!('\\', '/')
+          package.gsub!(%r{src/\w+/java}, '')
+          package.gsub!('/', '.')
+          package.gsub!(/\A\./, '')
+          package = nil if package.empty?
+          classname = source_file.basename(source_file.extname)
+          [package, classname].compact.join('.')
+        end
+
+        def java_opts
+          # Need a real way to choose/specify java options
+          # Should run via or get classpath from gradle or maven
+          '-classpath build/libs/*'
+        end
+      end
+    end
+  end
+end