spud 0.2.3 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c426d3d847aaa06b411cb1eba2e84ddf7ea45ff43d9d02781075637cac24f395
-  data.tar.gz: 2e37705b14ca816367dd038eb51d402e20d4fac00e144f263fcc8a930654023e
+SHA1:
+  metadata.gz: d0b081b3d20c3a0b253e2383b4a514aac28edcf8
+  data.tar.gz: da8443efc8c52b187e84158075cee7d5875de020
 SHA512:
-  metadata.gz: 44a4bd5790ca2613a7af968fc04c7460264a83743ca68ce77513eaafa41098b4fedea9d8a95163100eef2ddb48f2f91182ba7d38df0cdf4a04ae05d8f146b641
-  data.tar.gz: 17f6f57907780792ee7606520a53a2b373b722ab88bf981eb8193663975e716583f3597835035c228e79c9b8d7c6ea43ea88ab3d63be615b1c6530949c1da7cc
+  metadata.gz: 3798ff8d115c5c1cdafcca5f134531f5df5932a7bbfafd1d33b07486dd132cf49674888fa45c1708d058a9f2b6653f2ce8e642c93112313cec684a31b6ebde7d
+  data.tar.gz: e0f7c61cfc28af1d0f4b821fb904731240e842f35846c6d3257153223d814adc6875cf49241d046cfa0dd1c24d33f39fc59abe009a99c6ad6acb22e9493e4e04

data/lib/spud.rb

@@ -1,7 +1,8 @@
-require_relative 'spud/runtime'
+# typed: true
+require_relative 'spud/driver'
 
 module Spud
   def self.run!
-    Runtime.run!
+    Driver.new.run!
   end
 end

data/lib/spud/block_param_info.rb

@@ -0,0 +1,80 @@
+# typed: true
+require 'sorbet-runtime'
+require 'spud/task_arg'
+
+module Spud
+  class BlockParamInfo
+    extend T::Sig
+
+    sig {params(filename: String, block: Proc).void}
+    def initialize(filename, &block)
+      @filename = filename
+      @block = block
+    end
+
+    sig {returns(T::Array[TaskArg])}
+    def task_args
+      parameters.map do |type, name|
+        name_string = name.to_s
+
+        case type
+        when :req
+          TaskArg.new(name_string, 'ordered')
+        when :opt
+          TaskArg.new(name_string, 'ordered', default: arg_values[name])
+        when :keyreq
+          TaskArg.new(name_string, 'named')
+        when :key
+          TaskArg.new(name_string, 'named', default: arg_values[name])
+        else
+          raise "invalid proc arg type: '#{type}'"
+        end
+      end
+    end
+
+    sig {returns([T::Array[NilClass], T::Hash[Symbol, NilClass]])}
+    def dummy_args
+      [dummy_ordered_args, dummy_named_args]
+    end
+
+    sig {returns(T::Array[NilClass])}
+    def dummy_ordered_args
+      Array.new(parameters.count { |p| p.first == :req })
+    end
+
+    sig {returns(T::Hash[Symbol, NilClass])}
+    def dummy_named_args
+      parameters.select { |p| p.first == :keyreq }.map(&:last).each_with_object({}) { |n, h| h[n] = nil }
+    end
+
+    sig {returns(String)}
+    def arg_hash_string
+      "{ #{parameters.map(&:last).map { |n| "#{n}: #{n}" }.join(', ')} }"
+    end
+
+    sig {returns(T::Hash[Symbol, T.nilable(String)])}
+    def arg_values
+      @arg_values ||= begin
+        ordered, named = dummy_args
+        T.unsafe(lambda(arg_hash_string)).call(*ordered, **named)
+      end
+    end
+
+    sig {returns(T::Array[[Symbol, Symbol]])}
+    def parameters
+      @parameters ||= lambda.parameters
+    end
+
+    sig {params(body: T.nilable(String)).returns(Proc)}
+    def lambda(body = nil)
+      line = File.read(@filename).split("\n")[@block.source_location.last - 1]
+
+      match = /(do|{)\s*\|(?<params>[^|]+)\|/.match(line)
+      return -> {} unless match
+
+      param_source = T.must(match[:params])
+      param_source += ', _: nil, __: nil, ___: nil' if body
+      eval "-> (#{param_source}) { #{body} }"
+    end
+  end
+end

data/lib/spud/cli/options.rb

@@ -0,0 +1,29 @@
+# typed: true
+require 'sorbet-runtime'
+
+module Spud
+  module CLI
+    class Options
+      extend T::Sig
+
+      attr_writer :help
+      attr_writer :inspect
+
+      sig {returns(T::Array[String])}
+      def watches
+        @watches = T.let(@watches, T.nilable(T::Array[String]))
+        @watches ||= []
+      end
+
+      sig {returns(T::Boolean)}
+      def help?
+        !!@help
+      end
+
+      sig {returns(T::Boolean)}
+      def inspect?
+        !!@inspect
+      end
+    end
+  end
+end

data/lib/spud/cli/parser.rb

@@ -1,29 +1,33 @@
+# typed: true
+require 'sorbet-runtime'
 require 'spud/cli/results'
+require 'spud/cli/options'
 
 module Spud
   module CLI
     class Parser
-      # @return [Spud::CLI::Results]
+      extend T::Sig
+
+      sig {returns(Results)}
       attr_reader :results
 
-      # @return [void]
+      sig {returns(Results)}
       def self.parse!
         parse(ARGV)
       end
 
-      # @param args [Array<String>]
-      # @return [Spud::CLI::Results]
+      sig {params(args: T::Array[String]).returns(Results)}
       def self.parse(args)
         new(args).parse!
       end
 
-      # @param args [Array<String>]
+      sig {params(args: T::Array[String]).void}
       def initialize(args)
         @args = args.dup
         @results = Results.new
       end
 
-      # @return [void]
+      sig {returns(Results)}
       def parse!
         parse_arg! until done?
         results
@@ -31,7 +35,7 @@ module Spud
 
       private
 
-      # @return [void]
+      sig {void}
       def parse_arg!
         if before_task_name?
           flag? ? handle_option! : set_task_name!
@@ -39,61 +43,59 @@ module Spud
           if flag?
             results.named[lstrip_hyphens(take!)] = take!
           else
-            results.positional << take!
+            results.ordered << take!
           end
         end
       end
 
-      # @return [void]
+      sig {void}
       def handle_option!
         flag = take!
         case flag
         when '-h', '--help' then options.help = true
-        when '-f', '--files' then options.files = true
-        when '-i', '--inspect' then options.inspect = true
         when '-w', '--watch' then options.watches << take!
-        when '--debug' then options.debug = true
+        when '-i', '--inspect' then options.inspect = true
         else raise Error, "invalid option: '#{flag}'"
         end
       end
 
-      # @return [Spud::Options]
+      sig {returns(Options)}
       def options
         results.options
       end
 
-      # @param flag [String]
-      # @return [String]
+      sig {params(flag: String).returns(String)}
       def lstrip_hyphens(flag)
         flag.gsub(/^-+/, '')
       end
 
-      # @return [Boolean]
+      sig {returns(T::Boolean)}
       def before_task_name?
         !results.task
       end
 
-      # @return [void]
+      sig {void}
       def set_task_name!
         results.task = take!
       end
 
-      # @return [String]
+      sig {returns(String)}
       def take!
         @args.shift
       end
 
       # @return [String]
+      sig {returns(String)}
       def arg
         @args.first
       end
 
-      # @return [Boolean]
+      sig {returns(T::Boolean)}
       def flag?
         arg.start_with?('-')
       end
 
-      # @return [Boolean]
+      sig {returns(T::Boolean)}
       def done?
         @args.empty?
       end

data/lib/spud/cli/results.rb

@@ -1,25 +1,32 @@
-require 'spud/options'
+# typed: strict
+require 'sorbet-runtime'
+require 'spud/cli/options'
 
 module Spud
   module CLI
     class Results
-      # @return [String]
-      attr_accessor :task
+      extend T::Sig
 
-      # @return [Spud::Options]
-      def options
-        @options ||= Options.new
-      end
+      sig {returns(T.nilable(String))}
+      attr_accessor :task
 
-      # @return [Array<String>]
-      def positional
-        @positional ||= []
+      sig {returns(T::Array[String])}
+      def ordered
+        @ordered = T.let(@ordered, T.nilable(T::Array[String]))
+        @ordered ||= []
       end
 
-      # @return [Hash{String->String}]
+      sig {returns(T::Hash[String, String])}
       def named
+        @named = T.let(@named, T.nilable(T::Hash[String, String]))
         @named ||= {}
       end
+
+      sig {returns(Options)}
+      def options
+        @options = T.let(@options, T.nilable(Options))
+        @options ||= Options.new
+      end
     end
   end
 end

data/lib/spud/driver.rb

@@ -0,0 +1,141 @@
+# typed: true
+require 'sorbet-runtime'
+require 'spud/error'
+require 'spud/help'
+require 'spud/lister'
+require 'spud/watch'
+require 'spud/cli/parser'
+require 'spud/cli/options'
+require 'spud/task_runners/task'
+require 'spud/task_runners/task_runners'
+require 'spud/task_runners/spud_task_runner/task'
+
+module Spud
+  class Driver
+    extend T::Sig
+
+    sig {returns(T.nilable(Integer))}
+    attr_reader :subprocess_pid
+
+    def initialize
+      @subprocess_pid = nil
+    end
+
+    sig {void}
+    def run!
+      if debug?
+        puts "options: #{options.inspect}"
+        puts "task: #{args.task}"
+        puts "ordered: #{args.ordered}"
+        puts "named: #{args.named}"
+      end
+
+      if options.help?
+        Help.print!
+        return
+      end
+
+      unless args.task
+        lister.list_tasks!
+        return
+      end
+
+      if options.inspect?
+        inspect!
+        return
+      end
+
+      invoke!
+    rescue Error => error
+      puts error.message
+      raise error if debug?
+    rescue Interrupt => error
+      puts "handled interrupt #{error}" if debug?
+    rescue => error
+      puts "fatal: #{error.message}"
+      raise error if debug?
+    end
+
+    sig {params(name: String, ordered: T::Array[String], named: T::Hash[T.any(String, Symbol), String]).returns(T.untyped)}
+    def invoke(name, ordered, named)
+      get_task(name).invoke(ordered, stringify_keys(named))
+    end
+
+    sig {params(pid: T.nilable(Integer)).void}
+    def register_subprocess(pid)
+      @subprocess_pid = pid
+    end
+
+    sig {returns(T::Boolean)}
+    def debug?
+      @debug ||= ENV.key?('SPUD_DEBUG') && ENV['SPUD_DEBUG'] != 'false'
+    end
+
+    private
+
+    sig {void}
+    def invoke!
+      task_name = T.must(args.task)
+      task = get_task(task_name)
+
+      watches = options.watches
+      watches = task.watches if watches.empty?
+
+      if watches.empty?
+        invoke(task_name, args.ordered, args.named)
+      else
+        raise Error, "watches only supported for Spud tasks" unless task.is_a?(TaskRunners::SpudTaskRunner::Task)
+
+        Watch.run!(
+          driver: self,
+          task: task_name,
+          ordered: args.ordered,
+          named: args.named,
+          watches: watches,
+        )
+      end
+    end
+
+    sig {void}
+    def inspect!
+      puts get_task(T.must(args.task)).details
+    end
+
+    sig {params(task_name: String).returns(TaskRunners::Task)}
+    def get_task(task_name)
+      task = tasks[task_name]
+      raise Error, "no task found for '#{task_name}'" unless task
+
+      task
+    end
+
+    sig {returns(T::Hash[String, TaskRunners::Task])}
+    def tasks
+      @tasks ||= TaskRunners.get.each_with_object({}) do |task_runner, tasks|
+        task_runner.tasks(self).each do |task|
+          tasks[task.name] = task
+        end
+      end
+    end
+
+    sig {returns(CLI::Results)}
+    def args
+      @args ||= CLI::Parser.parse!
+    end
+
+    sig {returns(Lister)}
+    def lister
+      @lister ||= Lister.new(tasks.values)
+    end
+
+    sig {returns(CLI::Options)}
+    def options
+      args.options
+    end
+
+    sig {params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[String, T.untyped])}
+    def stringify_keys(hash)
+      hash.each_with_object({}) { |(key, value), new_hash| new_hash[key.to_s] = value }
+    end
+  end
+end

data/lib/spud/error.rb

@@ -1,6 +1,11 @@
+# typed: strict
+require 'sorbet-runtime'
+
 module Spud
   class Error < StandardError
-    # @return [String]
+    extend T::Sig
+
+    sig {override.returns(String)}
     def message
       "spud: #{super}"
     end