fasten 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b5fa7853f4b7c0e9a187bb5f76f59019e7db4defdbc68d059ca71a90ad38b8b
-  data.tar.gz: 91db6845b40c890928b3f217e5d91ab88f127187b95257a4863533db92dc0840
+  metadata.gz: ba214b0518a9968fceffca5ba9ce8ed32e845ecbacb56f153e14cd63fded465b
+  data.tar.gz: 6fb2041f89edda667b3b35522ac50503e90e93e7cbe6ecb5e2e93de46b45171d
 SHA512:
-  metadata.gz: 184e4868d0cc1b5e24ae365e636e7fb988c656665c05420abce2551024143b53857cf32ebb1e717cadedfba655cae42079d1044aa5ae8f82872478d762be8190
-  data.tar.gz: c7f0c1c4d1a8a23ee97be8916de501eacda6a70b526b387fbabbac130743b6aadcfccba1d626581cf0ebe860006cecb58cb7729cd48a4d8aa9d86633ef9a61ab
+  metadata.gz: e49e576f5ed462ec03884818a1fb24b39177bdc0661b5a028338c1160a1be301e71fdb7f109dfdcb306adae2c0153266be0245b650ecb8c1d2c23e5438f1708c
+  data.tar.gz: 674d4a02af2c36b36a2581f609ec13ba71ca8430ab0dd10060f2d0995d0fe5221969b70a9becf606abd7901f88fbbee63816eefc7482866faccc2d323b612303

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    fasten (0.4.0)
+    fasten (0.5.0)
       binding_of_caller
       curses
+      hirb
+      parallel
 
 GEM
   remote: https://rubygems.org/
@@ -12,9 +14,10 @@ GEM
     binding_of_caller (0.8.0)
       debug_inspector (>= 0.0.1)
     coderay (1.1.2)
-    curses (1.2.4)
+    curses (1.2.5)
     debug_inspector (0.0.3)
     diff-lcs (1.3)
+    hirb (0.7.3)
     jaro_winkler (1.5.1)
     method_source (0.9.0)
     parallel (1.12.1)

data/fasten.gemspec

@@ -30,6 +30,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'binding_of_caller'
   spec.add_runtime_dependency 'curses'
+  spec.add_runtime_dependency 'hirb'
+  spec.add_runtime_dependency 'parallel'
 
   raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
 

data/lib/fasten/dag.rb

@@ -26,7 +26,7 @@ module Fasten
         update_error_task task
       end
 
-      stats_add_entry(self, task.state, task)
+      stats_add_entry(task.state, task)
     end
 
     def update_done_task(task)

data/lib/fasten/executor.rb

@@ -1,14 +1,14 @@
 module Fasten
   class Executor < Task
-    include Fasten::LogSupport
+    include Fasten::Logger
     include Fasten::DAG
     include Fasten::UI
     include Fasten::LoadSave
     include Fasten::Stats
 
-    def initialize(name: nil, workers: 8, worker_class: Fasten::Worker, fasten_dir: '.fasten')
+    def initialize(name: nil, developer: STDIN.tty? && STDOUT.tty?, workers: Parallel.physical_processor_count, worker_class: Fasten::Worker, fasten_dir: '.fasten')
       setup_stats(name)
-      super name: name || "#{self.class} #{$PID}", workers: workers, pid: $PID, state: :IDLE, worker_class: worker_class, fasten_dir: fasten_dir
+      super name: name || "#{self.class} #{$PID}", workers: workers, pid: $PID, state: :IDLE, worker_class: worker_class, fasten_dir: fasten_dir, developer: developer
       initialize_dag
 
       self.worker_list = []
@@ -30,7 +30,7 @@ module Fasten
       self.state = task_list.map(&:state).all?(:DONE) ? :DONE : :FAIL
       log_fin self, running_counters
 
-      stats_add_entry(self, state, self)
+      stats_add_entry(state, self)
       save_stats
     end
 
@@ -47,46 +47,80 @@ module Fasten
         wait_for_running_tasks
         raise_error_in_failure
         remove_workers_as_needed
-        dispatch_pending_tasks
+        if %i[PAUSING PAUSED QUITTING].include?(state)
+          check_state
+        else
+          dispatch_pending_tasks
+        end
 
-        break if no_running_tasks? && no_waiting_tasks?
+        break if no_running_tasks? && no_waiting_tasks? || state == :QUIT
       end
 
       remove_all_workers
     end
 
+    def check_state
+      if state == :PAUSING && no_running_tasks?
+        self.state = :PAUSED
+        self.ui.message = nil
+        ui.force_clear
+      elsif state == :QUITTING && no_running_tasks?
+        self.state = :QUIT
+        ui.force_clear
+      end
+    end
+
+    def should_wait_for_running_tasks?
+      tasks_running? && (no_waiting_tasks? || tasks_failed? || %i[PAUSING QUITTING].include?(state)) || task_running_list.count >= workers
+    end
+
     def wait_for_running_tasks
-      while (no_waiting_tasks? && tasks_running?) || task_running_list.count >= workers || (tasks_running? && tasks_failed?)
-        ui_update
+      while should_wait_for_running_tasks?
+        ui.update
         reads = worker_list.map(&:parent_read)
-        reads, _writes, _errors = IO.select(reads, [], [], 0.2)
+        reads, _writes, _errors = IO.select(reads, [], [], 1)
 
         receive_workers_tasks(reads)
       end
-      ui_update
+
+      ui.update
     end
 
     def receive_workers_tasks(reads)
       reads&.each do |read|
-        worker = worker_list.find { |item| item.parent_read == read }
-        task = worker.receive
+        next unless (worker = worker_list.find { |item| item.parent_read == read })
+
+        task = worker.receive_response
 
         task_running_list.delete task
 
         update_task task
 
         log_fin task, done_counters
+        ui.force_clear
       end
     end
 
     def raise_error_in_failure
       return unless tasks_failed?
 
-      remove_all_workers
+      task_error_list.each do |task|
+        log_info "task: #{task} error:#{task.error}\n#{task.error&.backtrace&.join("\n")}"
+      end
 
-      count = task_error_list.count
+      if developer
+        ui.cleanup
+        puts "Stopping because the following tasks failed:\n"
+        task_error_list.map(&:to_s).each { |x| puts "  #{x}" }
 
-      raise "Stopping because the following #{count} #{count == 1 ? 'task' : 'tasks'} failed: #{task_error_list.map(&:to_s).join(', ')}"
+        puts 'Entering development console'
+
+        Kernel.binding.pry # rubocop:disable Lint/Debugger
+      else
+        remove_all_workers
+
+        raise "Stopping because the following tasks failed: #{task_error_list.map(&:to_s).join(', ')}"
+      end
     end
 
     def remove_workers_as_needed
@@ -95,6 +129,8 @@ module Fasten
 
         worker.kill
         worker_list.delete worker
+
+        ui.force_clear
       end
     end
 
@@ -104,10 +140,13 @@ module Fasten
       unless worker
         @worker_id = (@worker_id || 0) + 1
         worker = worker_class.new executor: self, name: "#{worker_class} #{format '%02X', @worker_id}"
+        worker.block = block if block
         worker.fork
         worker_list << worker
 
         log_info "Worker created: #{worker}"
+
+        ui.force_clear
       end
 
       worker
@@ -119,15 +158,18 @@ module Fasten
 
         task = next_task
         log_ini task, "on worker #{worker}"
-        worker.dispatch(task)
+        worker.send_request(task)
         task_running_list << task
+
+        ui.force_clear
       end
     end
 
     def remove_all_workers
-      while (worker = worker_list.pop)
-        worker.kill
-      end
+      worker_list.each(&:kill)
+      worker_list.clear
+
+      ui.force_clear
     end
   end
 end

data/lib/fasten/load_save.rb

@@ -4,13 +4,17 @@ module Fasten
 
     def load(path)
       items = YAML.safe_load(File.read(path)).each do |name, params|
-        params.each do |key, val|
-          next unless val.is_a?(String) && (match = %r{^/(.+)/$}.match(val))
-
-          params[key] = Regexp.new(match[1])
+        if params.is_a? String
+          params = { after: params }
+        else
+          params&.each do |key, val|
+            next unless val.is_a?(String) && (match = %r{^/(.+)/$}.match(val))
+
+            params[key] = Regexp.new(match[1])
+          end
         end
 
-        add Fasten::Task.new({ name: name }.merge(params))
+        add Fasten::Task.new({ name: name }.merge(params || {}))
       end
 
       log_info "Loaded #{items.count} tasks from #{path}"

data/lib/fasten/{log_support.rb → logger.rb}

@@ -3,7 +3,7 @@ module Fasten
     attr_accessor :logger
   end
 
-  module LogSupport
+  module Logger
     %w[debug info error].each do |method|
       define_method "log_#{method}" do |msg|
         return unless Fasten.logger.respond_to?(method)
@@ -21,9 +21,9 @@ module Fasten
 
     def log_fin(object, message = nil)
       object.fin ||= Time.new
-      diff = object.fin - object.ini
+      object.dif = object.fin - object.ini
 
-      log_info "Done #{object.class} #{object} #{message} in #{diff}"
+      log_info "Done #{object.class} #{object} #{message} in #{object.dif}"
     end
 
     def redirect_std(path)
@@ -47,7 +47,7 @@ end
 
 Fasten.logger ||=
   begin
-    Logger.new(STDOUT, level: Logger::INFO, progname: $PROGRAM_NAME)
+    Logger.new(STDOUT, level: Logger::DEBUG, progname: $PROGRAM_NAME)
   rescue StandardError
     nil
   end

data/lib/fasten/stats.rb

@@ -11,21 +11,70 @@ module Fasten
       }
     end
 
-    def stats_add_entry(object, state, target)
+    def stats_add_entry(state, target)
       return unless target.ini && target.fin
 
       entry = stats_create_entry(state, target)
-      object.stats_data ||= []
-      object.stats_data << entry
+      self.stats_data ||= []
+      self.stats_entries ||= []
+      stats_data << entry
+      stats_entries << entry
 
-      history = stats_history(object, entry)
+      history = stats_history(entry)
 
+      update_cnt(history, entry)
       update_avg(history, entry)
       update_std(history, entry)
     end
 
-    def stats_history(object, entry)
-      object.stats_data.select { |e| e['state'] == entry['state'] && e['kind'] == entry['kind'] && e['name'] == entry['name'] }
+    FLOAT_FORMATTER = ->(f) { format('%7.3f', f) }
+
+    def stats_table_run
+      sub = stats_entries.select { |x| x['kind'] == 'task' }.map { |x| x['run'] }.sum
+      tot = stats_entries.select { |x| x['kind'] == 'executor' }.map { |x| x['run'] }.sum
+
+      [sub, tot]
+    end
+
+    def split_time(time)
+      sign = time.negative? ? '-' : ''
+      time = -time if time.negative?
+
+      hours, seconds = time.divmod(3600)
+      minutes, seconds = seconds.divmod(60)
+      seconds, decimal = seconds.divmod(1)
+      milliseconds, _ignored = (decimal.round(4) * 1000).divmod(1)
+
+      [sign, hours, minutes, seconds, milliseconds]
+    end
+
+    def hformat(time, total = nil)
+      sign, hours, minutes, seconds, milliseconds = split_time time
+
+      str = hours.zero? ? format('%.1s%02d:%02d.%03d', sign, minutes, seconds, milliseconds) : format('%.1s%02d:%02d:%02d.%03d', sign, hours, minutes, seconds, milliseconds)
+      str += format(' (%.1f%%)', 100.0 * time / total) if total
+
+      str
+    end
+
+    def stats_table
+      sub, tot = stats_table_run
+
+      Hirb::Console.render_output(stats_entries,
+                                  fields: %w[state kind name run cnt avg std], unicode: true, class: 'Hirb::Helpers::AutoTable',
+                                  filters: { 'run' => FLOAT_FORMATTER, 'avg' => FLOAT_FORMATTER, 'std' => FLOAT_FORMATTER },
+                                  description: false)
+
+      puts format('∑tasks: %<task>s ∑executed: %<executed>s saved: %<saved>s workers: %<workers>s',
+                  task: hformat(sub), executed: hformat(tot, sub), saved: hformat(sub - tot, sub), workers: workers.to_s)
+    end
+
+    def stats_history(entry)
+      stats_data.select { |e| e['state'] == entry['state'] && e['kind'] == entry['kind'] && e['name'] == entry['name'] }
+    end
+
+    def update_cnt(history, entry)
+      entry['cnt'] = history.size
     end
 
     def update_avg(history, entry)

data/lib/fasten/task.rb

@@ -1,6 +1,6 @@
 module Fasten
   class Task < OpenStruct
-    include Fasten::LogSupport
+    include Fasten::Logger
 
     def to_s
       name

data/lib/fasten/ui/console.rb

@@ -0,0 +1,58 @@
+require 'forwardable'
+
+module Fasten
+  module UI
+    class Console
+      extend Forwardable
+      def_delegators :executor, :worker_list, :task_list, :task_done_list, :task_error_list, :task_running_list, :task_waiting_list, :worker_list
+      def_delegators :executor, :name, :workers, :workers=, :state, :state=, :hformat
+
+      attr_accessor :executor
+
+      def initialize(executor:)
+        @executor = executor
+        @old = {
+          task_done_list: [],
+          task_error_list: []
+        }
+      end
+
+      def setup
+        puts <<~FIN
+
+          = == === ==== ===== ====== ======= ======== ========= ==========
+          Fasten your seatbelts! #{'💺' * workers}
+
+          #{name}
+        FIN
+
+        $stdout.sync = true
+        @setup_done = true
+      end
+
+      def update
+        setup unless @setup_done
+        display_task_message(task_done_list, @old[:task_done_list], 'Done in')
+        display_task_message(task_error_list, @old[:task_error_list], 'Fail in')
+      end
+
+      def cleanup
+        puts '========== ========= ======== ======= ====== ===== ==== === == ='
+        @setup_done = false
+      end
+
+      def force_clear; end
+
+      protected
+
+      def display_task_message(orig, old, message)
+        return unless old.count != orig.count
+
+        (orig - old).each do |task|
+          puts "Time: #{hformat Time.new - executor.ini} #{message} #{hformat task.dif} Task #{task}"
+          old << task
+        end
+      end
+    end
+  end
+end

data/lib/fasten/ui/curses.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Fasten
+  module UI
+    class Curses
+      include ::Curses
+      extend Forwardable
+      def_delegators :executor, :worker_list, :task_list, :task_done_list, :task_error_list, :task_running_list, :task_waiting_list, :worker_list
+      def_delegators :executor, :name, :workers, :workers=, :state, :state=
+
+      attr_accessor :n_rows, :n_cols, :clear_needed, :message, :executor
+
+      SPINNER_STR = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
+      SPINNER_LEN = SPINNER_STR.length
+      PROGRESSBAR_STR = ' ▏▎▍▌▋▊▉'
+      PROGRESSBAR_LEN = PROGRESSBAR_STR.length
+
+      def initialize(executor:)
+        @executor = executor
+      end
+
+      def update
+        setup unless @setup_done
+        ui_keyboard
+        clear if clear_needed
+        draw_title
+        ui_workers
+        ui_tasks
+
+        refresh
+        self.clear_needed = false
+      end
+
+      def draw_title
+        ui_text_aligned(0, :left, 'Fasten your seatbelts!')
+        ui_text_aligned(0, :center, name.to_s)
+        ui_text_aligned(0, :right, Time.new.to_s)
+      end
+
+      def cleanup
+        close_screen
+        @setup_done = nil
+      end
+
+      def setup
+        init_screen
+        self.n_rows = lines
+        self.n_cols = cols
+        stdscr.keypad = true
+        stdscr.nodelay = true
+        setup_color
+        noecho
+        cbreak
+        nonl
+        curs_set 0
+        @setup_done = true
+      end
+
+      def setup_color
+        start_color
+        use_default_colors
+
+        init_pair 1, Curses::COLOR_YELLOW, -1
+        init_pair 2, Curses::COLOR_GREEN, -1
+        init_pair 3, Curses::COLOR_RED, -1
+        init_pair 4, Curses::COLOR_WHITE, -1
+      end
+
+      def ui_text_aligned(row, align, str, attrs = nil)
+        if align == :center
+          setpos row, (n_cols - str.length) / 2
+        elsif align == :right
+          setpos row, n_cols - str.length
+        else
+          setpos row, 0
+        end
+
+        attrset attrs if attrs
+        addstr str
+        attroff attrs if attrs
+
+        str.length
+      end
+
+      def force_clear
+        self.clear_needed = true
+      end
+
+      def ui_keyboard
+        return unless (key = stdscr.getch)
+
+        self.message = nil
+
+        if key == Curses::Key::LEFT
+          if workers <= 1
+            self.message = "Can't remove 1 worker left, press [P] to pause"
+          else
+            self.workers -= 1
+            self.message = "Decreasing max workers to #{workers}"
+          end
+        elsif key == Curses::Key::RIGHT
+          self.workers += 1
+          self.message = "Increasing max workers to #{workers}"
+        elsif key == 'q'
+          self.message = 'Will quit when running tasks end'
+          self.state = :QUITTING
+        elsif key == 'p'
+          self.message = 'Will pause when running tasks end'
+          self.state = :PAUSING
+        elsif key == 'r'
+          self.state = :RUNNING
+        end
+
+        force_clear
+      end
+
+      def ui_workers_summary
+        running_count = task_running_list.count
+        waiting_count = task_waiting_list.count
+        workers_count = worker_list.count
+
+        "Procs: #{running_count} run #{workers_count - running_count} idle #{workers} max #{waiting_count} wait"
+      end
+
+      def ui_workers
+        l = ui_text_aligned(1, :left, ui_workers_summary) + 1
+
+        worker_list.each_with_index do |worker, index|
+          setpos 1, l + index
+          attrs = worker.running? ? A_STANDOUT : color_pair(4) | A_DIM
+          attrset attrs
+          addstr worker.running? ? 'R' : '_'
+          attroff attrs
+        end
+
+        ui_state
+      end
+
+      def ui_state
+        if state == :RUNNING
+          attrs = color_pair(2)
+        elsif state == :PAUSING
+          attrs = color_pair(1) | A_BLINK | A_STANDOUT
+        elsif state == :PAUSED
+          attrs = color_pair(1) | A_STANDOUT
+        elsif state == :QUITTING
+          attrs = color_pair(3) | A_BLINK | A_STANDOUT
+        end
+
+        l = ui_text_aligned(1, :right, state.to_s, attrs)
+        return unless message
+
+        setpos 1, n_cols - l - message.length - 1
+        addstr message
+      end
+
+      def ui_progressbar(row, col_ini, col_fin, count, total)
+        slice = total.to_f / (col_fin - col_ini + 1)
+        col_ini.upto col_fin do |col|
+          setpos row, col
+          count -= slice
+          if count.positive?
+            addstr PROGRESSBAR_STR[-1]
+          elsif count > -slice
+            addstr PROGRESSBAR_STR[(count * PROGRESSBAR_LEN / slice) % PROGRESSBAR_LEN]
+          else
+            addstr '.'
+          end
+        end
+      end
+
+      def ui_task_icon(task)
+        case task.state
+        when :RUNNING
+          SPINNER_STR[task.worker&.spinner]
+        when :FAIL
+          '✘'
+        when :DONE
+          '✔'
+        else
+          '…'
+        end
+      end
+
+      def ui_task_color(task)
+        case task.state
+        when :RUNNING
+          color_pair(1) | A_TOP
+        when :FAIL
+          color_pair(3) | A_TOP
+        when :DONE
+          color_pair(2) | A_TOP
+        else
+          color_pair(4) | A_TOP
+        end
+      end
+
+      def ui_task_string(task, y, x, icon: nil, str: nil)
+        setpos y, x
+
+        attrs = ui_task_color(task)
+        icon = ui_task_icon(task) if icon
+
+        str ||= icon ? "#{icon} #{task}" : task.to_s
+
+        attrset attrs if attrs
+        addstr str
+        attroff attrs if attrs
+
+        x + str.length
+      end
+
+      def ui_tasks
+        worker_list.each do |worker|
+          worker.spinner = (worker.spinner + 1) % SPINNER_LEN if worker.running?
+        end
+
+        count_done = task_done_list.count
+        count_total = task_list.count
+        tl = count_total.to_s.length
+        col_ini = ui_text_aligned(2, :left, format("Tasks: %#{tl}d/%d", count_done, count_total)) + 1
+        col_fin = n_cols - 5
+        ui_text_aligned(2, :right, "#{(count_done * 100 / count_total).to_i}%") if count_total.positive?
+
+        ui_progressbar(2, col_ini, col_fin, count_done, count_total)
+
+        max = 2
+        list = task_list.sort_by(&:run_score)
+        list.each_with_index do |task, index|
+          next if 3 + index >= n_rows
+
+          x = ui_task_string(task, 3 + index, 2, icon: true)
+          max = x if x > max
+        end
+
+        list.each_with_index do |task, index|
+          next if 3 + index >= n_rows
+
+          if task.dif
+            setpos 3 + index, max + 2
+            ui_task_string(task, 3 + index, max + 2, str: format('%.2f s', task.dif))
+          elsif task.depends && !task.depends.empty?
+            setpos 3 + index, max
+            x = max + 2
+            addstr ':'
+            task.depends.each do |dependant_task|
+              x = ui_task_string(dependant_task, 3 + index, x) + 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fasten/ui.rb

@@ -1,166 +1,18 @@
-# frozen_string_literal: true
+require 'fasten/ui/console'
+require 'fasten/ui/curses'
 
 module Fasten
   module UI
-    include Curses
-
-    SPINNER_STR = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
-    SPINNER_LEN = SPINNER_STR.length
-    PROGRESSBAR_STR = ' ▏▎▍▌▋▊▉'
-    PROGRESSBAR_LEN = PROGRESSBAR_STR.length
+    def ui
+      @ui ||= STDIN.tty? && STDOUT.tty? ? Fasten::UI::Curses.new(executor: self) : Fasten::UI::Console.new(executor: self)
+    end
 
     def run_ui
-      ui_setup
-      ui_title
-      ui_workers
+      ui.update
 
       yield
     ensure
-      close_screen
-    end
-
-    def ui_setup
-      init_screen
-      self.ui_rows = lines
-      self.ui_cols = cols
-      ui_setup_color
-      noecho
-      cbreak
-      nonl
-      curs_set 0
-    end
-
-    def ui_setup_color
-      start_color
-      use_default_colors
-      init_pair 1, Curses::COLOR_YELLOW, -1
-      init_pair 2, Curses::COLOR_GREEN, -1
-      init_pair 3, Curses::COLOR_RED, -1
-      init_pair 4, Curses::COLOR_WHITE, -1
-    end
-
-    def ui_text_aligned(row, align, str, attrs = nil)
-      if align == :center
-        setpos row, (ui_cols - str.length) / 2
-      elsif align == :right
-        setpos row, ui_cols - str.length
-      else
-        setpos row, 0
-      end
-
-      attrset attrs if attrs
-      addstr str
-      attroff attrs if attrs
-
-      str.length
-    end
-
-    def ui_title
-      ui_text_aligned(0, :left, 'Fasten your seatbelts!')
-      ui_text_aligned(0, :center, name.to_s)
-      ui_text_aligned(0, :right, Time.new.to_s)
-    end
-
-    def ui_update
-      clear
-      ui_title
-      ui_workers
-      ui_tasks
-
-      refresh
-    end
-
-    def ui_workers_summary
-      "Procs: #{task_running_list.count} run #{worker_list.count - task_running_list.count} idle #{workers} max"
-    end
-
-    def ui_workers
-      l = ui_text_aligned(1, :left, ui_workers_summary) + 1
-
-      worker_list.each_with_index do |worker, index|
-        setpos 1, l + index
-        attrs = worker.running? ? A_STANDOUT : color_pair(4) | A_DIM
-        attrset attrs
-        addstr worker.running? ? 'R' : '_'
-        attroff attrs
-      end
-    end
-
-    def ui_progressbar(row, col_ini, col_fin, count, total)
-      slice = total.to_f / (col_fin - col_ini + 1)
-      col_ini.upto col_fin do |col|
-        setpos row, col
-        count -= slice
-        if count.positive?
-          addstr PROGRESSBAR_STR[-1]
-        elsif count > -slice
-          addstr PROGRESSBAR_STR[(count * PROGRESSBAR_LEN / slice) % PROGRESSBAR_LEN]
-        else
-          addstr '.'
-        end
-      end
-    end
-
-    def ui_task_string(task, y, x, icon: nil)
-      setpos y, x
-
-      case task.state
-      when :RUNNING
-        attrs = color_pair(1) | A_TOP
-        icon = SPINNER_STR[task.worker&.spinner] if icon
-      when :FAIL
-        attrs = color_pair(3)
-        icon = '✘︎' if icon
-      when :DONE
-        attrs = color_pair(2)
-        icon = '✔︎' if icon
-      else
-        attrs = color_pair(4) | A_DIM
-        icon = '…' if icon
-      end
-
-      str = icon ? "#{icon} #{task}" : task.to_s
-
-      attrset attrs if attrs
-      addstr str
-      attroff attrs if attrs
-
-      x + str.length
-    end
-
-    def ui_tasks
-      worker_list.each do |worker|
-        worker.spinner = (worker.spinner + 1) % SPINNER_LEN if worker.running?
-      end
-
-      count_done = task_done_list.count
-      count_total = task_list.count
-      tl = count_total.to_s.length
-      col_ini = ui_text_aligned(2, :left, format("Tasks: %#{tl}d/%s", count_done, count_total)) + 1
-      col_fin = ui_cols - 5
-      ui_text_aligned(2, :right, "#{(count_done * 100/count_total).to_i}%") if count_total.positive?
-
-      ui_progressbar(2, col_ini, col_fin, count_done, count_total)
-
-      max = 2
-      list = task_list.sort_by(&:run_score)
-      list.each_with_index do |task, index|
-        next if 3 + index >= ui_rows
-
-        x = ui_task_string(task, 3 + index, 2, icon: true)
-        max = x if x > max
-      end
-
-      list.each_with_index do |task, index|
-        next if 3 + index >= ui_rows || task.depends.nil? || task.depends.empty?
-
-        setpos 3 + index, max
-        x = max + 2
-        addstr ':'
-        task.depends.each do |dependant_task|
-          x = ui_task_string(dependant_task, 3 + index, x) + 1
-        end
-      end
+      ui.cleanup
     end
   end
 end

data/lib/fasten/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fasten
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/fasten/worker.rb

@@ -1,13 +1,38 @@
 module Fasten
+  class WorkerError < StandardError
+    attr_reader :backtrace
+
+    def initialize(origin)
+      super "#{origin.class} #{origin.message}"
+      @backtrace = origin.backtrace
+    end
+  end
+
   class Worker < Task
-    include Fasten::LogSupport
+    include Fasten::Logger
 
     def initialize(executor:, name: nil)
       super executor: executor, name: name, spinner: 0
     end
 
     def perform(task)
-      system task.shell if task.shell
+      perform_shell(task) if task.shell
+      perform_ruby(task) if task.ruby
+      perform_block(task) if block
+    end
+
+    def perform_ruby(task)
+      task.response = eval task.ruby # rubocop:disable Security/Eval we trust our users ;-)
+    end
+
+    def perform_shell(task)
+      result = system task.shell
+
+      raise "Command failed with exit code: #{$CHILD_STATUS.exitstatus}" unless result
+    end
+
+    def perform_block(task)
+      task.response = block.call(task.request)
     end
 
     def fork
@@ -16,20 +41,20 @@ module Fasten
       self.pid = Process.fork do
         close_parent_pipes
 
-        process_incoming_tasks
+        process_incoming_requests
       end
 
       close_child_pipes
     end
 
-    def dispatch(task)
+    def send_request(task)
       Marshal.dump(Task.new(task.to_h.merge(depends: nil, dependants: nil)), parent_write)
       self.running_task = task
       task.worker = self
       task.state = :RUNNING
     end
 
-    def receive
+    def receive_response
       updated_task = Marshal.load(parent_read) # rubocop:disable Security/MarshalLoad because pipe is a secure channel
 
       %i[ini fin response error].each { |key| running_task[key] = updated_task[key] }
@@ -74,14 +99,14 @@ module Fasten
       child_write.close unless child_write.closed?
     end
 
-    def process_incoming_tasks
-      log_ini self, 'process_incoming_tasks'
+    def process_incoming_requests
+      log_ini self, 'process_incoming_requests'
 
       while (object = Marshal.load(child_read)) # rubocop:disable Security/MarshalLoad because pipe is a secure channel
         run_task(object) if object.is_a? Fasten::Task
       end
 
-      log_fin self, 'process_incoming_tasks'
+      log_fin self, 'process_incoming_requests'
     rescue EOFError
       log_info 'Terminating on EOF'
     end
@@ -102,12 +127,17 @@ module Fasten
       log_ini task, 'perform'
 
       perform(task)
-
-      log_fin task, 'perform'
-      Marshal.dump(task, child_write)
     rescue StandardError => error
-      task.error = error
-      Marshal.dump(task, child_write)
+      task.error = WorkerError.new(error)
+    ensure
+      log_fin task, 'perform'
+      send_response(task)
+    end
+
+    def send_response(task)
+      log_info "Sending task response back to executor #{task}"
+      data = Marshal.dump(task)
+      child_write.write(data)
     end
   end
 end

data/lib/fasten.rb

@@ -8,8 +8,10 @@ require 'ostruct'
 require 'curses'
 require 'fileutils'
 require 'csv'
+require 'hirb'
+require 'parallel'
 
-require 'fasten/log_support'
+require 'fasten/logger'
 require 'fasten/stats'
 require 'fasten/task'
 require 'fasten/ui'
@@ -21,7 +23,7 @@ require 'fasten/version'
 
 module Fasten
   class << self
-    include Fasten::LogSupport
+    include Fasten::Logger
 
     def load(path, **options)
       executor = Fasten::Executor.new(**options)
@@ -29,5 +31,19 @@ module Fasten
 
       executor
     end
+
+    def map(list, **options, &block)
+      executor = Fasten::Executor.new(**options)
+      executor.block = block
+
+      list.each do |item|
+        executor.add Fasten::Task.new name: item.to_s, request: item
+      end
+
+      executor.perform
+      executor.stats_table
+
+      executor.task_list.map(&:response)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fasten
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Aldrin Martoq
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2018-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: hirb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Fasten your seatbelts! Run jobs in parallel, intelligently.
 email:
 - contacto@a0.cl
@@ -134,10 +162,12 @@ files:
 - lib/fasten/dag.rb
 - lib/fasten/executor.rb
 - lib/fasten/load_save.rb
-- lib/fasten/log_support.rb
+- lib/fasten/logger.rb
 - lib/fasten/stats.rb
 - lib/fasten/task.rb
 - lib/fasten/ui.rb
+- lib/fasten/ui/console.rb
+- lib/fasten/ui/curses.rb
 - lib/fasten/version.rb
 - lib/fasten/worker.rb
 homepage: https://github.com/a0/fasten/