spud 0.2.1 → 0.2.6

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

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

@@ -0,0 +1,50 @@
+# typed: true
+require 'sorbet-runtime'
+
+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,149 @@
+# 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?
+            raise Error, "'#{name}' up to date"
+          end
+
+          check_required_args!(ordered)
+
+          catch :halt do
+            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
+          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,95 @@
+# 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(value: T.untyped).void}
+        def halt(value = nil)
+          value ? throw(:halt, value) : throw(:halt)
+        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