wip-runner 0.1.0

data/lib/wip/runner/shell/handlers/script.rb

@@ -0,0 +1,63 @@
+require 'expect'
+require 'open3'
+
+module WIP
+  module Runner
+    module Shell
+      module Handlers
+        class Script < Base
+          attr_reader :prompts
+
+          def initialize(*)
+            @prompts = []
+            super
+          end
+
+          def description
+            @description ||= "```\n#{@content}\n```"
+            # @description ||= @content
+          end
+
+          def execute(io, env, &block)
+            prompts.empty? ? simplex!(io, env, &block) : complex!(io, env, &block)
+          end
+
+          def prompt(term, options = {})
+            @prompts << [term, options]      # Prompt.new(...)
+          end
+
+          private
+
+          def simplex!(io, env, &block)
+            Open3.popen2e(env, executable) do |stdin, stdoe, thread|
+              while line = stdoe.gets
+                block.call(line)
+              end
+
+              thread.value
+            end
+          end
+
+          def complex!(io, env, &block)
+            Open3.popen2e(env, executable) do |stdin, stdoe, thread|
+              prompts.each do |term, options|
+                stdoe.expect(term) do |result|
+                  stdin.puts io.ask(term) do |q|
+                    options.each { |k, v| q.send(:"#{k}=", v) }
+                  end
+                  stdoe.gets
+                end
+              end
+
+              while line = stdoe.gets
+                block.call(line)
+              end
+
+              thread.value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/shell/handlers/system.rb

@@ -0,0 +1,22 @@
+module WIP
+  module Runner
+    module Shell
+      module Handlers
+        class System < Base
+          def description
+            # @description ||= "```\n#{@content}\n```"
+            @description ||= @content
+          end
+
+          def execute(io, env, &block)
+            IO.popen(env, executable, 'r') do |pipe|
+              pipe.each(&block)
+            end
+
+            $?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/shell/handlers.rb

@@ -0,0 +1,17 @@
+require 'wip/runner/shell/handlers/base'
+require 'wip/runner/shell/handlers/script'
+require 'wip/runner/shell/handlers/system'
+
+module WIP
+  module Runner
+    module Shell
+      module Handlers
+        class << self
+          def locate(key)
+            const_get(key.to_s.capitalize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/shell/runner.rb

@@ -0,0 +1,147 @@
+require 'open3'
+
+module WIP
+  module Runner
+    module Shell
+      class Runner
+        attr_reader :arguments, :options
+
+        def initialize(io, tasks, env = {})
+          @io    = io
+          @tasks = tasks
+          @env   = env
+          @io.indent_size = 2
+        end
+
+        def run(arguments, options)
+          @arguments = arguments
+          @options   = options
+
+          @io.indent do
+            @tasks.each do |task|
+              evaluate(task)
+            end
+          end
+        end
+
+        private
+
+        def evaluate(task)
+          task.build(arguments, options)
+          prefix = options.preview ? :preview : :execute
+
+          section('Config') do
+            # @io.newline
+            # @io.say '```'
+            task.configs.each do |term, options|
+              send(:"#{prefix}_config", term, options)
+            end
+            # @io.say '```'
+          end unless task.configs.empty?
+
+          task.shells.each do |shell|
+            section("Shell #{shell.type.downcase}") do
+              @io.newline
+              send(:"#{prefix}_shell", shell)
+            end
+          end
+
+          # p task.children
+          task.children.each do |child|
+            section('Task') do
+              evaluate(child)
+            end
+          end
+        end
+
+        # ---
+
+        # class Execute
+        # end
+        #
+        # class Preview
+        # end
+
+        def execute_config(term, options = {})
+          query  = options[:required] ? "#{term} (*)" : term
+          answer = @io.ask("- #{query}: ") do |q|
+            q.default  = (options[:default] || ENV[term]) unless options[:password]
+            q.echo     = false  if options[:password]
+            q.validate = /^.+$/ if options[:required]
+          end
+          @env[term] = answer unless answer.empty?
+          @env[term] ||= ENV[term]
+        end
+
+        def execute_shell(shell)
+          preview_shell(shell)
+
+          if approved?
+            @io.newline
+            result = shell.execute(@io, @env) do |line|
+              # @io.say "> `#{line.rstrip}`<br>"
+              @io.say "> #{line.rstrip}"
+              # puts "#{@io.indentation}> `#{line.rstrip}`  "
+              # @io.instance_variable_get(:@output).puts "> `#{line.rstrip}`  "
+
+              # @io.send((action || :say), line)
+            end
+            @io.newline
+
+            # TODO: raise instead of exit.
+            exit 1 unless result.success?
+          else
+            @io.newline
+            @io.say '> (skipped)'
+          end
+        end
+
+        def preview_config(term, options = {})
+          message = options[:required] ? "#{term} (*)" : term
+          @io.say "- #{message}"
+        end
+
+        def preview_shell(shell)
+          @io.say shell.description
+        end
+
+        # ---
+
+        def section(heading, &block)
+          @io.say "- [ ] #{heading}..."
+          @io.indent(&block)
+        end
+
+        # $ wip-runner x --format=markdown
+        # $ wip-runner x --log=out.md       # log format determined by extension
+        #
+        # @formatter = Formatter::Markdown.new(@io)
+        #
+        # def item(text)
+        #   formatter.item(text)
+        # end
+        #
+        # class Formatter::Markdown
+        #   def item(text, check = true)
+        #     @io.say check ? "- [ ] #{text}" : "- #{text}"
+        #   end
+        # end
+        #
+        # class Formatter::Plain
+        # class Formatter::Color
+        # class Formatter::HTML
+        # class Formatter::JSON
+
+        # ---
+
+        def approved?
+          return true unless @options.stepwise
+
+          # case choice
+          # when 'yes'
+          # end
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/shell/task.rb

@@ -0,0 +1,50 @@
+module WIP
+  module Runner
+    module Shell
+      class Task
+        attr_reader :configs, :shells, :children
+
+        def initialize(command, &block)
+          @command  = command
+          @configs  = []
+          @shells   = []
+          @children = []
+          @block    = block
+        end
+
+        def build(arguments, options)
+          self.instance_exec(arguments, options, &@block) ; self
+        end
+
+        def config(term, options = {})
+          @configs << [term.to_s, options] # Config.new(...)
+        end
+
+        def shell(handler, content, &block)
+          shells << Handlers.locate(handler).new(content, &block)
+        end
+
+        def task(&block)
+          children << Task.new(@command, &block)
+        end
+
+        protected
+
+        def method_missing(method_name, *args, &block)
+          if @command.respond_to?(method_name)
+            @command.send(method_name, *args, &block)
+          else
+            # super
+            @command.instance_eval {
+              method_missing(method_name, *args, &block)
+            }
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @command.respond_to?(method_name) || super
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/shell.rb

@@ -0,0 +1,9 @@
+require 'wip/runner/shell/runner'
+require 'wip/runner/shell/task'
+require 'wip/runner/shell/handlers'
+
+module WIP
+  module Runner
+    module Shell ; end
+  end
+end

data/lib/wip/runner/version.rb

@@ -0,0 +1,5 @@
+module WIP
+  module Runner
+    VERSION = "0.1.0"
+  end
+end

data/lib/wip/runner/workflow/builder/component.rb

@@ -0,0 +1,43 @@
+module WIP
+  module Runner
+    module Workflow
+      class Builder::Component
+        def prologue(value = nil)
+          @prologue = clean(value) unless value.nil?
+          @prologue
+        end
+
+        def shell(*args)
+          unless args.empty?
+            shells << [args[0], clean(args[1])]
+          end
+        end
+
+        def shells
+          @shells ||= []
+        end
+
+        def method_missing(method_name, *args, &block)
+          if @command.respond_to?(method_name)
+            @command.send(method_name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @command.respond_to?(method_name) || super
+        end
+
+        private
+
+        def clean(string)
+          return if string.nil?
+
+          indent = (string.scan(/^[ \t]*(?=\S)/).min || '').size
+          string.gsub(/^[ \t]{#{indent}}/, '').strip
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/workflow/builder/step.rb

@@ -0,0 +1,15 @@
+module WIP
+  module Runner
+    module Workflow
+      class Builder::Step  < Builder::Component
+        attr_reader :heading
+
+        def initialize(command, heading, &block)
+          @command = command
+          @heading = heading
+          instance_exec(&block) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/workflow/builder/task.rb

@@ -0,0 +1,20 @@
+module WIP
+  module Runner
+    module Workflow
+      class Builder::Task  < Builder::Component
+        attr_reader :heading, :steps
+
+        def initialize(command, heading, &block)
+          @command = command
+          @heading = heading
+          @steps   = []
+          instance_exec(&block) if block_given?
+        end
+
+        def step(name, &block)
+          steps << Builder::Step.new(@command, name, &block)
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/workflow/builder/workflow.rb

@@ -0,0 +1,50 @@
+module WIP
+  module Runner
+    module Workflow
+      class Builder::Workflow  < Builder::Component
+        def initialize(command)
+          @command = command
+          @configs = []
+          @guards  = []
+          @tasks   = []
+        end
+
+        # ---
+
+        def config(key, options = {})
+          @configs << [key.to_s, options]
+        end
+
+        def guard(description, check, expectation = nil)
+          @guards << [description, check, expectation]
+        end
+
+        def task(heading, &block)
+          @tasks << Builder::Task.new(@command, heading, &block)
+        end
+
+        # ---
+
+        def heading
+          [@command.class.name.split('::').last, 'Workflow'].join(' ')
+        end
+
+        def overview
+          clean(@command.class.overview)
+        end
+
+        def configs
+          @configs
+        end
+
+        def guards
+          @guards
+        end
+
+        def tasks
+          @tasks
+        end
+      end
+    end
+  end
+end

data/lib/wip/runner/workflow/builder.rb

@@ -0,0 +1,18 @@
+module WIP
+  module Runner
+    module Workflow
+      class Builder
+        def initialize(command, &block)
+          @command = command
+          @block   = block
+        end
+
+        def build(arguments, options)
+          workflow = Workflow.new(@command)
+          workflow.instance_exec(arguments, options, &@block)
+          workflow
+        end
+      end
+    end
+  end
+end