psychic-runner 0.0.7 → 0.0.8

data/lib/psychic/runner/code_helper.rb

@@ -0,0 +1,131 @@
+module Psychic
+  class Runner
+    module CodeHelper
+      class Highlighter
+        def initialize(opts)
+          require 'rouge'
+          @lexer = Rouge::Lexer.find(opts[:language]) || Rouge::Lexer.guess_by_filename(opts[:filename])
+          @formatter = opts[:formatter]
+        rescue LoadError # rubocop:disable Lint/HandleExceptions
+          # No highlighting support
+        end
+
+        def highlight(source)
+          if defined?(Rouge)
+            Rouge.highlight(source, @lexer, @formatter)
+          else
+            # No highlighting support
+            source
+          end
+        end
+      end
+
+      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 # I've seen lots of rendering issues without a dividing newline
+          buffer.puts "```#{language}"
+          buffer.puts source
+          buffer.puts '```'
+          buffer.puts # Put a dividing newline after as well, to be safe...
+          buffer.string
+        end
+      end
+
+      def absolute_source_file
+        return nil if source_file.nil?
+
+        if basedir
+          File.expand_path source_file, basedir
+        else
+          source_file
+        end
+      end
+
+      def source
+        File.read absolute_source_file
+      end
+
+      def source?
+        !absolute_source_file.nil?
+      end
+
+      def language
+        @language ||= detect_language
+      end
+
+      def detect_language
+        File.extname(source_file)
+      end
+
+      def highlighted_code(formatter = 'terminal256')
+        Highlighter.new(language: language, filename: absolute_source_file,
+          formatter: formatter).highlight(source)
+      end
+
+      def code_block(source_code, language, opts = { format: :markdown })
+        case opts[:format]
+        when :rst
+          ReStructuredTextHelper.code_block source_code, language
+        when :markdown
+          MarkdownHelper.code_block source_code, language
+        else
+          fail IllegalArgumentError, "Unknown format: #{format}"
+        end
+      end
+
+      # TODO: Segmentation support...
+      # def initialize(*args)
+      #   @segmenter = Polytrix::Documentation::CodeSegmenter.new
+      #   super
+      # 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.puts "\n"
+      #   buffer.string
+      # end
+
+      # private
+
+      # 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

data/lib/psychic/runner/code_sample.rb

@@ -0,0 +1,70 @@
+require 'psychic/runner/code_helper'
+
+module Psychic
+  class Runner
+    class CodeSample < Struct.new(:name, :source_file, :basedir)
+      include CodeHelper
+      include Psychic::OutputHelper
+      # property :name
+      # property :basedir
+      # property :source_file
+
+      def token_handler
+        # Default token pattern/replacement (used by php-opencloud) should be configurable
+        @token_handler ||= RegexpTokenHandler.new(source, /'\{(\w+)\}'/, "'\\1'")
+      end
+
+      def command(runner)
+        command = runner.task_for(:run_sample)
+        # FIXME: Shouldn't this be relative to runner's cwd?
+        # command ||= Psychic::Util.relativize(source_file, runner.cwd)
+        command ||= "./#{source_file}"
+
+        command_params = { sample: name, sample_file: source_file }
+        command_params.merge!(@parameters) unless @parameters.nil?
+        Psychic::Util.replace_tokens(command, command_params)
+      end
+
+      def to_s(verbose = false)
+        build_string do
+          status('Sample 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
+
+      private
+
+      def display_source
+        return unless source?
+        status 'Source Code'
+        say highlighted_code
+      end
+
+      def display_tokens
+        return status 'Tokens', '(None)' if token_handler.tokens.empty?
+
+        status 'Tokens'
+        indent do
+          token_handler.tokens.each do | token |
+            say "- #{token}"
+          end
+        end
+      end
+
+      def formatted_file_name
+        if source?
+          Psychic::Util.relativize(absolute_source_file, Dir.pwd)
+        else
+          colorize('<No code sample>', :red)
+        end
+      end
+    end
+  end
+end

data/lib/psychic/runner/factories/ruby_factories.rb

@@ -0,0 +1,16 @@
+module Psychic
+  class Runner
+    module Factories
+      class BundlerTaskFactory < MagicTaskFactory
+        magic_file 'Gemfile'
+        magic_file '.bundle/config'
+        magic_env_var 'BUNDLE_GEMFILE'
+        register_task_factory
+
+        task :bootstrap do
+          'bundle install'
+        end
+      end
+    end
+  end
+end

data/lib/psychic/runner/{cold/shell_script_runner.rb → factories/shell_script_factories.rb}

@@ -1,11 +1,11 @@
 module Psychic
   class Runner
-    module Cold
-      class ShellScriptRunner
+    module Factories
+      class ShellScriptTaskFactory < MagicTaskFactory
         include BaseRunner
         EXTENSIONS = ['.sh', '']
         magic_file 'scripts/*'
-        register_runner
+        register_task_factory
 
         def initialize(opts)
           super
@@ -14,7 +14,7 @@ module Psychic
           end
         end
 
-        def [](task_name)
+        def task_for(task_name)
           task = task_name.to_s
           script = Dir["#{@cwd}/scripts/#{task}{.sh,}"].first
           if script

data/lib/psychic/runner/{hot_runner.rb → hot_read_task_factory.rb}

@@ -1,6 +1,6 @@
 module Psychic
   class Runner
-    class HotRunner
+    class HotReadTaskFactory
       include BaseRunner
       def initialize(opts = {})
         super
@@ -8,8 +8,9 @@ module Psychic
         @known_tasks = @tasks.keys
       end
 
-      def [](task_name)
-        @tasks[task_name]
+      def task_for(task_name)
+        return @tasks[task_name.to_s] if @tasks.include? task_name.to_s
+        super
       end
     end
   end

data/lib/psychic/runner/magic_task_factory.rb

@@ -0,0 +1,95 @@
+module Psychic
+  class Runner
+    class MagicTaskFactory
+      include Psychic::Logger
+
+      attr_reader :known_tasks, :tasks, :cwd, :env, :hints
+
+      class << self
+        def register_task_factory
+          Psychic::Runner::TaskFactoryRegistry.register(self)
+        end
+
+        def magic_file_patterns
+          @magic_file_patterns ||= []
+        end
+
+        def magic_file(pattern) # rubocop:disable Style/TrivialAccessors
+          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
+
+      def initialize(opts = {})
+        @opts = opts
+        init_attr(:cwd) { Dir.pwd }
+        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 }
+      end
+
+      def task_for(task_name)
+        tasks[task_name] if tasks.include? task_name
+      end
+
+      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 active?
+        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 known_task?(task_name)
+        known_tasks.include?(task_name.to_s)
+      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
+    end
+  end
+end

data/lib/psychic/runner/sample_finder.rb

@@ -0,0 +1,36 @@
+module Psychic
+  class Runner
+    class SampleFinder
+      attr_accessor :hints
+
+      def initialize(search_dir = Dir.pwd, hints = nil)
+        @search_dir = search_dir
+        @hints = hints || {}
+      end
+
+      def known_samples
+        hints.map do | name, file |
+          CodeSample.new(name, file, @search_dir)
+        end
+      end
+
+      def find_sample(name)
+        file = find_in_hints(name) || Psychic::Util.find_file_by_alias(name, @search_dir)
+        CodeSample.new(name, file, @search_dir)
+      end
+
+      # Find multiple samples by a regex or glob pattern
+      # def find_samples(pattern)
+      # end
+
+      private
+
+      def find_in_hints(name)
+        hints.each do |k, v|
+          return v if k.downcase == name.downcase
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/psychic/runner/sample_runner.rb

@@ -2,23 +2,14 @@ module Psychic
   class Runner
     module SampleRunner
       def find_sample(code_sample)
-        find_in_hints(code_sample) || Psychic::Util.find_file_by_alias(code_sample, cwd)
+        @sample_finder.find_sample(code_sample)
       end
 
-      def run_sample(code_sample, *args)
-        sample_file = find_sample(code_sample)
-        absolute_sample_file = File.expand_path(sample_file, cwd)
+      def run_sample(code_sample_name, *args)
+        code_sample = find_sample(code_sample_name)
+        absolute_sample_file = code_sample.absolute_source_file
         process_parameters(absolute_sample_file)
-        command = build_command(code_sample, sample_file)
-        if command
-          execute(command, *args)
-        else
-          run_sample_file(sample_file)
-        end
-      end
-
-      def run_sample_file(sample_file, *args)
-        execute("./#{sample_file}", *args) # Assuming Bash, but should detect Windows and use PowerShell
+        execute(code_sample.command(self), *args)
       end
 
       def process_parameters(sample_file)
@@ -52,7 +43,7 @@ module Psychic
       end
 
       def build_command(code_sample, sample_file)
-        command = command_for_task('run_sample')
+        command = task_for(:run_sample)
         return nil if command.nil?
 
         command_params = { sample: code_sample, sample_file: sample_file }
@@ -80,6 +71,7 @@ module Psychic
       end
 
       def prompt(key)
+        value = @parameters[key]
         if value
           return value unless @interactive_mode == 'always'
           new_value = @cli.ask "Please set a value for #{key} (or enter to confirm #{value.inspect}): "

data/lib/psychic/runner/task_factory_registry.rb

@@ -0,0 +1,31 @@
+module Psychic
+  class Runner
+    class TaskFactoryRegistry
+      include Psychic::Logger
+
+      BUILT_IN_DIR = File.expand_path('../factories', __FILE__)
+
+      class << self
+        def autoload_task_factories!
+          # Load built-in task factories
+          Dir["#{BUILT_IN_DIR}/*.rb"].each do |task_factory_file|
+            require task_factory_file
+          end
+        end
+
+        def task_factory_classes
+          @task_factory_classes ||= Set.new
+        end
+
+        def register(klass)
+          task_factory_classes.add klass
+        end
+
+        def active_task_factories(opts)
+          task_factories = task_factory_classes.map { |k| k.new(opts) }
+          task_factories.select(&:active?)
+        end
+      end
+    end
+  end
+end