spud 0.2.0 → 0.2.5

data/lib/spud/help.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'stringio'
 require 'spud/version'
 
@@ -5,19 +6,18 @@ module Spud
   module Help
     # @return [void]
     def self.print!
-      help = StringIO.new
-
-      help.puts "spud #{VERSION}"
-      help.puts
-      help.puts 'usage:'
-      help.puts '  spud [options] <task> [args]'
-      help.puts
-      help.puts 'options:'
-      help.puts '  -h, --help   show this help dialog'
-      help.puts '  -f, --files  list parsed files'
-      help.puts '  --debug      run in debug mode'
-
-      puts help.string
+      puts <<~HELP
+        spud #{VERSION}
+        
+        usage:
+          spud [options] <task> [args]
+        
+        options:
+          -h, --help          show this help dialog
+          -w, --watch <glob>  re-run task any time glob changes
+          -f, --files         list parsed files
+          -i, --inspect       show details about a task
+      HELP
     end
   end
 end

data/lib/spud/lister.rb

@@ -1,22 +1,27 @@
+# typed: true
+require 'sorbet-runtime'
 require 'stringio'
+require 'spud/task_runners/task'
 
 module Spud
   class Lister
-    # @param tasks [Array<BuildTools::Task>]
+    extend T::Sig
+
+    sig {params(tasks: T::Array[TaskRunners::Task]).void}
     def initialize(tasks)
       @tasks = tasks
     end
 
-    # @return [void]
-    def list!
+    sig {void}
+    def list_tasks!
       builder = StringIO.new
 
       @tasks.each do |task|
         builder.write task.name.ljust(max_task_length)
 
-        if show_positional_args?
+        if show_ordered_args?
           builder.write '  '
-          builder.write task.args.positional.join(' ').ljust(max_positional_string_length)
+          builder.write task.args.ordered.join(' ').ljust(max_ordered_string_length)
         end
 
         if show_named_args?
@@ -35,32 +40,37 @@ module Spud
       puts builder.string
     end
 
-    # @return [void]
+    sig {void}
     def list_filenames!
       puts filenames.join("\n")
     end
 
+    sig {returns(T::Array[String])}
+    def filenames
+      @filenames ||= @tasks.map(&:filename).uniq
+    end
+
     private
 
-    # @return [Integer]
+    sig {returns(Integer)}
     def max_task_length
       @max_task_length ||= @tasks.map { |task| task.name.length }.max
     end
 
-    # @return [Integer]
-    def max_positional_string_length
-      @max_positional_string_length ||= @tasks
-        .map { |task| task.args.positional.join(' ') }
+    sig {returns(Integer)}
+    def max_ordered_string_length
+      @max_ordered_string_length ||= @tasks
+        .map { |task| task.args.ordered.join(' ') }
         .map(&:length)
         .max
     end
 
-    # @return [Boolean]
-    def show_positional_args?
-      @show_positional_args ||= @tasks.any? { |task| task.args.any_positional? }
+    sig {returns(T::Boolean)}
+    def show_ordered_args?
+      @show_ordered_args ||= @tasks.any? { |task| task.args.any_ordered? }
     end
 
-    # @return [Integer]
+    sig {returns(Integer)}
     def max_named_string_length
       @max_named_string_length ||= @tasks
         .map { |task| task.args.named.join(' ') }
@@ -68,17 +78,12 @@ module Spud
         .max
     end
 
-    # @return [Boolean]
+    sig {returns(T::Boolean)}
     def show_named_args?
       @show_named_args ||= @tasks.any? { |task| task.args.any_named? }
     end
 
-    # @return [Array<String>]
-    def filenames
-      @filenames ||= @tasks.map(&:filename).uniq
-    end
-
-    # @return [Boolean]
+    sig {returns(T::Boolean)}
     def show_filenames?
       filenames.length > 1
     end

data/lib/spud/shell/command.rb

@@ -0,0 +1,75 @@
+# typed: true
+require 'sorbet-runtime'
+require 'stringio'
+require 'open3'
+require 'spud/driver'
+require 'spud/shell/result'
+
+module Spud
+  module Shell
+    class Command
+      extend T::Sig
+
+      attr_reader :result
+
+      Handle = T.type_alias {T.any(IO, StringIO)}
+
+      sig {params(command: String, driver: T.nilable(Driver), silent: T::Boolean, handle: Handle).returns(Result)}
+      def self.call(command, driver: nil, silent: false, handle: STDOUT)
+        cmd = new(command, driver: driver, silent: silent, handle: handle)
+        cmd.issue!
+        cmd.result
+      end
+
+      sig {params(driver: Driver).returns(Commander)}
+      def self.commander(driver)
+        Commander.new(driver)
+      end
+
+      sig {params(command: String, driver: T.nilable(Driver), silent: T::Boolean, handle: Handle).void}
+      def initialize(command, driver: nil, silent: false, handle: STDOUT)
+        @command = command
+        @driver = driver
+        @silent = silent
+        @handle = handle
+
+        @result = T.let(nil, T.nilable(Result))
+      end
+
+      sig {void}
+      def issue!
+        capturer = StringIO.new
+
+        Open3.popen2e(@command) do |_, out, thread|
+          @driver&.register_subprocess(thread.pid)
+
+          loop do
+            line = out.gets
+            break unless line
+
+            @handle.write line unless @silent
+            capturer.puts line
+          end
+
+          @result = Result.new(capturer.string, T.cast(thread.value, Process::Status))
+        end
+
+        @driver&.register_subprocess(nil)
+      end
+
+      class Commander
+        extend T::Sig
+
+        sig {params(driver: Driver).void}
+        def initialize(driver)
+          @driver = driver
+        end
+
+        sig {params(command: String, silent: T::Boolean, handle: Handle).returns(Result)}
+        def call(command, silent: false, handle: STDOUT)
+          Command.(command, driver: @driver, silent: silent, handle: handle)
+        end
+      end
+    end
+  end
+end

data/lib/spud/shell/result.rb

@@ -0,0 +1,33 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'forwardable'
+
+module Spud
+  module Shell
+    class Result < String
+      extend T::Sig
+      extend Forwardable
+
+      sig {returns(Process::Status)}
+      attr_reader :status
+
+      def_delegators :status,
+        :coredump?,
+        :exited?,
+        :exitstatus,
+        :pid,
+        :signaled?,
+        :stopped?,
+        :stopsig,
+        :success?,
+        :termsig,
+        :to_i
+
+      sig {params(output: String, status: Process::Status).void}
+      def initialize(output, status)
+        super(output)
+        @status = status
+      end
+    end
+  end
+end

data/lib/spud/task_arg.rb

@@ -1,39 +1,51 @@
+# typed: strict
+require 'sorbet-runtime'
+
 module Spud
   class TaskArg
-    # @param name [String]
-    # @param type [String]
-    # @param default [String]
+    extend T::Sig
+
+    sig {returns(String)}
+    attr_reader :name
+
+    sig {returns(String)}
+    attr_reader :type
+
+    sig {returns(T.nilable(String))}
+    attr_reader :default
+
+    sig {params(name: String, type: String, default: T.nilable(String)).void}
     def initialize(name, type, default: nil)
-      raise 'must be of type "positional" or "named"' unless %w[positional named].include?(type)
+      raise 'must be of type "ordered" or "named"' unless %w[ordered named].include?(type)
 
       @name = name
       @type = type
       @default = default
     end
 
-    # @return [Boolean]
+    sig {returns(T::Boolean)}
     def required?
       !has_default?
     end
 
-    # @return [Boolean]
+    sig {returns(T::Boolean)}
     def has_default?
       !!@default
     end
 
-    # @return [Boolean]
-    def positional?
-      @type == 'positional'
+    sig {returns(T::Boolean)}
+    def ordered?
+      @type == 'ordered'
     end
 
-    # @return [Boolean]
+    sig {returns(T::Boolean)}
     def named?
       @type == 'named'
     end
 
-    # @return [String]
+    sig {returns(String)}
     def to_s
-      if positional?
+      if ordered?
         if has_default?
           "<#{@name}=#{@default}>"
         else

data/lib/spud/task_args.rb

@@ -1,47 +1,49 @@
+# typed: true
+require 'sorbet-runtime'
 require 'spud/task_arg'
-require 'spud/build_tools/spud/block_param_info'
+require 'spud/block_param_info'
 
 module Spud
   class TaskArgs < Array
-    # @param filename [String]
-    # @param block [Proc]
-    # @return [Spud::TaskArgs]
+    extend T::Sig
+
+    sig {params(filename: String, block: Proc).returns(T.attached_class)}
     def self.from_block(filename, &block)
-      info = BuildTools::Spud::BlockParamInfo.new(filename, &block)
+      info = BlockParamInfo.new(filename, &block)
       new(info.task_args)
     end
 
-    # @param task_args [Array<Spud::TaskArg>]
+    sig {params(task_args: T::Array[TaskArg]).void}
     def initialize(task_args)
       super(task_args)
     end
 
-    # @return [Array<Spud::TaskArg>]
-    def positional
-      @positional ||= select(&:positional?)
+    sig {returns(T::Array[TaskArg])}
+    def ordered
+      @ordered ||= select(&:ordered?)
     end
 
-    # @return [Array<Spud::TaskArg>]
-    def required_positional
-      @required_positional ||= positional.select(&:required?)
+    sig {returns(T::Array[TaskArg])}
+    def required_ordered
+      @required_ordered ||= ordered.select(&:required?)
     end
 
-    # @return [Boolean]
-    def any_positional?
-      !positional.empty?
+    sig {returns(T::Boolean)}
+    def any_ordered?
+      !ordered.empty?
     end
 
-    # @return [Array<Spud::TaskArg>]
+    sig {returns(T::Array[TaskArg])}
     def named
       @named ||= select(&:named?)
     end
 
-    # @return [Array<Spud::TaskArg>]
+    sig {returns(T::Array[TaskArg])}
     def required_named
       @required_named ||= named.select(&:required?)
     end
 
-    # @return [Boolean]
+    sig {returns(T::Boolean)}
     def any_named?
       !named.empty?
     end

data/lib/spud/task_runners/make/task.rb

@@ -0,0 +1,67 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'stringio'
+require 'spud/driver'
+require 'spud/shell/command'
+require 'spud/task_runners/task'
+
+module Spud
+  module TaskRunners
+    module Make
+      class Task < TaskRunners::Task
+        extend T::Sig
+
+        sig {override.returns(String)}
+        attr_reader :name
+
+        sig {override.params(driver: Driver).returns(T::Array[TaskRunners::Task])}
+        def self.tasks(driver)
+          return [] unless File.exist?('Makefile')
+
+          if `command -v make`.empty?
+            puts 'Makefile detected, but no installation of `make` exists. Skipping make...'
+            return []
+          end
+
+          source = File.read('Makefile')
+          T.unsafe(source.scan(/^(\S+):.*/)).map(&:first).map do |name|
+            new(driver, name)
+          end
+        end
+
+        sig {params(driver: Driver, name: String).void}
+        def initialize(driver, name)
+          @driver = driver
+          @name = name
+        end
+
+        sig {override.params(ordered: T::Array[String], named: T::Hash[String, String]).returns(T.untyped)}
+        def invoke(ordered, named)
+          Shell::Command.("make #{name}", driver: @driver)
+        end
+
+        sig {override.returns(String)}
+        def filename
+          'Makefile'
+        end
+
+        sig {override.returns(String)}
+        def details
+          source = File.read('Makefile')
+          lines = source.split("\n")
+          cursor = 0
+
+          cursor += 1 until lines[cursor]&.start_with?(name)
+
+          builder = StringIO.new
+          while lines[cursor] && !lines[cursor]&.empty?
+            builder.puts lines[cursor]
+            cursor += 1
+          end
+
+          builder.string
+        end
+      end
+    end
+  end
+end

data/lib/spud/task_runners/package.json/task.rb

@@ -0,0 +1,71 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'json'
+require 'spud/driver'
+require 'spud/task_args'
+require 'spud/shell/command'
+require 'spud/task_runners/task'
+
+module Spud
+  module TaskRunners
+    module PackageJSON
+      class Task < TaskRunners::Task
+        extend T::Sig
+
+        sig {override.returns(String)}
+        attr_reader :name
+
+        sig {override.params(driver: Driver).returns(T::Array[TaskRunners::Task])}
+        def self.tasks(driver)
+          if File.exist?('package.lock')
+            if `command -v npm`.empty?
+              puts 'package.json detected, but no installation of `npm` exists. Skipping npm...'
+              return []
+            else
+              command = 'npm'
+            end
+          elsif File.exist?('yarn.lock')
+            if `command -v yarn`.empty?
+              puts 'package.json detected, but no installation of `yarn` exists. Skipping yarn...'
+              return []
+            else
+              command = 'yarn'
+            end
+          else
+            return []
+          end
+
+          source = File.read('package.json')
+          json = JSON.parse(source)
+          scripts = json['scripts']
+          return [] unless scripts
+
+          scripts.keys.map { |name| new(driver, name, command, scripts) }
+        end
+
+        sig {params(driver: Driver, name: String, command: String, scripts: T::Hash[String, String]).void}
+        def initialize(driver, name, command, scripts)
+          @driver = driver
+          @name = name
+          @command = command
+          @scripts = scripts
+        end
+
+        sig {override.params(ordered: T::Array[String], named: T::Hash[String, String]).returns(T.untyped)}
+        def invoke(ordered, named)
+          Shell::Command.("#{@command} run #{name}", driver: @driver)
+        end
+
+        sig {override.returns(String)}
+        def filename
+          'package.json'
+        end
+
+        sig {override.returns(String)}
+        def details
+          %({ "#{name}": "#{@scripts[name]}" })
+        end
+      end
+    end
+  end
+end