spud 0.2.3 → 0.2.4

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

@@ -1,12 +1,17 @@
+# typed: false
+require 'sorbet-runtime'
+
 module Spud
-  module BuildTools
-    module Spud
+  module TaskRunners
+    module SpudTaskRunner
       module Shell
         class Result < String
+          extend T::Sig
+
+          sig {returns(Process::Status)}
           attr_reader :status
 
-          # @param output [String]
-          # @param status [Process::Status]
+          sig {params(output: String, status: Process::Status).void}
           def initialize(output, status)
             super(output)
             @status = status

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

@@ -0,0 +1,143 @@
+# typed: true
+require 'sorbet-runtime'
+require 'stringio'
+require 'spud/driver'
+require 'spud/error'
+require 'spud/task_args'
+require 'spud/task_runners/task'
+require 'spud/task_runners/spud_task_runner/dependency'
+require 'spud/task_runners/spud_task_runner/task'
+require 'spud/task_runners/spud_task_runner/file_dsl'
+require 'spud/task_runners/spud_task_runner/task_dsl'
+
+module Spud
+  module TaskRunners
+    module SpudTaskRunner
+      class Task < TaskRunners::Task
+        extend T::Sig
+
+        sig {override.returns(String)}
+        attr_reader :filename
+
+        sig {override.returns(String)}
+        attr_reader :name
+
+        sig {override.params(driver: Driver).returns(T::Array[TaskRunners::Task])}
+        def self.tasks(driver)
+          Dir['**/Spudfile', '**/*.spud'].flat_map { |filename| FileDSL.run(driver, filename) }
+        end
+
+        sig {params(filename: String, name: String).returns(String)}
+        def self.qualified_name(filename, name)
+          segments = File.dirname(filename)
+            .split('/')
+            .reject { |segment| segment == '.' }
+
+          basename = File.basename(filename, '.spud')
+          segments << basename unless basename == 'Spudfile'
+
+          segments << name
+          segments.join('.')
+        end
+
+        sig do
+          params(
+            driver: Driver,
+            name: String,
+            filename: String,
+            dependencies: T::Hash[T.any(String, T::Array[String]), T.any(String, T::Array[String])],
+            block: Proc,
+          )
+          .void
+        end
+        def initialize(driver:, name:, filename:, dependencies:, &block)
+          @driver = driver
+          @name = name
+          @filename = filename
+          @dependencies = dependencies.map { |to, from| Dependency.new(to, from) }
+          @block = block
+        end
+
+        sig {override.params(ordered: T::Array[String], named: T::Hash[String, String]).returns(T.untyped)}
+        def invoke(ordered, named)
+          if up_to_date?
+            puts "'#{name}' up to date"
+            return nil
+          end
+
+          check_required_args!(ordered)
+
+          if args.any_named?
+            T.unsafe(task_dsl).instance_exec(*ordered, **symbolize_keys(named), &@block)
+          else
+            T.unsafe(task_dsl).instance_exec(*ordered, &@block)
+          end
+        rescue ArgumentError => error
+          raise Error, "invocation of '#{name}' with #{error.message}"
+        end
+
+        sig {override.returns(TaskArgs)}
+        def args
+          @args ||= TaskArgs.from_block(filename, &@block)
+        end
+
+        sig {override.returns(String)}
+        def details
+          filename, line_cursor = @block.source_location
+          line_cursor -= 1
+
+          lines = File.read(filename).split("\n")
+          builder = StringIO.new
+
+          # Move up for comments
+          while lines[line_cursor - 1]&.start_with?('#')
+            line_cursor -= 1
+          end
+
+          # Capture comments
+          while lines[line_cursor]&.start_with?('#')
+            builder.puts lines[line_cursor]
+            line_cursor += 1
+          end
+
+          # Capture block
+          until lines[line_cursor - 1]&.start_with?('end')
+            builder.puts lines[line_cursor]
+            line_cursor += 1
+          end
+
+          builder.string
+        end
+
+        private
+
+        sig {params(ordered: T::Array[String]).void}
+        def check_required_args!(ordered)
+          required_ordered = args.required_ordered
+          missing_ordered = required_ordered.length - ordered.length
+          if missing_ordered > 0
+            arguments = required_ordered.length - missing_ordered > 1 ? 'arguments' : 'argument'
+            raise Error, "invocation of '#{name}' missing required #{arguments} #{required_ordered.join(', ')}"
+          end
+        end
+
+        sig {returns(T::Boolean)}
+        def up_to_date?
+          return false if @dependencies.empty?
+
+          @dependencies.all?(&:up_to_date?)
+        end
+
+        sig {returns(SpudTaskRunner::TaskDSL)}
+        def task_dsl
+          @task_dsl ||= TaskDSL.new(@driver, @filename)
+        end
+
+        sig {params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[Symbol, T.untyped])}
+        def symbolize_keys(hash)
+          hash.each_with_object({}) { |(key, value), new_hash| new_hash[key.to_sym] = value }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# typed: false
+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'
+
+module Spud
+  module TaskRunners
+    module SpudTaskRunner
+      class TaskDSL
+        extend T::Sig
+
+        sig {params(driver: Driver, filename: String).void}
+        def initialize(driver, filename)
+          @__filename = filename
+          @__driver = driver
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def sh(command)
+          puts command
+          Shell::Command.(@__driver, command)
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def shh(command)
+          Shell::Command.(@__driver, command)
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def shhh(command)
+          Shell::Command.(@__driver, command, silent: true)
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def sh!(command)
+          puts command
+          result = Shell::Command.(@__driver, 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)
+          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)
+          raise Error, "sh failed for '#{command}'" unless result.success?
+          result
+        end
+
+        sig {params(task: String, ordered: String, named: String).returns(T.untyped)}
+        def invoke(task, *ordered, **named)
+          task = task.to_s
+          task = task.include?('.') ? task : Task.qualified_name(@__filename, task)
+          @__driver.invoke(task, ordered, named)
+        rescue Error => error
+          puts error.message
+        end
+
+        sig {params(task: String, ordered: String, named: String).returns(T.untyped)}
+        def invoke!(task, *ordered, **named)
+          task = task.to_s
+          task = task.include?('.') ? task : Task.qualified_name(@__filename, task)
+          @__driver.invoke(task, ordered, named)
+        end
+
+        def method_missing(symbol, *ordered, **named)
+          task = symbol.to_s
+          task = task.include?('.') ? task : Task.qualified_name(@__filename, task)
+          @__driver.invoke(task, ordered, named)
+        end
+      end
+    end
+  end
+end

data/lib/spud/task_runners/task.rb

@@ -0,0 +1,43 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'spud/driver'
+require 'spud/task_args'
+
+module Spud
+  module TaskRunners
+    class Task
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig {abstract.params(driver: Driver).returns(T::Array[TaskRunners::Task])}
+      def self.tasks(driver); end
+
+      sig {abstract.returns(String)}
+      def name; end
+
+      sig {abstract.returns(String)}
+      def filename; end
+
+      sig do
+        abstract
+          .params(
+            ordered: T::Array[String],
+            named: T::Hash[String, String],
+          )
+          .returns(T.untyped)
+      end
+      def invoke(ordered, named); end
+
+      sig {overridable.returns(TaskArgs)}
+      def args
+        TaskArgs.new([])
+      end
+
+      sig {overridable.returns(String)}
+      def details
+        name
+      end
+    end
+  end
+end

data/lib/spud/task_runners/task_runners.rb

@@ -0,0 +1,25 @@
+# typed: strict
+require 'sorbet-runtime'
+require 'spud/task_runners/task'
+require 'spud/task_runners/spud_task_runner/task'
+require 'spud/task_runners/make/task'
+require 'spud/task_runners/package.json/task'
+
+module Spud
+  module TaskRunners
+    extend T::Sig
+
+    sig {returns(T::Array[T.class_of(Task)])}
+    def self.get
+      # Ordered by priority
+      T.let(
+        [
+          T.let(SpudTaskRunner::Task, T.class_of(Task)),
+          T.let(Make::Task, T.class_of(Task)),
+          T.let(PackageJSON::Task, T.class_of(Task)),
+        ],
+        T::Array[T.class_of(Task)]
+      )
+    end
+  end
+end

data/lib/spud/version.rb

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

data/lib/spud/watch.rb

@@ -0,0 +1,73 @@
+# typed: true
+require 'sorbet-runtime'
+require 'spud/driver'
+
+module Spud
+  class Watch
+    extend T::Sig
+
+    sig do
+      params(
+        driver: Driver,
+        task: String,
+        ordered: T::Array[String],
+        named: T::Hash[String, String],
+        watches: T::Array[String],
+      ).void
+    end
+    def self.run!(driver:, task:, ordered:, named:, watches:)
+      new(driver: driver, task: task, ordered: ordered, named: named, watches: watches).run!
+    end
+
+    sig do
+      params(
+        driver: Driver,
+        task: String,
+        ordered: T::Array[String],
+        named: T::Hash[String, String],
+        watches: T::Array[String],
+      ).void
+    end
+    def initialize(driver:, task:, ordered:, named:, watches:)
+      @driver = driver
+      @task = task
+      @ordered = ordered
+      @named = named
+      @watches = watches
+
+      @last_changed = Time.at(0)
+    end
+
+    sig {void}
+    def run!
+      thread = T.let(nil, T.nilable(Thread))
+
+      loop do
+        if watches_changed?
+          thread&.kill
+          Process.kill('SIGKILL', T.must(@driver.subprocess_pid)) if @driver.subprocess_pid
+
+          @last_changed = latest_watch_change
+          thread = Thread.new { @driver.invoke(@task, @ordered, @named) }
+        end
+
+        sleep(0.1)
+      end
+    rescue SystemExit, Interrupt => error
+      puts "handled interrupt #{error}" if @driver.debug?
+    end
+
+    sig {returns(T::Boolean)}
+    def watches_changed?
+      @last_changed < latest_watch_change
+    end
+
+    sig {returns(Time)}
+    def latest_watch_change
+      T.unsafe(Dir)[*@watches]
+        .map(&File.method(:stat))
+        .map(&:mtime)
+        .max
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spud
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Andrew Booth
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-18 00:00:00.000000000 Z
+date: 2020-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6100
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6100
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6100
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6100
 description:
 email: andrew@andrewbooth.xyz
 executables:
@@ -61,27 +89,28 @@ extra_rdoc_files: []
 files:
 - bin/spud
 - lib/spud.rb
-- lib/spud/build_tools/build_tools.rb
-- lib/spud/build_tools/make/task.rb
-- lib/spud/build_tools/package.json/task.rb
-- lib/spud/build_tools/spud/block_param_info.rb
-- lib/spud/build_tools/spud/dependency.rb
-- lib/spud/build_tools/spud/dsl/file.rb
-- lib/spud/build_tools/spud/dsl/task.rb
-- lib/spud/build_tools/spud/shell/command.rb
-- lib/spud/build_tools/spud/shell/result.rb
-- lib/spud/build_tools/spud/task.rb
-- lib/spud/build_tools/task.rb
+- lib/spud/block_param_info.rb
+- lib/spud/cli/options.rb
 - lib/spud/cli/parser.rb
 - lib/spud/cli/results.rb
+- lib/spud/driver.rb
 - lib/spud/error.rb
 - lib/spud/help.rb
 - lib/spud/lister.rb
-- lib/spud/options.rb
-- lib/spud/runtime.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
+- lib/spud/task_runners/task_runners.rb
 - lib/spud/version.rb
+- lib/spud/watch.rb
 homepage: https://github.com/broothie/spud#readme
 licenses:
 - MIT
@@ -92,9 +121,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="