spud 0.2.0 → 0.2.5

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

@@ -0,0 +1,49 @@
+# 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
+
+        sig {returns(T::Boolean)}
+        def need_to_update?
+          !up_to_date?
+        end
+
+        sig {returns(T::Boolean)}
+        def up_to_date?
+          source_filenames = Dir[*@sources]
+          return true if source_filenames.empty?
+
+          newest_source = source_filenames
+            .map(&File.method(:stat))
+            .map(&:mtime)
+            .max
+
+          target_filenames = Dir[*@targets]
+          return false if target_filenames.empty?
+
+          oldest_target = target_filenames
+            .map(&File.method(:stat))
+            .map(&:mtime)
+            .min
+
+          newest_source < oldest_target
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# 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,
+            file_dsl: self,
+            &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/task.rb

@@ -0,0 +1,148 @@
+# 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 {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) }
+        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])],
+            file_dsl: FileDSL,
+            block: Proc,
+          )
+          .void
+        end
+        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
+
+        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(TaskDSL)}
+        def task_dsl
+          @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])}
+        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,90 @@
+# typed: true
+require 'sorbet-runtime'
+require 'spud/error'
+require 'spud/driver'
+require 'spud/shell/command'
+require 'spud/shell/result'
+require 'spud/task_runners/spud_task_runner/file_dsl'
+
+module Spud
+  module TaskRunners
+    module SpudTaskRunner
+      class TaskDSL
+        extend T::Sig
+
+        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
+          @__commander.(command)
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def shh(command)
+          @__commander.(command)
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def shhh(command)
+          @__commander.(command, silent: true)
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def sh!(command)
+          puts 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 = @__commander.(command)
+          raise Error, "sh failed for '#{command}'" unless result.success?
+          result
+        end
+
+        sig {params(command: String).returns(Shell::Result)}
+        def shhh!(command)
+          result = @__commander.(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
+
+        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
+      end
+    end
+  end
+end

data/lib/spud/task_runners/task.rb

@@ -0,0 +1,40 @@
+# 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.0'
+  VERSION = '0.2.5'
 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