psychic-runner 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 966decba16f73cabfd0e9c5ec9b06264da9cff30
-  data.tar.gz: 124f2dda5812f6ef48ab04e626f0f1fc92a612e5
+  metadata.gz: a3af75e80b40bfaa12b7fdf0c0321d653ab56b86
+  data.tar.gz: ed65f470ce7e85d0f62b329c34ecd476818c9c3e
 SHA512:
-  metadata.gz: 2677291d81e7f08bf56415062a19f2b4eee25fdb3e8a539c2d4b5b84e1e1e8ab65470a5c2b137e91f5c5c3b4a91e550739f93ed077dac6e28776f5d5c006d265
-  data.tar.gz: 2528ceea531136d5b1e1125965fdb95e29a1074398a3f1fb32bc918ecf34066491c762f4ee16264195e35bda8fe144783898ff1d9a48deb6b21f77682f0db438
+  metadata.gz: 03565dc8cc94cca3682ce30a9e6e3967f7b682882591d5005d08f11c6722141bfad92a1642456611ce4ebe3ba0dec91d4131505a4f1b51c59a487778444b53fa
+  data.tar.gz: 48e7bd41635a48408e4b6a103a4e9688135e2ee75d82c7f81da9042f144b285bb1835aff15a549a6f89820d478f29df7766eade9c4647a84882a1e92acf3b8ba

data/Gemfile

@@ -3,3 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in psychic-runner.gemspec
 gemspec
 gem 'pry'
+gem 'rouge'

data/bin/psychic

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require 'psychic/runner/cli'
 
-Psychic::CLI.start
+Psychic::Runner::CLI.start

data/lib/psychic/cli.rb

@@ -11,7 +11,14 @@ module Psychic
 
       def start(given_args = ARGV, config = {})
         if given_args && (split_pos = given_args.index('--'))
-          @extra_args = given_args.slice(split_pos + 1, given_args.length)
+          @extra_args = given_args.slice(split_pos + 1, given_args.length).map do | arg |
+            # Restore quotes
+            next unless arg.match(/\=/)
+            lhs, rhs = arg.split('=')
+            lhs = "\"#{lhs}\"" if lhs.match(/\s/)
+            rhs = "\"#{rhs}\"" if rhs.match(/\s/)
+            [lhs, rhs].join('=')
+          end
           given_args = given_args.slice(0, split_pos)
         end
         super given_args, config

data/lib/psychic/output_helper.rb

@@ -0,0 +1,84 @@
+module Psychic
+  module OutputHelper
+    class StringShell < Thor::Base.shell
+      attr_reader :io
+
+      def initialize(*args)
+        @io = StringIO.new
+        super
+      end
+
+      alias_method :stdout, :io
+      alias_method :stderr, :io
+
+      def string
+        @io.string
+      end
+
+      def can_display_colors?
+        # Still capture colors if they can eventually be displayed.
+        $stdout.tty?
+      end
+    end
+
+    def cli
+      @cli ||= Thor::Base.shell.new
+    end
+
+    def build_string
+      old_cli = @cli
+      new_cli = @cli = StringShell.new
+      yield
+      @cli = old_cli
+      new_cli.string
+    end
+
+    def reformat(string)
+      return if string.nil? || string.empty?
+
+      indent do
+        string.gsub(/^/, indent)
+      end
+    end
+
+    def indent
+      @indent_level ||= 0
+      if block_given?
+        @indent_level += 2
+        result = yield
+        @indent_level -= 2
+        result
+      else
+        ' ' * @indent_level
+      end
+    end
+
+    def say(msg)
+      cli.say msg if msg
+    end
+
+    def status(status, msg = nil, color = :cyan, colwidth = 50)
+      msg = yield if block_given?
+      cli.say(indent) if indent.length > 0
+      status = cli.set_color("#{status}:", color, true)
+      # The built-in say_status is right-aligned, we want left-aligned
+      cli.say format("%-#{colwidth}s %s", status, msg).rstrip
+    end
+
+    # TODO: Reporters for different formats
+    def print_table(*args)
+      # @reporter.print_table(*args)
+      cli.print_table(*args)
+    end
+
+    def colorize(string, *args)
+      return string unless @reporter.respond_to? :set_color
+      # @reporter.set_color(string, *args)
+      cli.set_color(string, *args)
+    end
+
+    def color_pad(string)
+      string + colorize('', :white)
+    end
+  end
+end

data/lib/psychic/runner.rb

@@ -1,38 +1,110 @@
 require 'psychic/runner/version'
 
+autoload :Thor, 'thor'
 autoload :YAML, 'yaml'
 
 module Psychic
   autoload :Util,   'psychic/util'
   autoload :Logger, 'psychic/logger'
   autoload :Shell,  'psychic/shell'
+  autoload :OutputHelper, 'psychic/output_helper'
   class Runner
+    autoload :MagicTaskFactory, 'psychic/runner/magic_task_factory'
     autoload :BaseRunner, 'psychic/runner/base_runner'
+    autoload :CodeSample, 'psychic/runner/code_sample'
+    autoload :SampleFinder, 'psychic/runner/sample_finder'
     autoload :SampleRunner, 'psychic/runner/sample_runner'
-    autoload :HotRunner, 'psychic/runner/hot_runner'
-    autoload :CompoundRunner, 'psychic/runner/compound_runner'
-    autoload :ColdRunnerRegistry, 'psychic/runner/cold_runner_registry'
-    class TaskNotImplementedError < NotImplementedError; end
-    ColdRunnerRegistry.autoload_runners!
+    autoload :HotReadTaskFactory, 'psychic/runner/hot_read_task_factory'
+    autoload :TaskFactoryRegistry, 'psychic/runner/task_factory_registry'
+    class TaskNotImplementedError < NotImplementedError
+      def initialize(task_name)
+        super("#{self.class} cannot handle task #{task_name}")
+      end
+    end
+    TaskFactoryRegistry.autoload_task_factories!
 
     include BaseRunner
     include SampleRunner
-    attr_reader :runners, :hot_runner, :cold_runners
+    attr_reader :runners, :hot_read_task_factory, :task_factories, :sample_factories
 
-    def initialize(opts = { cwd: Dir.pwd })
+    def initialize(opts = { cwd: Dir.pwd }) # rubocop:disable Metrics/MethodLength
+      # TODO: Will reduce method length after further splitting Runner vs TaskFactory
       fail 'cwd is required' unless opts[:cwd]
-      opts[:cwd] = Pathname(opts[:cwd]).to_s # must be a string on windows...
-      super
-      @hot_runner = HotRunner.new(opts)
-      @cold_runners = ColdRunnerRegistry.active_runners(opts)
-      @runners = [@hot_runner, @cold_runners].flatten
-      @known_tasks = @runners.map(&:known_tasks).uniq
+      # must be a string on windows...
+      opts[:cwd] = Pathname(opts[:cwd]).to_s
+      @opts = opts
+      init_attr(:cwd) { Dir.pwd }
+      init_hints
+      init_attr(:logger) { new_logger }
+      init_attr(:env) { ENV.to_hash }
+      init_attrs :cli, :interactive, :parameter_mode, :restore_mode, :dry_run
+      @shell_opts = select_shell_opts
+      @parameters = load_parameters(opts[:parameters])
+      # super
+      @hot_read_task_factory = HotReadTaskFactory.new(opts)
+      @sample_finder = SampleFinder.new(opts[:cwd], @hot_read_task_factory.hints['samples'])
+      @task_factories = TaskFactoryRegistry.active_task_factories(opts)
+      @runners = [@hot_read_task_factory, @task_factories].flatten
+      @known_tasks = @runners.flat_map(&:known_tasks).uniq
+    end
+
+    def known_samples
+      @sample_finder.known_samples
     end
 
-    def [](task_name)
-      runner = runners.find { |r| r.command_for_task(task_name) }
+    def task_for(task_name)
+      runner = runners.find { |r| r.known_task?(task_name) }
       return nil unless runner
-      runner[task_name]
+      runner.task_for(task_name)
+    end
+
+    private
+
+    def init_attr(var)
+      var_name = "@#{var}"
+      var_value = @opts[var]
+      var_value = yield if var_value.nil? && block_given?
+      instance_variable_set(var_name, var_value)
+    end
+
+    def init_attrs(*vars)
+      vars.each do | var |
+        init_attr var
+      end
+    end
+
+    def init_hints
+      @hints = Psychic::Util.stringified_hash(@opts[:hints] || load_hints || {})
+      if @hints['options']
+        @opts.merge! Psychic::Util.symbolized_hash(@hints['options'])
+      end
+    end
+
+    def select_shell_opts
+      # Make sure to delete any option that isn't a MixLib::ShellOut option
+      @opts.select { |key, _| Psychic::Shell::AVAILABLE_OPTIONS.include? key }
+    end
+
+    def load_hints
+      hints_file = Dir["#{@cwd}/psychic.{yaml,yml}"].first
+      YAML.load(File.read(hints_file)) unless hints_file.nil?
+    end
+
+    def load_parameters(parameters)
+      if parameters.nil? || parameters.is_a?(String)
+        load_parameters_file(parameters)
+      else
+        parameters
+      end
+    end
+
+    def load_parameters_file(file = nil)
+      if file.nil?
+        file ||= File.expand_path(DEFAULT_PARAMS_FILE, cwd)
+        return {} unless File.exist? file
+      end
+      parameters = Psychic::Util.replace_tokens(File.read(file), @env)
+      YAML.load(parameters)
     end
   end
 end

data/lib/psychic/runner/base_runner.rb

@@ -6,20 +6,41 @@ module Psychic
       include Psychic::Shell
       include Psychic::Logger
 
-      attr_reader :known_tasks
-      attr_reader :cwd
-      attr_reader :env
-      attr_reader :hints
+      attr_reader :known_tasks, :tasks, :cwd, :env, :hints
 
       module ClassMethods
-        attr_accessor :magic_file_pattern
+        def register_task_factory
+          Psychic::Runner::TaskFactoryRegistry.register(self)
+        end
 
-        def register_runner
-          Psychic::Runner::ColdRunnerRegistry.register(self)
+        def magic_file_patterns
+          @magic_file_patterns ||= []
         end
 
         def magic_file(pattern) # rubocop:disable Style/TrivialAccessors
-          @magic_file_pattern = pattern
+          magic_file_patterns << pattern
+        end
+
+        def magic_env_vars
+          @magic_env_vars ||= []
+        end
+
+        def magic_env_var(var)
+          magic_env_vars << var
+        end
+
+        def known_tasks
+          @known_tasks ||= []
+        end
+
+        def tasks
+          @tasks ||= {}
+        end
+
+        def task(name, &block)
+          name = name.to_s
+          tasks[name] = block
+          known_tasks << name
         end
       end
 
@@ -27,53 +48,54 @@ module Psychic
         base.extend(ClassMethods)
       end
 
-      def initialize(opts = {}, _hints = {})
-        @cwd = opts[:cwd] ||= Dir.pwd
-        @hints = Psychic::Util.stringified_hash(opts[:hints] || load_hints || {})
-        if @hints['options']
-          opts.merge! Psychic::Util.symbolized_hash(@hints['options'])
-        end
-        @logger = opts[:logger] || new_logger
-        @env = opts[:env] || ENV.to_hash
+      def initialize(opts = {})
+        @opts = opts
+        init_attr(:cwd) { Dir.pwd }
+        init_hints
+        init_attr(:known_tasks) { self.class.known_tasks }
+        init_attr(:tasks) { self.class.tasks }
+        init_attr(:logger) { new_logger }
+        init_attr(:env) { ENV.to_hash }
+        init_attrs :cli, :interactive, :parameter_mode, :restore_mode, :dry_run
+        @shell_opts = select_shell_opts
         @parameters = load_parameters(opts[:parameters])
-        @cli, @interactive_mode, @parameter_mode, @restore_mode, @dry_run = opts.values_at(
-          :cli, :interactive, :parameter_mode, :restore_mode, :dry_run)
-        # Make sure to delete any option that isn't a MixLib::ShellOut option
-        @shell_opts = opts.select { |key, _| Psychic::Shell::AVAILABLE_OPTIONS.include? key }
       end
 
-      def respond_to_missing?(task, include_all = false)
-        return true if known_tasks.include?(task.to_s)
-        super
+      def known_task?(task_name)
+        known_tasks.include?(task_name.to_s)
       end
 
-      def method_missing(task, *args, &block)
-        execute_task(task, *args)
-      rescue Psychic::Runner::TaskNotImplementedError
-        super
+      def task_for(task_name)
+        tasks[task_name] if tasks.include? task_name
       end
 
-      # Reserved words
-
       def execute(command, *args)
         full_cmd = [command, *args].join(' ')
         logger.info("Executing #{full_cmd}")
         shell.execute(full_cmd, @shell_opts) unless dry_run?
       end
 
-      def command_for_task(task, *_args)
-        task_name = task.to_s
-        self[task_name]
+      def build_task(task_name, *_args)
+        task_name = task_name.to_s
+        task = task_for(task_name)
+        task = task.call if task.respond_to? :call
+        fail Psychic::Runner::TaskNotImplementedError, task_name if task.nil?
+        task
       end
 
-      def execute_task(task, *args)
-        command = command_for_task(task, *args)
-        fail Psychic::Runner::TaskNotImplementedError if command.nil?
+      def execute_task(task_name, *args)
+        command = build_task(task_name, *args)
         execute(command, *args)
       end
 
       def active?
-        self.class.magic_file_pattern ? false : Dir["#{@cwd}/#{self.class.magic_file_pattern}"]
+        self.class.magic_file_patterns.each do | pattern |
+          return true unless Dir["#{@cwd}/#{pattern}"].empty?
+        end
+        self.class.magic_env_vars.each do | var |
+          return true if ENV[var]
+        end
+        false
       end
 
       def dry_run?
@@ -82,6 +104,31 @@ module Psychic
 
       private
 
+      def init_attr(var)
+        var_name = "@#{var}"
+        var_value = @opts[var]
+        var_value = yield if var_value.nil? && block_given?
+        instance_variable_set(var_name, var_value)
+      end
+
+      def init_attrs(*vars)
+        vars.each do | var |
+          init_attr var
+        end
+      end
+
+      def init_hints
+        @hints = Psychic::Util.stringified_hash(@opts[:hints] || load_hints || {})
+        if @hints['options']
+          @opts.merge! Psychic::Util.symbolized_hash(@hints['options'])
+        end
+      end
+
+      def select_shell_opts
+        # Make sure to delete any option that isn't a MixLib::ShellOut option
+        @opts.select { |key, _| Psychic::Shell::AVAILABLE_OPTIONS.include? key }
+      end
+
       def load_hints
         hints_file = Dir["#{@cwd}/psychic.{yaml,yml}"].first
         YAML.load(File.read(hints_file)) unless hints_file.nil?
@@ -103,6 +150,12 @@ module Psychic
         parameters = Psychic::Util.replace_tokens(File.read(file), @env)
         YAML.load(parameters)
       end
+
+      # Blame Ruby's flatten and Array(...) behavior...
+      def to_ary
+        nil
+      end
+      alias_method :to_a, :to_ary
     end
   end
 end

data/lib/psychic/runner/cli.rb

@@ -1,10 +1,32 @@
+require 'psychic/cli'
 require 'psychic/runner'
 
+# rubocop:disable Metrics/LineLength
+
 module Psychic
-  module Runner
-    class CLI < Psychic::CLI
+  class Runner
+    class RunnerCLI < Psychic::CLI
+      no_commands do
+        def runner
+          @runner ||= setup_runner
+        end
+
+        def setup_runner
+          runner_opts = { cwd: Dir.pwd, cli: shell, parameters: options.parameters }
+          runner_opts.merge!(Util.symbolized_hash(options))
+          Psychic::Runner.new(runner_opts)
+        end
+      end
+    end
+
+    class CLI < RunnerCLI
       desc 'task <name>', 'Executes any task by name'
-      def task(task_name)
+      method_option :list, aliases: '-l', desc: '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 task(task_name = nil)
+        return list_tasks if options[:list]
+        abort 'You must specify a task name, run with -l for a list of known tasks' unless task_name
         result = runner.execute_task(task_name, *extra_args)
         result.error!
         say_status :success, task_name
@@ -15,33 +37,22 @@ module Psychic
 
       BUILT_IN_TASKS.each do |task_name|
         desc task_name, "Executes the #{task_name} 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_name) do
           task(task_name)
         end
       end
 
       desc 'sample <name>', 'Executes a code sample'
-      # rubocop:disable Metrics/LineLength
+      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 :dry_run, desc: 'Do not execute - just show what command would be run', lazy_default: true
-      # rubocop:enable Metrics/LineLength
-      def sample(*sample_names)
-        sample_names.each do | sample_name |
-          say_status :executing, sample_name
-          begin
-            run_sample sample_name
-          rescue Errno::ENOENT
-            say_status :failed, "No code sample found for #{sample_name}", :red
-            # TODO: Fail on missing? Fail fast?
-          end
-        end
-      end
-
-      private
-
-      def run_sample(sample_name)
+      def sample(sample_name = nil)
+        abort 'You must specify a sample name, run `psychic list samples` for a list of known samples' unless sample_name
         result = runner.run_sample(sample_name, *extra_args)
         if options.dry_run
           say_status :dry_run, sample_name
@@ -51,12 +62,56 @@ module Psychic
         end
       end
 
-      def runner
-        runner_opts = Util.symbolized_hash(options).merge(
-          cwd: Dir.pwd, cli: shell, parameters: options.parameters
-        )
-        @runner ||= Psychic::Runner.new(runner_opts)
+      class List < RunnerCLI
+        desc 'samples', 'Lists known code samples'
+        method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+        method_option :cwd, desc: 'Working directory for detecting and running commands'
+        def samples
+          samples = runner.known_samples.map do |sample|
+            [set_color(sample.name, :bold), sample.source_file]
+          end
+          print_table samples
+        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
+          runner.known_tasks.map do |task|
+            task_id = set_color(task, :bold)
+            if options[:verbose]
+              details = runner.task_for(task)
+              details = details.call if details.respond_to? :call
+              details = "\n#{details}".lines.join('  ') if details.lines.size > 1
+              say "#{task_id}: #{details}"
+            else
+              say task_id
+            end
+          end
+        end
+      end
+
+      class Show < RunnerCLI
+        desc 'sample <name>', 'Show detailed information about a code sample'
+        method_option :verbose, aliases: '-v', desc: 'Verbose: display more details'
+        method_option :cwd, desc: 'Working directory for detecting and running commands'
+        def sample(sample_name)
+          sample = runner.find_sample(sample_name)
+          say sample.to_s(options[:verbose])
+        end
+      end
+
+      desc 'list', 'List known tasks or code samples'
+      subcommand 'list', List
+      desc 'show', 'Show details about a task or code sample'
+      subcommand 'show', Show
+
+      no_commands do
+        def show_sample(_sample_name)
+        end
       end
     end
   end
 end
+
+# rubocop:enable Metrics/LineLength