spud 0.2.3 → 0.2.4

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/task_arg.rb

@@ -1,39 +1,42 @@
+# typed: strict
+require 'sorbet-runtime'
+
 module Spud
   class TaskArg
-    # @param name [String]
-    # @param type [String]
-    # @param default [String]
+    extend T::Sig
+
+    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,66 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'stringio'
+require 'spud/driver'
+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)
+          system('make', name)
+        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
+          until 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,70 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'json'
+require 'spud/driver'
+require 'spud/task_args'
+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)
+          system("#{@command} run #{name}")
+        end
+
+        sig {override.returns(String)}
+        def filename
+          'package.json'
+        end
+
+        sig {override.returns(String)}
+        def details
+          %({ "#{name}": "#{@scripts[name]}" })
+        end
+      end
+    end
+  end
+end

data/lib/spud/{build_tools/spud → task_runners/spud_task_runner}/dependency.rb

@@ -1,6 +1,7 @@
+# typed: true
 module Spud
-  module BuildTools
-    module Spud
+  module TaskRunners
+    module SpudTaskRunner
       class Dependency
         def initialize(source, target)
           @sources = [source].flatten

data/lib/spud/task_runners/spud_task_runner/file_dsl.rb

@@ -0,0 +1,56 @@
+# typed: true
+require 'sorbet-runtime'
+require 'spud/driver'
+require 'spud/task_runners/spud_task_runner/task'
+
+module Spud
+  module TaskRunners
+    module SpudTaskRunner
+      class FileDSL
+        extend T::Sig
+
+        sig {params(driver: Driver, filename: String).returns(T::Array[SpudTaskRunner::Task])}
+        def self.run(driver, filename)
+          dsl = new(driver, filename)
+          dsl.instance_eval(::File.read(filename), filename)
+
+          dsl.instance_variable_get(:@__tasks)
+        end
+
+        sig {params(driver: Driver, filename: String).void}
+        def initialize(driver, filename)
+          @__driver = driver
+          @__filename = filename
+
+          @__tasks = T.let([], T::Array[Task])
+        end
+
+        sig {params(name: String).returns(T::Boolean)}
+        def require_relative(name)
+          require("./#{name}")
+        end
+
+        sig do
+          params(
+            name: T.any(String, Symbol),
+            dependencies: T::Hash[T.any(String, T::Array[String]), T.any(String, T::Array[String])],
+            block: Proc,
+          ).void
+        end
+        def task(name, dependencies = {}, &block)
+          @__tasks << Task.new(
+            driver: @__driver,
+            name: Task.qualified_name(@__filename, name.to_s),
+            filename: @__filename,
+            dependencies: dependencies,
+            &block
+          )
+        end
+
+        def method_missing(name, *args, &block)
+          T.unsafe(self).task(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/spud/task_runners/spud_task_runner/shell/command.rb

@@ -0,0 +1,58 @@
+# typed: true
+require 'sorbet-runtime'
+require 'stringio'
+require 'open3'
+require 'spud/driver'
+require 'spud/task_runners/spud_task_runner/shell/result'
+
+module Spud
+  module TaskRunners
+    module SpudTaskRunner
+      module Shell
+        class Command
+          extend T::Sig
+
+          attr_reader :result
+
+          sig {params(driver: Driver, command: String, silent: T::Boolean, handle: T.any(IO, StringIO)).returns(Result)}
+          def self.call(driver, command, silent: false, handle: STDOUT)
+            cmd = new(driver, command, silent: silent, handle: handle)
+            cmd.issue!
+            cmd.result
+          end
+
+          sig {params(driver: Driver, command: String, silent: T::Boolean, handle: T.any(IO, StringIO)).void}
+          def initialize(driver, command, 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 |_stdin, stdout, thread|
+              @driver.register_subprocess(thread.pid)
+
+              loop do
+                line = stdout.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
+        end
+      end
+    end
+  end
+end