run_tasks 1.7.6 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42142bd1919ce9f61fb6df67f5f7dcf7213145ee
-  data.tar.gz: 31771d47371d92754667f988c76101d0e8f3d27e
+  metadata.gz: 651b53b567a43d2b6b660b7df04eb1f29402cc01
+  data.tar.gz: 48e8c2c044195c180818179dc654a06070180350
 SHA512:
-  metadata.gz: 383f68e5b67d0a0117be4aca5a82b97019d62a8de2ba8919feb98a08f1c9b470bf26eec353940c6a669834f375cf3df9849c6a9328dfff22d085ac76c45948eb
-  data.tar.gz: 3132a335135485e784fc10d6ffa513bcc27e53aa9d0d964c19f78579b0a7b27f815e34c7d165a8c5168d71f2f279be34737c09615754d50ff0db45e05795de9d
+  metadata.gz: b44b338980d23b2beb8fd2aff9ceb53116ff33c7b6496c2d40a864ac2cb103999a28d4dd3d7f89d976624599ed7fdec46d6d0cd367e73b92486c4593d1735c65
+  data.tar.gz: 16afb42816e127b41360fd3df15798de29234c4032e0a3354603437f1082d16eb5514325724a8abab6e00b7633a91121c416648ee8751951e4bab6e3f0175df9

data/bin/run

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
 
-require_relative '../src/run'
+require_relative '../src/bootstrap'

data/src/bootstrap.rb

@@ -0,0 +1,88 @@
+require "digest"
+require "fileutils"
+require "io/console"
+require "readline"
+require "rubygems"
+require "securerandom"
+
+# Require all files.
+Dir.glob(
+  File.join(__dir__, "{monkey,gemspec,markdown,version,run}", "**", "*.rb"),
+  &method(:require)
+)
+
+# Check for new versions.
+Run::Core::VerifyRunVersion.run
+
+# Expose global methods.
+[:task, :run].each do |name|
+  define_method name do |*args, **options, &block|
+    if options.size == 0
+      Run::Core.send(name, *args, &block)
+    else
+      Run::Core.send(name, *args, **options, &block)
+    end
+  end
+end
+
+# Define global tasks.
+task :rspec do |path|
+  command = "bundle exec rspec"
+
+  if path.include?(":")
+    run "#{command} #{path}"
+  else
+    run "#{command} #{expand(File.directory?(path) ? "#{path}/**/*" : path)}"
+  end
+end
+
+# Expose helpers.
+Dir.glob(File.join(__dir__, "run", "helper", "*.rb")) do |path|
+  filename = File.basename(path, ".rb")
+  classname = filename.split('_').map(&:capitalize).join
+  helper = Object.const_get("Run::Helper::#{classname}")
+  name = filename.slice(0, filename.size - 7)
+  define_method(name) do |*args, **options, &block|
+    if options.size == 0
+      helper.new(*args).run(&block)
+    else
+      helper.new(*args, **options).run(&block)
+    end
+  end
+end
+
+# @param error [StandardError]
+# @return [void]
+def format_error(error)
+  puts "· #{error.message}".red
+  puts "· #{error.backtrace[0]}".red
+  puts "· #{error.backtrace[1]}".red
+  puts "· #{error.backtrace[2]}".red
+end
+
+# Run Run.
+begin
+  Run::Core.run_run
+rescue Run::Error::UnknownTask => error
+  puts error.message.red
+  exit 2
+rescue Interrupt
+  exit 3
+rescue SyntaxError => error
+  format_error error
+  exit 5
+rescue ArgumentError => error
+  format_error error
+  exit 6
+rescue Run::Error::NonExistingRunfile
+  puts "Runfile.rb does not exist in '#{Dir.pwd}'".red
+  exit 7
+rescue Run::Error::Aborted => error
+  exit 9
+rescue Run::Error::ExistingTask => error
+  puts error.message.red
+  exit 10
+rescue => error
+  format_error error
+  exit 4
+end

data/src/gemspec/metadata.rb

@@ -0,0 +1,23 @@
+module Gemspec
+  class Metadata
+    # @param lib_name [String]
+    def initialize(lib_name)
+      @lib_name = lib_name
+    end
+
+    # @return [Hash]
+    def read
+      @_read ||= (
+        path = "#{__dir__}/../../#{@lib_name}.gemspec"
+
+        # Development.
+        if File.exist?(path)
+          Gem::Specification::load(path)
+        # Production.
+        else
+          Gem::Specification::find_by_name(@lib_name) rescue nil
+        end
+      )
+    end
+  end
+end

data/src/{run/markdown → markdown}/abstract_tag.rb

@@ -7,7 +7,7 @@ module Markdown
       when AbstractTag
         @tag = value
       else
-        raise "Invalid value of '#{value.class.name}' class"
+        raise ArgumentError.new("Invalid value of '#{value.class.name}' class")
       end
     end
 
@@ -23,7 +23,7 @@ module Markdown
 
       loop do
         string = string.sub(pattern) do
-          Regexp.last_match[1] + replace_by(Regexp.last_match[2]) + Regexp.last_match[3]
+          Regexp.last_match[1] + convert(Regexp.last_match[2]) + Regexp.last_match[3]
         end
         break if !Regexp.last_match
       end
@@ -33,12 +33,15 @@ module Markdown
 
     protected
 
+    # @return [Array<String>]
     def tokens
-      raise "Not implemented"
+      raise NotImplementedError.new
     end
 
-    def replace_by(string)
-      raise "Not implemented"
+    # @param string [String]
+    # @return [String]
+    def convert(string)
+      raise NotImplementedError.new
     end
   end
 end

data/src/{run/markdown → markdown}/bold_tag.rb

@@ -1,17 +1,19 @@
 require_relative "./abstract_tag"
-require_relative "../string"
 
 module Markdown
-  class Bold
+  class BoldTag
     include AbstractTag
 
     protected
 
+    # @return [Array<String>]
     def tokens
-      ['**', '__']
+      ["**", "__"]
     end
 
-    def replace_by(string)
+    # @param string [String]
+    # @return [String]
+    def convert(string)
       string.bold
     end
   end

data/src/{run/markdown → markdown}/code_tag.rb

@@ -1,17 +1,19 @@
 require_relative "./abstract_tag"
-require_relative "../string"
 
 module Markdown
-  class Code
+  class CodeTag
     include AbstractTag
 
     protected
 
+    # @return [Array<String>]
     def tokens
-      ['`']
+      ["`"]
     end
 
-    def replace_by(string)
+    # @param string [String]
+    # @return [String]
+    def convert(string)
       string.cyan
     end
   end

data/src/{run/markdown → markdown}/engine.rb

@@ -10,13 +10,8 @@ module Markdown
 
     def to_ansi
       # The tags are ordered by priority.
-      # E.g. `Bold` should run before `Italic`.
-      tag = Code.new(
-              Italic.new(
-                Bold.new(@string)
-              )
-            )
-      tag.to_ansi
+      # For example: `Bold` should run before `Italic`.
+      CodeTag.new(ItalicTag.new(BoldTag.new(@string))).to_ansi
     end
   end
 end

data/src/{run/markdown → markdown}/italic_tag.rb

@@ -1,17 +1,19 @@
 require_relative "./abstract_tag"
-require_relative "../string"
 
 module Markdown
-  class Italic
+  class ItalicTag
     include AbstractTag
 
     protected
 
+    # @return [Array<String>]
     def tokens
-      ['*', '_']
+      ["*", "_"]
     end
 
-    def replace_by(string)
+    # @param string [String]
+    # @return [String]
+    def convert(string)
       string.italic
     end
   end

data/src/{run → monkey}/string.rb

@@ -1,5 +1,4 @@
 # https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
-
 class String
   @@styles = {
     :bold              => "1",

data/src/run/core/help.rb

@@ -0,0 +1,125 @@
+require "ripper"
+
+module Run
+  module Core
+    module Help
+      # @return [String]
+      def self.run(contents)
+        tasks = extract_tasks(contents)
+        help_verbatims = extract_help_verbatims(contents, tasks)
+        tasks_column_length = compute_tasks_column_length(tasks)
+
+        output = help_verbatims.reduce("") do |output, help_verbatim|
+          name_verbatim = help_verbatim[:names].sort.join(", ")
+          name_verbatim = " #{name_verbatim}".yellow +
+                          " " * (tasks_column_length - name_verbatim.size - 1)
+
+          help_verbatim[:comments].each_with_index do |comment, comment_line|
+            split_comment = split_verbatim(
+              comment,
+              STDOUT.winsize[1] - tasks_column_length - 2
+            )
+            if split_comment.size > 0
+              split_comment.map.with_index do |chunk, chunk_line|
+                text = comment_line == 0 && chunk_line == 0 ?
+                       name_verbatim :
+                       " " * tasks_column_length
+                text += chunk
+                output += "#{Markdown::Engine.new(text).to_ansi}\n"
+              end
+            else
+              output += "#{Markdown::Engine.new(name_verbatim).to_ansi}\n"
+            end
+          end
+
+          output
+        end
+
+        puts output
+      end
+
+      private
+
+      # @param contents [String]
+      # @param tasks [Array<Hash>]
+      # @return [Array<Hash>]
+      def self.extract_help_verbatims(contents, tasks)
+        lines = contents.lines.map(&:chomp)
+
+        tasks.map do |names:, line:|
+          lines_to_scan = (0..(line - 2 < 0 ? 0 : line - 2)).to_a.reverse
+          {
+            names: names,
+            comments: lines_to_scan.each_with_object([]) do |current_line, comments|
+              match = /^\s*#\s*(?<comment>.*?)\s*$/.match(lines[current_line])
+              break comments if !match
+              comments << match[:comment]
+            end.reverse
+          }
+        end
+      end
+
+      # @param contents [String]
+      # @return [Array<Hash>]
+      def self.extract_tasks(contents)
+        Ripper.sexp(contents)[1].each_with_object([]) do |(id, sexp), tasks|
+          next if id != :method_add_block || sexp.fetch(1, nil)&.fetch(1, nil) != "task"
+
+          names = case sexp[2][1][0][0]
+                  when :symbol_literal
+                    [sexp[2][1][0][1][1][1].to_sym]
+                  when :array
+                    sexp[2][1][0][1].map{ |tokens| tokens[1][1][1].to_sym }.sort
+                  else
+                    raise "Unsupported task name type"
+                  end
+
+          line = case sexp[2][1][0][0]
+                 when :symbol_literal
+                   sexp[2][1][0][1][1][2][0]
+                 when :array
+                   sexp[2][1][0][1][0][1][1][2][0]
+                 else
+                   raise "Unsupported task name type"
+                 end
+
+          tasks << {
+            names: names,
+            line: line,
+          }
+        end.sort do |a, b|
+          a[:names].first <=> b[:names].first
+        end
+      end
+
+      # @param tasks [Array<Hash>]
+      # @return [Integer]
+      def self.compute_tasks_column_length(tasks)
+        tasks
+          .map do |item|
+            item[:names].join(", ")
+          end
+          .reduce(0) do |max, name|
+            next max if name.size <= max
+            name.size
+          end + 2
+      end
+
+      # @param verbatim [String]
+      # @param available_length [Integer]
+      # @return [Array<String>]
+      def self.split_verbatim(verbatim, available_length)
+        verbatim.split(/\s+/).each_with_object([]) do |word, lines|
+          line = lines.pop || ""
+          if (line + word).size > available_length
+            lines << line
+            line = word
+          else
+            line += line.size == 0 ? word : " #{word}"
+          end
+          lines << line
+        end
+      end
+    end
+  end
+end

data/src/run/core/verify_run_version.rb

@@ -0,0 +1,24 @@
+module Run
+  module Core
+    module VerifyRunVersion
+      REMOTE_GEMSPEC_URL = "https://raw.githubusercontent.com/pyrsmk/run/master/run_tasks.gemspec"
+
+      # @return [void]
+      def self.run
+        local_version = Version::Semver.new(
+          Version::LocalGemspecVersion.new(Gemspec::Metadata.new("run_tasks")).extract
+        )
+        remote_version = Version::Semver.new(
+          Version::RemoteGemspecVersion.new(REMOTE_GEMSPEC_URL).extract
+        )
+        if local_version.major == remote_version.major && local_version < remote_version
+          puts
+          puts " A new version of Run is available: #{remote_version}".yellow.bright
+          puts " Please update with: `gem update run_tasks`".yellow.bright
+          puts
+        end
+      rescue Version::UnreachableError
+      end
+    end
+  end
+end

data/src/run/core.rb

@@ -0,0 +1,98 @@
+module Run
+  module Core
+    RUNFILE_FILENAME = "Runfile.rb"
+    RESERVED_TASK_NAMES = ["help", "version"]
+    @@tasks = []
+
+    # @return [void]
+    def self.run_run
+      raise Run::Error::NonExistingRunfile.new if !File.exists?(RUNFILE_FILENAME)
+      require "./#{RUNFILE_FILENAME}"
+      run_requested_task if !display_help_if_needed
+    end
+
+    # @param task_name_or_command [Symbol, String]
+    # @param arguments [Array] Optional arguments sent to the task.
+    # @param options [Hash] Optional options sent to the task.
+    # @return [void]
+    def self.run(task_name_or_command, *arguments, **options)
+      if task_name_or_command.is_a?(Symbol)
+        run_block_task(task_name_or_command, *arguments, **options)
+      else
+        run_system_task(task_name_or_command)
+      end
+    end
+
+    # @param names [Array<Symbol> | Symbol]
+    # @param block [Proc]
+    # @return [void]
+    def self.task(names, &block)
+      names = !names.is_a?(Array) ? [names] : names
+
+      names.each do |name|
+        if !name.is_a?(Symbol)
+          raise ArgumentError.new("'name' must be a Symbol or an Array of Symbol")
+        end
+        raise Run::Error::ExistingTask.new(name) if task_exist?(name)
+        raise Run::Error::ReservedTaskName.new(name) if RESERVED_TASK_NAMES.include?(name)
+      end
+
+      @@tasks << {
+        names: names,
+        task: Run::Task::BlockTask.new(&block),
+      }
+    end
+
+    private
+
+    # @return [Boolean]
+    def self.display_help_if_needed
+      if ARGV.size == 0 || (ARGV.size == 1 && ["help", "version"].include?(ARGV[0]))
+        puts
+        puts " Run v#{Gemspec::Metadata.new("run_tasks").read.version}".bright_blue
+        puts
+        Run::Core::Help.run(File.read("./#{RUNFILE_FILENAME}"))
+        return true
+      end
+      false
+    end
+
+    # @return [void]
+    def self.run_requested_task
+      name = ARGV[0].gsub('-', '_').to_sym # Auto-replace hyphens to underscores.
+      raise Run::Error::UnknownTask.new(name) if !task_exist?(name)
+
+      # Cast value to the right type.
+      args = ARGV.slice(1, ARGV.size - 1).map do |arg|
+        value = Float(arg) rescue nil
+        next value if !value.nil?
+        next true if arg == "true"
+        next false if arg == "false"
+        next arg.to_sym if arg.match?(/^\w+$/)
+        arg
+      end
+
+      run name, *args
+    end
+
+    # @param name [Symbol]
+    # @return [Boolean]
+    def self.task_exist?(name)
+      !!@@tasks.find_index{ |item| item[:names].include? name }
+    end
+
+    # @param name [Symbol]
+    # @param args [Array]
+    # @param options [Hash]
+    # @return [void]
+    def self.run_block_task(name, *args, **options)
+      @@tasks.find{ |item| item[:names].include? name }[:task].run(*args, **options)
+    end
+
+    # @param name [Symbol]
+    # @return [void]
+    def self.run_system_task(name)
+      Run::Task::SystemTask.new(name).run
+    end
+  end
+end

data/src/run/error/aborted.rb

@@ -0,0 +1,6 @@
+module Run
+  module Error
+    class Aborted < StandardError
+    end
+  end
+end

data/src/run/error/existing_task.rb

@@ -0,0 +1,10 @@
+module Run
+  module Error
+    class ExistingTask < StandardError
+      # @param name [String]
+      def initialize(name)
+        super "'#{name}' task already exists"
+      end
+    end
+  end
+end

data/src/run/error/non_existing_runfile.rb

@@ -0,0 +1,6 @@
+module Run
+  module Error
+    class NonExistingRunfile < StandardError
+    end
+  end
+end

data/src/run/error/reserved_task_name.rb

@@ -0,0 +1,10 @@
+module Run
+  module Error
+    class ReservedTaskName < StandardError
+      # @param name [String]
+      def initialize(name)
+        super "'#{name}' task name is reserved"
+      end
+    end
+  end
+end

data/src/run/error/unknown_task.rb

@@ -0,0 +1,10 @@
+module Run
+  module Error
+    class UnknownTask < StandardError
+      # @param name [String]
+      def initialize(name)
+        super "Unknown '#{name}' task"
+      end
+    end
+  end
+end

data/src/run/helper/are_you_sure_helper.rb

@@ -0,0 +1,24 @@
+module Run
+  module Helper
+    class AreYouSureHelper
+      # @param message [String]
+      def initialize(message = "Are you sure?")
+        raise ArgumentError.new("'message' must be a String") if !message.is_a?(String)
+        @message = message
+      end
+
+      # @return [void]
+      def run
+        puts "#{@message.yellow.bold} [yN]"
+        raise Run::Error::Aborted.new unless answer == "y"
+      end
+
+      private
+
+      # @return [String, Nil]
+      def answer
+        STDIN.gets.chomp.downcase.chars.first
+      end
+    end
+  end
+end

data/src/run/helper/catch_interruption_helper.rb

@@ -0,0 +1,20 @@
+module Run
+  module Helper
+    class CatchInterruptionHelper
+      # @param command [String]
+      # @param &block [Proc]
+      def initialize(command, &block)
+        @command = command
+        @block = block
+      end
+
+      # @return [void]
+      def run
+        Run::Task::SystemTask.new(@command).run
+      rescue Interrupt
+      ensure
+        @block&.call
+      end
+    end
+  end
+end

data/src/run/helper/expand_helper.rb

@@ -0,0 +1,22 @@
+require "shellwords"
+
+module Run
+  module Helper
+    class ExpandHelper
+      # @param glob [String]
+      def initialize(glob)
+        @glob = glob
+      end
+
+      # @return [String] space-separated list of found paths
+      def run
+        Dir.glob(@glob)
+           .each_with_object([]) do |path, paths|
+             next if File.directory?(path)
+             paths << File.realpath(path).shellescape
+           end
+           .join(" ")
+      end
+    end
+  end
+end

data/src/run/helper/menu_helper.rb

@@ -0,0 +1,43 @@
+require "tty-prompt"
+
+module Run
+  module Helper
+    class MenuHelper
+      # @param text [String]
+      # @param choices [Array | Hash]
+      def initialize(text, choices)
+        raise ArgumentError.new("'text' must be a String") if !text.is_a?(String)
+
+        @text = text
+        @choices = format_choices(choices)
+      end
+
+      # @return [any]
+      def run
+        TTY::Prompt.new.select(@text.bright_yellow, show_help: "never") do |menu|
+          @choices.each do |(label, value)|
+            menu.choice(name: label, value: value)
+          end
+        end
+      end
+
+      private
+
+      # @param choices [Array, Hash]
+      # @return [Hash]
+      def format_choices(choices)
+        if !choices.is_a?(Array) && !choices.is_a?(Hash)
+          raise ArgumentError.new("'choices' must be an Array or an Hash")
+        end
+
+        if choices.is_a?(Array)
+          return choices.each_with_object({}) do |value, hash|
+            hash[value] = value
+          end
+        end
+
+        choices
+      end
+    end
+  end
+end

data/src/run/helper/pause_helper.rb

@@ -0,0 +1,10 @@
+module Run
+  module Helper
+    class PauseHelper
+      # @return [void]
+      def run
+        STDIN.gets("\n")
+      end
+    end
+  end
+end

data/src/run/helper/wait_for_interruption_helper.rb

@@ -0,0 +1,16 @@
+module Run
+  module Helper
+    class WaitForInterruptionHelper
+      # @param &block [Proc]
+      def initialize(&block)
+        @block = block
+      end
+
+      # @return [void]
+      def run
+        STDIN.gets while true
+        @block.call
+      end
+    end
+  end
+end

data/src/run/task/block_task.rb

@@ -0,0 +1,21 @@
+module Run
+  module Task
+    class BlockTask
+      # @param &block [Proc]
+      def initialize(&block)
+        @block = block
+      end
+
+      # @param arguments [Array]
+      # @param options [Hash]
+      # @return [void]
+      def run(*arguments, **options)
+        if options.size == 0
+          @block.call *arguments
+        else
+          @block.call *arguments, **options
+        end
+      end
+    end
+  end
+end

data/src/run/task/system_task.rb

@@ -0,0 +1,31 @@
+module Run
+  module Task
+    class SystemTask
+      # @param command [String]
+      def initialize(command)
+        @command = command
+      end
+
+      # @param arguments [Array] (unused)
+      # @param options [Hash] (unused)
+      # @return [void]
+      def run(*arguments, **options)
+        puts ">".bright_blue + " #{@command}".bright_white
+        puts
+
+        case system(@command)
+        when false
+          puts "The command has exited with return code: #{$?.exitstatus}.".magenta
+          puts
+          raise Interrupt.new
+        when nil
+          puts "The command has failed.".magenta
+          puts
+          raise Interrupt.new
+        end
+
+        puts
+      end
+    end
+  end
+end

data/src/version/local_gemspec_version.rb

@@ -0,0 +1,13 @@
+module Version
+  class LocalGemspecVersion
+    # @param gemspec [Gemspec::Metadata]
+    def initialize(gemspec)
+      @gemspec = gemspec
+    end
+
+    # @return [String]
+    def extract
+      @gemspec.read.version.to_s
+    end
+  end
+end

data/src/version/remote_gemspec_version.rb

@@ -0,0 +1,21 @@
+require "open-uri"
+require "socket"
+
+module Version
+  class RemoteGemspecVersion
+    # @param url [String]
+    def initialize(url)
+      @url = url
+    end
+
+    # @return [String]
+    def extract
+      contents = URI.parse(@url).open.read
+      matches = /^\s*s.version\s*=\s*"(.+?)"\s*$/.match(contents)
+      raise UnreachableError.new if matches.nil?
+      matches[1]
+    rescue SocketError
+      raise UnreachableError.new
+    end
+  end
+end

data/src/version/semver.rb

@@ -0,0 +1,62 @@
+module Version
+  class Semver
+    # @return [String]
+    def initialize(version)
+      match = /^(\d+)\.(\d+)\.(\d+)$/.match(version)
+      raise ArgumentError.new("Invalid SEMVER number") if match.nil?
+
+      @major = match[1].to_i
+      @minor = match[2].to_i
+      @patch = match[3].to_i
+    end
+
+    # @return [Integer]
+    def major
+      @major
+    end
+
+    # @return [Integer]
+    def minor
+      @minor
+    end
+
+    # @return [Integer]
+    def patch
+      @patch
+    end
+
+    # @return [Boolean]
+    def <(semver)
+      is_a_semver?(semver)
+
+      @major < semver.major ||
+      (@major == semver.major && @minor < semver.minor) ||
+      (@major == semver.major && @minor == semver.minor && @patch < semver.patch)
+    end
+
+    # @return [Boolean]
+    def >(semver)
+      is_a_semver?(semver)
+
+      @major > semver.major ||
+      (@major == semver.major && @minor > semver.minor) ||
+      (@major == semver.major && @minor == semver.minor && @patch > semver.patch)
+    end
+
+    # @return [Boolean]
+    def ==(semver)
+      is_a_semver?(semver)
+
+      @major == semver.major && @minor == semver.minor && @patch == semver.patch
+    end
+
+    private
+
+    # @return [Boolean]
+    def is_a_semver?(semver)
+      if !semver.respond_to?(:major) || !semver.respond_to?(:minor) || !semver.respond_to?(:patch)
+        raise ArgumentError.new("SemVer compatible object expected")
+      end
+    end
+  end
+end

data/src/version/unreachable_error.rb

@@ -0,0 +1,4 @@
+module Version
+  class UnreachableError < StandardError
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: run_tasks
 version: !ruby/object:Gem::Version
-  version: 1.7.6
+  version: 2.0.3
 platform: ruby
 authors:
 - Aurélien Delogu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-13 00:00:00.000000000 Z
-dependencies: []
+date: 2025-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
 description:
 email: aurelien.delogu@gmail.com
 executables:
@@ -18,13 +32,34 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/run
-- src/run.rb
-- src/run/markdown/abstract_tag.rb
-- src/run/markdown/bold_tag.rb
-- src/run/markdown/code_tag.rb
-- src/run/markdown/engine.rb
-- src/run/markdown/italic_tag.rb
-- src/run/string.rb
+- src/bootstrap.rb
+- src/gemspec/metadata.rb
+- src/markdown/abstract_tag.rb
+- src/markdown/bold_tag.rb
+- src/markdown/code_tag.rb
+- src/markdown/engine.rb
+- src/markdown/italic_tag.rb
+- src/monkey/string.rb
+- src/run/core.rb
+- src/run/core/help.rb
+- src/run/core/verify_run_version.rb
+- src/run/error/aborted.rb
+- src/run/error/existing_task.rb
+- src/run/error/non_existing_runfile.rb
+- src/run/error/reserved_task_name.rb
+- src/run/error/unknown_task.rb
+- src/run/helper/are_you_sure_helper.rb
+- src/run/helper/catch_interruption_helper.rb
+- src/run/helper/expand_helper.rb
+- src/run/helper/menu_helper.rb
+- src/run/helper/pause_helper.rb
+- src/run/helper/wait_for_interruption_helper.rb
+- src/run/task/block_task.rb
+- src/run/task/system_task.rb
+- src/version/local_gemspec_version.rb
+- src/version/remote_gemspec_version.rb
+- src/version/semver.rb
+- src/version/unreachable_error.rb
 homepage: https://github.com/pyrsmk/run
 licenses:
 - MIT
@@ -45,8 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.5.2
+rubygems_version: 2.6.14.4
 signing_key:
 specification_version: 4
-summary: Run project tasks with ease
+summary: Easy project management for the masses
 test_files: []

data/src/run.rb

@@ -1,253 +0,0 @@
-#!/usr/bin/ruby
-
-require "digest"
-require "fileutils"
-require "open-uri"
-require "readline"
-require "rubygems"
-require "securerandom"
-
-##########################################################################################
-
-require_relative "#{__dir__}/run/string"
-require_relative "#{__dir__}/run/markdown/engine"
-
-##########################################################################################
-
-GEMSPEC_PATH = "#{__dir__}/../run_tasks.gemspec"
-GEM = if File.exist?(GEMSPEC_PATH)
-        Gem::Specification::load(GEMSPEC_PATH) # Development.
-      else
-        Gem::Specification::find_by_name("run_tasks") rescue nil # Production.
-      end
-VERSION = GEM&.version
-HOMEPAGE = GEM&.homepage
-
-##########################################################################################
-
-@tasks = {}
-
-# @param name [Symbol]
-# @param help [String]
-# @yield [*Array, **Hash]
-def task(name, help = nil, &block)
-  if !name.is_a?(Symbol)
-    puts
-    puts "'name' parameter must be a symbol".red
-    exit 6
-  end
-  if !help.nil?
-    if !help.is_a?(String)
-      puts
-      puts "'help' parameter must be a string".red
-      exit 6
-    end
-  else
-    # Load comments directly above the task as help verbatim.
-    caller = caller_locations[0]
-    lines = File.readlines(caller.absolute_path)
-    help = (0..(caller.lineno - 2)).to_a.reverse.reduce([]) do |comments, lineno|
-      match = /^\s*#\s*(?<comment>.+?)\s*$/.match(lines[lineno])
-      break comments if match.nil?
-      comments << match[:comment]
-      comments
-    end.reverse
-  end
-  @tasks.store(
-    name,
-    {
-      :help => help.is_a?(String) ? [help] : help,
-      :block => block
-    }
-  )
-end
-
-# @param task_name_or_command [Symbol, String]
-# @param arguments [Array] Optional arguments sent to the task.
-# @param options [Hash] Optional options sent to the task.
-def run(task_name_or_command, *arguments, **options)
-  if task_name_or_command.is_a?(Symbol)
-    if options.empty?
-      @tasks[task_name_or_command][:block].call *arguments
-    else
-      @tasks[task_name_or_command][:block].call *arguments, **options
-    end
-    return
-  end
-
-  puts ">".bright_blue + " #{task_name_or_command}".bright_white
-  puts
-  case system(task_name_or_command)
-  when false
-    puts
-    puts "The command has exited with return code: #{$?.exitstatus}.".magenta
-    puts
-    raise Interrupt.new
-  when nil
-    puts
-    puts "The command has failed.".magenta
-    puts
-    raise Interrupt.new
-  end
-  puts
-end
-
-def are_you_sure?(text = "Are you sure?")
-  puts "#{text.yellow.bold} [yN]"
-  answer = STDIN.gets.chomp.downcase.chars.first
-  exit 9 unless answer == "y"
-end
-
-def menu(text, choices)
-  labels = nil
-  values = nil
-  choice = nil
-
-  if choices.is_a?(Array)
-    labels = choices
-    values = choices
-  elsif choices.is_a?(Hash)
-    labels = choices.keys
-    values = choices.values
-  else
-    puts "menu() 'choices' parameter must be an Array or an Hash".red
-    exit 10
-  end
-
-  loop do
-    labels.each_with_index do |label, index|
-      puts "#{index + 1}. #{label}"
-    end
-    puts text
-    choice = STDIN.gets.chomp.to_i
-    break if !values[choice - 1].nil?
-  end
-  puts
-
-  values[choice - 1]
-end
-
-# @param uri [String]
-def require_remote(uri)
-  cache_path = "/tmp/run_cache_#{Digest::MD5.hexdigest(uri)}"
-  if !File.exist? cache_path
-    File.write(cache_path, URI.parse(uri).open.read)
-  end
-  eval File.read(cache_path)
-rescue => error
-  puts
-  puts "Unable to load #{uri}:".red
-  puts "#{error.class}: #{error.message}".red
-  exit 8
-end
-
-# @param name [String]
-def require_extension(name)
-  require_remote "https://pyrsmk.fra1.cdn.digitaloceanspaces.com" \
-                 "/run_extensions/#{name}.rb"
-end
-
-##########################################################################################
-
-RUNFILE = "Runfile.rb"
-
-if !File.exist?(RUNFILE)
-  puts
-  puts "#{RUNFILE} does not exist".red
-  exit 7
-end
-
-begin
-  require "./#{RUNFILE}"
-rescue SyntaxError => error
-  puts
-  puts "The Runfile contains a syntax error:".red
-  puts error.message.red
-  exit 5
-end
-
-##########################################################################################
-
-# Show the help screen if there is no provided task, or if it's explicitly requested.
-if ARGV.size == 0 || (ARGV.size == 1 && ARGV[0] == "help")
-  puts
-  if VERSION
-    puts " Run v#{VERSION}".bright_blue
-  else
-    puts " Run".bright_blue
-  end
-  puts
-  # Compute the max task names size.
-  max_size = @tasks.keys.reduce(0) do |max, name|
-    next max if name.size <= max
-    name.size
-  end
-  # Display each task and their help.
-  @tasks.sort.to_h.each do |name, task|
-    if task[:help].size == 0
-      puts " #{name}".yellow
-      next
-    end
-    task[:help].each_with_index do |help, index|
-      help = Markdown::Engine.new(help).to_ansi
-      if index == 0
-        puts " #{name}".yellow + (" " * (max_size - name.size + 4)) + help
-        next
-      end
-      puts (" " * (max_size + 5)) + help
-    end
-  end
-  exit
-end
-
-# Verify the latest release version.
-if VERSION && HOMEPAGE
-  Thread.new do
-    begin
-      contents = URI.parse("#{HOMEPAGE}/master/run.gemspec")
-                    .open
-                    .read
-      version = /^\s*s.version\s*=\s*"(.+?)"\s*$/.match(contents)
-      if !version.nil?
-        next if File.exist?("/tmp/run_dismiss_#{version}")
-        current = VERSION.split "."
-        latest = version[1].split "."
-        if current[0].to_i < latest[0].to_i ||
-          current[1].to_i < latest[1].to_i ||
-          current[2].to_i < latest[2].to_i
-          puts "New ".cyan + version[1].yellow + " version released!".cyan
-          puts
-          puts "You can upgrade with:".cyan + "gem update run_tasks".yellow
-          puts
-          File.write "/tmp/run_dismiss_#{version}", ""
-        end
-      end
-    rescue
-    end
-  end
-end
-
-# Run the requested task.
-name = ARGV[0].gsub('-', '_').to_sym # Auto-fix hyphens to underscores.
-if !@tasks.include?(name)
-  puts
-  puts "Unknown '#{name}' task".red
-  exit 2
-end
-begin
-  run(name, *ARGV.slice(Range.new(1, ARGV.size - 1)))
-rescue Interrupt
-  exit 3
-rescue => error
-  puts
-  message = if error.message.size > 300
-              "#{error.message[0, 300]}..."
-            else
-              error.message
-            end
-  puts "· #{message}".red
-  error.backtrace.each do |trace|
-    puts "· #{trace}".red
-  end
-  exit 4
-end