omnitest-psychic 0.0.9

data/lib/omnitest/psychic/script.rb

@@ -0,0 +1,146 @@
+require 'shellwords'
+
+module Omnitest
+  class Psychic
+    class Script # rubocop:disable Metrics/ClassLength
+      include Code2Doc::CodeHelper
+      include Omnitest::OutputHelper
+
+      attr_reader :psychic
+
+      # @return [String] a name for the script
+      attr_reader :name
+      # @return [Pathname] the location of the script
+      attr_reader :source_file
+      # @return [Hash] options controlling how the script is executed
+      attr_reader :opts
+      # @return [Hash] params key/value pairs to bind to script input
+      attr_accessor :params
+      attr_accessor :arguments
+      attr_accessor :env
+
+      def initialize(psychic, name, source_file, opts = {})
+        fail ArgumentError if psychic.nil?
+        fail ArgumentError if name.nil?
+        fail ArgumentError if source_file.nil?
+        @name = name.to_s
+        @source_file, *@arguments = Shellwords.shellsplit(source_file.to_s)
+        @source_file = Pathname(@source_file)
+        @opts ||= opts
+        @env = opts[:env] || psychic.env
+        @params = opts[:params] ||= psychic.parameters
+        @psychic = psychic
+      end
+
+      def basedir
+        @psychic.basedir
+      end
+
+      def extname
+        source_file.extname
+      end
+
+      def command
+        execution_strategy.command
+      end
+
+      def execute(*extra_args)
+        execution_strategy.execute *extra_args
+      end
+
+      def tokens
+        return [] unless detection_strategy.respond_to? :tokens
+        @tokens ||= detection_strategy.tokens
+      end
+
+      def to_s(verbose = false)
+        build_string do
+          status('Script Name', name)
+          display_tokens
+          status('Source File', formatted_file_name)
+          display_source if verbose
+        end
+      end
+
+      def to_path
+        # So coercion to Pathname is possible
+        source_file.to_s
+      end
+
+      def absolute_source_file
+        return nil if source_file.nil?
+
+        File.expand_path source_file, basedir
+      end
+
+      def detection_strategy
+        @detection_strategy ||= create_detection_strategy
+      end
+
+      def execution_strategy
+        @execution_strategy ||= create_execution_strategy
+      end
+
+      def interactive?
+        @psychic.interactive?
+      end
+
+      private
+
+      def display_source
+        return unless source?
+        status 'Source Code'
+        say highlighted_code
+      end
+
+      def display_tokens
+        return status 'Tokens', '(None)' if tokens.empty?
+
+        status 'Tokens'
+        indent do
+          tokens.each do | token |
+            say "- #{token}"
+          end
+        end
+      end
+
+      def formatted_file_name
+        if source?
+          Omnitest::Core::FileSystem.relativize(absolute_source_file, Dir.pwd)
+        else
+          colorize('<No script>', :red)
+        end
+      end
+
+      def create_execution_strategy
+        strategy = opts[:execution_strategy]
+        case strategy
+        when nil
+          Execution::DefaultStrategy.new self
+        when 'tokens'
+          Execution::TokenStrategy.new self
+        when 'environment_variables'
+          Execution::EnvStrategy.new self
+        when 'flags'
+          Execution::FlagStrategy.new self
+        else
+          # TODO: Need support for custom commands with positional args
+          fail "Unknown binding strategy #{strategy}"
+        end
+      end
+
+      def create_detection_strategy
+        strategy = opts[:detection_strategy] || opts[:execution_strategy]
+        case strategy
+        when nil
+          nil
+        when 'tokens'
+          Tokens::RegexpTokenHandler.new(source, /'\{(\w+)\}'/, "'\\1'")
+        else
+          # TODO: Need support for detecting tokens from comments, help commands, etc.
+          fail "Unknown token detection strategy #{strategy}"
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/script_factory.rb

@@ -0,0 +1,66 @@
+module Omnitest
+  class Psychic
+    class ScriptFactory < FactoryManager
+      include Omnitest::Core::Logger
+
+      TASK_PRIORITY = 5
+
+      attr_reader :priority, :psychic, :run_patterns
+
+      class << self
+        def register_script_factory
+          Omnitest::Psychic::ScriptFactoryManager.register_factory(self)
+        end
+
+        def run_patterns
+          @run_patterns ||= {}
+        end
+
+        def runs(ext, priority = 5)
+          run_patterns[ext] = priority
+        end
+
+        def priority_for_script(script)
+          script_path = Pathname(script)
+          run_patterns.each do | pattern, priority |
+            return priority if script_path.fnmatch(pattern, File::FNM_CASEFOLD)
+          end
+          nil
+        end
+      end
+
+      def initialize(psychic, opts)
+        @psychic = psychic
+        @opts = opts
+        @logger = psychic.logger
+      end
+
+      def active?
+        true
+      end
+
+      def cwd
+        psychic.cwd
+      end
+
+      def known_scripts
+        cwd_path = Pathname(cwd)
+        self.class.run_patterns.flat_map do | pattern, _priority |
+          Dir[cwd_path.join(pattern)]
+        end
+      end
+
+      def known_script?(script)
+        known_scripts.include? Pathname(script)
+      end
+
+      def priority_for_script(script)
+        self.class.priority_for_script(script)
+      end
+
+      def script(_script)
+        fail NotImplementedError, 'This should be implemented by subclasses'
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/script_factory_manager.rb

@@ -0,0 +1,24 @@
+module Omnitest
+  class Psychic
+    class ScriptFactoryManager < FactoryManager
+      def factories_for(script)
+        capable_factories = active_factories.select do | factory |
+          factory.priority_for_script(script)
+        end
+
+        capable_factories.sort_by do |factory|
+          factory.priority_for_script(script)
+        end
+      end
+
+      def priority_for(script)
+        active_factories.map do | factory |
+          priority = factory.priority_for_script(script) || 0
+          # FIXME: Need to change default log level to info before adding debug logging
+          # logger.debug("#{factory.class} priority for #{script.source_file}: #{priority}")
+          priority
+        end.max
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/script_runner.rb

@@ -0,0 +1,45 @@
+module Omnitest
+  class Psychic
+    module ScriptRunner
+      def script_factory_manager
+        @script_factory_manager ||= ScriptFactoryManager.new(self, opts)
+      end
+
+      def known_scripts
+        @known_scripts ||= hints.scripts.map do | script_name, script_file |
+          Script.new(self, script_name, script_file, opts)
+        end
+      end
+
+      def script(script_name)
+        find_in_known_scripts(script_name) || find_in_basedir(script_name)
+      end
+
+      protected
+
+      def find_in_known_scripts(script_name)
+        known_scripts.find do |script|
+          script.name.downcase == script_name.downcase
+        end
+      end
+
+      def find_in_basedir(script_name) # rubocop:disable Metrics/AbcSize
+        file = FileFinder.find_file_by_alias(script_name, basedir) do | files |
+          candidates = files.group_by do | script_file |
+            # Chooses the file w/ the highest chance of being runnable
+            path = Omnitest::Core::FileSystem.relativize(script_file, cwd)
+            script = Script.new(self, script_name, path, opts)
+            script_factory_manager.priority_for(script) || 0
+          end
+          candidates.empty? ? files.first : candidates[candidates.keys.max].min_by(&:length)
+        end
+
+        return nil if file.nil?
+
+        Script.new(self, script_name, file, opts).tap do | script |
+          @known_scripts << script
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/task.rb

@@ -0,0 +1,6 @@
+module Omnitest
+  class Psychic
+    class Task < CommandTemplate
+    end
+  end
+end

data/lib/omnitest/psychic/task_factory_manager.rb

@@ -0,0 +1,19 @@
+module Omnitest
+  class Psychic
+    class TaskFactoryManager < FactoryManager
+      def factories_for(task)
+        capable_factories = active_factories.select do | factory |
+          factory.priority_for_task(task)
+        end
+
+        capable_factories.sort_by do |factory|
+          factory.priority_for_task(task)
+        end
+      end
+
+      def known_tasks
+        active_factories.flat_map(&:known_tasks)
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/task_runner.rb

@@ -0,0 +1,30 @@
+module Omnitest
+  class Psychic
+    module TaskRunner
+      # Chooses an appropriate task for the task alias
+      # @param [String] task_alias an alias used to lookup a task
+      # @return [Task] the best match for the task alias
+      def task(task_alias)
+        task_alias = task_alias.to_sym
+        task_factory = task_factory_manager.factories_for(task_alias).last
+        fail TaskNotImplementedError, task_alias if task_factory.nil? || task_factory.priority == 0
+        command = task_factory.task(task_alias)
+        Task.new(self, command)
+      end
+
+      # Lists all known tasks. This will include tasks that have been
+      # manually alased in `psychic.yaml`, well-known tasks for detected
+      # tools, and possibly some dynamically detected tasks for tools that
+      # support task discovery.
+      # @return [Set<Task>] the set of known tasks
+      def known_tasks
+        task_factory_manager.known_tasks
+      end
+
+      # @api private
+      def task_factory_manager
+        @task_factory_manager ||= TaskFactoryManager.new(self, opts)
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/tokens.rb

@@ -0,0 +1,51 @@
+autoload :Mustache, 'mustache'
+
+module Omnitest
+  class Psychic
+    module Tokens
+      class RegexpTokenHandler
+        def initialize(template, token_pattern, token_replacement)
+          @template = template
+          @token_pattern = token_pattern
+          @token_replacement = token_replacement
+        end
+
+        def tokens
+          @template.scan(@token_pattern).flatten.uniq
+        end
+
+        def render(variables = {})
+          @template.gsub(@token_pattern) do
+            full_match = Regexp.last_match[0]
+            key = Regexp.last_match[1]
+            value = variables[key]
+            value = @token_replacement.gsub('\\1', value.to_s) unless @token_replacement.nil?
+            full_match.gsub(@token_pattern, value)
+          end
+        end
+      end
+
+      class MustacheTokenHandler
+        def initialize(template)
+          @template = Mustache::Template.new(template)
+        end
+
+        def tokens
+          @template.tags
+        end
+
+        def render(variables = {})
+          Mustache.render(@template, variables)
+        end
+      end
+
+      def self.replace_tokens(template, variables, token_regexp = nil, token_replacement = nil)
+        if token_regexp.nil?
+          MustacheTokenHandler.new(template).render(variables)
+        else
+          RegexpTokenHandler.new(template, token_regexp, token_replacement).render(variables)
+        end
+      end
+    end
+  end
+end

data/lib/omnitest/psychic/version.rb

@@ -0,0 +1,5 @@
+module Omnitest
+  class Psychic
+    VERSION = '0.0.9'
+  end
+end

data/lib/omnitest/psychic/workflow.rb

@@ -0,0 +1,27 @@
+module Omnitest
+  class Psychic
+    class Workflow
+      attr_reader :commands, :psychic
+
+      def initialize(psychic, name = 'workflow', options = {}, &block)
+        @psychic = psychic
+        @name = name
+        @options = options
+        @commands = []
+        instance_eval &block if block_given?
+      end
+
+      def task(name, *args)
+        @commands << psychic.task(name, *args)
+      end
+
+      def command
+        @commands.map(&:command).join("\n") + "\n"
+      end
+
+      def execute(_params = {}, shell_opts = {}, *extra_args)
+        @psychic.execute(command, shell_opts, *extra_args)
+      end
+    end
+  end
+end

data/lib/omnitest/shell.rb

@@ -0,0 +1,27 @@
+module Omnitest
+  module Shell
+    autoload :ExecutionResult, 'omnitest/shell/execution_result'
+    autoload :ExecutionError, 'omnitest/shell/execution_result'
+    autoload :MixlibShellOutExecutor, 'omnitest/shell/mixlib_shellout_executor'
+    autoload :BuffShellOutExecutor, 'omnitest/shell/buff_shellout_executor'
+
+    AVAILABLE_OPTIONS = [
+      # All MixLib::ShellOut options - though we don't use most of these
+      :cwd, :domain, :password, :user, :group, :umask,
+      :timeout, :returns, :live_stream, :live_stdout,
+      :live_stderr, :input, :logger, :log_level, :log_tag, :env
+    ]
+
+    attr_writer :shell
+
+    def shell
+      @shell ||= RUBY_PLATFORM == 'java' ? BuffShellOutExecutor.new : MixlibShellOutExecutor.new
+    end
+
+    attr_writer :shell
+
+    def cli
+      @cli ||= Thor::Shell::Base.shell
+    end
+  end
+end