spud 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3508c944aca0510946f7705ce2f1fb057632619f11182a872affe5bced27a8e
-  data.tar.gz: 3f6c06be53831bad47cfcee5314982e1d2cd165078607b98b2f48b25a75ca2f6
+  metadata.gz: 28a274884358f6717d4e649d7ad01ea399317c89a02d2595576a15d35465b8de
+  data.tar.gz: 1866b4fc335245a0a86fb21ad60c875596af2cc545399aa22db440d34e51bbf3
 SHA512:
-  metadata.gz: b4f6ed2d24030f329187f61475ccfebddf169cec0fdc7c17a8679de302747da7fe1ce74d8a4d92b000af8e50e3e927f103f00d445861e0e6b8cc8f85d8ff62b7
-  data.tar.gz: 7a68fd902c3a6494fd2659edf642b924d10a240b59fa7b0780b42392bf69b0dd5f254872ced0490911870b7f49a2eda8f4451b4547140dca89214473c41e02a3
+  metadata.gz: b44fd607406fe417224470905701c9f37fbb616ebc207df2ad041650f3368c5d6a15d5cf07778641d72d47f9c6af1b3fca7c774f09660bff679f44e50a946ea9
+  data.tar.gz: e4e08a44cce308f92d7ff769ddf4f2ad4f75dfe8f4ca54643b4d84e9266cce9fbed191fd6e85710839440b8d85126b57dfaeadc881e17f412850f77432b46b51

data/lib/spud/driver.rb

@@ -1,5 +1,4 @@
 # typed: true
-require 'sorbet-runtime'
 require 'spud/error'
 require 'spud/help'
 require 'spud/lister'
@@ -66,7 +65,9 @@ module Spud
       raise error if debug?
     end
 
-    sig {params(name: String, ordered: T::Array[String], named: T::Hash[T.any(String, Symbol), String]).void}
+    sig do
+      params(name: String, ordered: T::Array[String], named: T::Hash[T.any(String, Symbol), String]).returns(T.untyped)
+    end
     def invoke(name, ordered, named)
       get_task(name).invoke(ordered, stringify_keys(named))
     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

@@ -5,6 +5,15 @@ module Spud
   class TaskArg
     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 "ordered" or "named"' unless %w[ordered named].include?(type)

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

@@ -2,6 +2,7 @@
 require 'sorbet-runtime'
 require 'stringio'
 require 'spud/driver'
+require 'spud/shell/command'
 require 'spud/task_runners/task'
 
 module Spud
@@ -36,7 +37,7 @@ module Spud
 
         sig {override.params(ordered: T::Array[String], named: T::Hash[String, String]).returns(T.untyped)}
         def invoke(ordered, named)
-          system('make', name)
+          Shell::Command.("make #{name}", driver: @driver)
         end
 
         sig {override.returns(String)}
@@ -53,7 +54,7 @@ module Spud
           cursor += 1 until lines[cursor]&.start_with?(name)
 
           builder = StringIO.new
-          until lines[cursor]&.empty?
+          while lines[cursor] && !lines[cursor]&.empty?
             builder.puts lines[cursor]
             cursor += 1
           end

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

@@ -3,6 +3,7 @@ require 'sorbet-runtime'
 require 'json'
 require 'spud/driver'
 require 'spud/task_args'
+require 'spud/shell/command'
 require 'spud/task_runners/task'
 
 module Spud
@@ -52,7 +53,7 @@ module Spud
 
         sig {override.params(ordered: T::Array[String], named: T::Hash[String, String]).returns(T.untyped)}
         def invoke(ordered, named)
-          system("#{@command} run #{name}")
+          Shell::Command.("#{@command} run #{name}", driver: @driver)
         end
 
         sig {override.returns(String)}

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

@@ -1,19 +1,29 @@
 # typed: true
+
 module Spud
   module TaskRunners
     module SpudTaskRunner
       class Dependency
+        extend T::Sig
+
+        sig {returns(T::Array[String])}
+        attr_reader :sources
+
+        sig {returns(T::Array[String])}
+        attr_reader :targets
+
+        sig {params(source: T.any(String, T::Array[String]), target: T.any(String, T::Array[String])).void}
         def initialize(source, target)
           @sources = [source].flatten
           @targets = [target].flatten
         end
 
-        # @return [Boolean]
+        sig {returns(T::Boolean)}
         def need_to_update?
           !up_to_date?
         end
 
-        # @return [Boolean]
+        sig {returns(T::Boolean)}
         def up_to_date?
           source_filenames = Dir[*@sources]
           return true if source_filenames.empty?

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

@@ -43,6 +43,7 @@ module Spud
             name: Task.qualified_name(@__filename, name.to_s),
             filename: @__filename,
             dependencies: dependencies,
+            file_dsl: self,
             &block
           )
         end

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

@@ -22,6 +22,9 @@ module Spud
         sig {override.returns(String)}
         attr_reader :name
 
+        sig {returns(T::Array[Dependency])}
+        attr_reader :dependencies
+
         sig {override.params(driver: Driver).returns(T::Array[TaskRunners::Task])}
         def self.tasks(driver)
           Dir['**/Spudfile', '**/*.spud'].flat_map { |filename| FileDSL.run(driver, filename) }
@@ -46,15 +49,17 @@ module Spud
             name: String,
             filename: String,
             dependencies: T::Hash[T.any(String, T::Array[String]), T.any(String, T::Array[String])],
+            file_dsl: FileDSL,
             block: Proc,
           )
           .void
         end
-        def initialize(driver:, name:, filename:, dependencies:, &block)
+        def initialize(driver:, name:, filename:, dependencies:, file_dsl:, &block)
           @driver = driver
           @name = name
           @filename = filename
           @dependencies = dependencies.map { |to, from| Dependency.new(to, from) }
+          @file_dsl = file_dsl
           @block = block
         end
 
@@ -128,9 +133,9 @@ module Spud
           @dependencies.all?(&:up_to_date?)
         end
 
-        sig {returns(SpudTaskRunner::TaskDSL)}
+        sig {returns(TaskDSL)}
         def task_dsl
-          @task_dsl ||= TaskDSL.new(@driver, @filename)
+          @task_dsl ||= TaskDSL.new(@driver, @filename, @file_dsl)
         end
 
         sig {params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[Symbol, T.untyped])}

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

@@ -1,9 +1,10 @@
-# typed: false
+# typed: true
 require 'sorbet-runtime'
 require 'spud/error'
 require 'spud/driver'
-require 'spud/task_runners/spud_task_runner/shell/command'
-require 'spud/task_runners/spud_task_runner/shell/result'
+require 'spud/shell/command'
+require 'spud/shell/result'
+require 'spud/task_runners/spud_task_runner/file_dsl'
 
 module Spud
   module TaskRunners
@@ -11,46 +12,52 @@ module Spud
       class TaskDSL
         extend T::Sig
 
-        sig {params(driver: Driver, filename: String).void}
-        def initialize(driver, filename)
+        sig {params(driver: Driver, filename: String, file_dsl: FileDSL).void}
+        def initialize(driver, filename, file_dsl)
           @__filename = filename
           @__driver = driver
+
+          @__commander = Shell::Command.commander(driver)
+
+          file_dsl.singleton_methods.each do |method|
+            define_singleton_method(method, &file_dsl.singleton_method(method))
+          end
         end
 
         sig {params(command: String).returns(Shell::Result)}
         def sh(command)
           puts command
-          Shell::Command.(@__driver, command)
+          @__commander.(command)
         end
 
         sig {params(command: String).returns(Shell::Result)}
         def shh(command)
-          Shell::Command.(@__driver, command)
+          @__commander.(command)
         end
 
         sig {params(command: String).returns(Shell::Result)}
         def shhh(command)
-          Shell::Command.(@__driver, command, silent: true)
+          @__commander.(command, silent: true)
         end
 
         sig {params(command: String).returns(Shell::Result)}
         def sh!(command)
           puts command
-          result = Shell::Command.(@__driver, command)
+          result = @__commander.(command)
           raise Error, "sh failed for '#{command}'" unless result.success?
           result
         end
 
         sig {params(command: String).returns(Shell::Result)}
         def shh!(command)
-          result = Shell::Command.(@__driver, command)
+          result = @__commander.(command)
           raise Error, "sh failed for '#{command}'" unless result.success?
           result
         end
 
         sig {params(command: String).returns(Shell::Result)}
         def shhh!(command)
-          result = Shell::Command.(@__driver, command, silent: true)
+          result = @__commander.(command, silent: true)
           raise Error, "sh failed for '#{command}'" unless result.success?
           result
         end
@@ -71,8 +78,9 @@ module Spud
           @__driver.invoke(task, ordered, named)
         end
 
-        def method_missing(symbol, *ordered, **named)
-          task = symbol.to_s
+        sig {params(task: Symbol, ordered: String, named: String).returns(T.untyped)}
+        def method_missing(task, *ordered, **named)
+          task = task.to_s
           task = task.include?('.') ? task : Task.qualified_name(@__filename, task)
           @__driver.invoke(task, ordered, named)
         end

data/lib/spud/task_runners/task.rb

@@ -21,10 +21,7 @@ module Spud
 
       sig do
         abstract
-          .params(
-            ordered: T::Array[String],
-            named: T::Hash[String, String],
-          )
+          .params(ordered: T::Array[String], named: T::Hash[String, String])
           .returns(T.untyped)
       end
       def invoke(ordered, named); end

data/lib/spud/version.rb

@@ -1,4 +1,4 @@
 # typed: strict
 module Spud
-  VERSION = '0.2.4'
+  VERSION = '0.2.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spud
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Andrew Booth
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-22 00:00:00.000000000 Z
+date: 2020-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -97,14 +97,14 @@ files:
 - lib/spud/error.rb
 - lib/spud/help.rb
 - lib/spud/lister.rb
+- lib/spud/shell/command.rb
+- lib/spud/shell/result.rb
 - lib/spud/task_arg.rb
 - lib/spud/task_args.rb
 - lib/spud/task_runners/make/task.rb
 - lib/spud/task_runners/package.json/task.rb
 - lib/spud/task_runners/spud_task_runner/dependency.rb
 - lib/spud/task_runners/spud_task_runner/file_dsl.rb
-- lib/spud/task_runners/spud_task_runner/shell/command.rb
-- lib/spud/task_runners/spud_task_runner/shell/result.rb
 - lib/spud/task_runners/spud_task_runner/task.rb
 - lib/spud/task_runners/spud_task_runner/task_dsl.rb
 - lib/spud/task_runners/task.rb

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

@@ -1,58 +0,0 @@
-# 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

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

@@ -1,31 +0,0 @@
-# typed: false
-require 'sorbet-runtime'
-
-module Spud
-  module TaskRunners
-    module SpudTaskRunner
-      module Shell
-        class Result < String
-          extend T::Sig
-
-          sig {returns(Process::Status)}
-          attr_reader :status
-
-          sig {params(output: String, status: Process::Status).void}
-          def initialize(output, status)
-            super(output)
-            @status = status
-          end
-
-          def method_missing(symbol, *args)
-            status.respond_to?(symbol) ? status.send(symbol, *args) : super
-          end
-
-          def respond_to_missing?(symbol, *)
-            status.respond_to?(symbol) || super
-          end
-        end
-      end
-    end
-  end
-end