spud 0.2.1 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 12c0947e9a6ed28a7e5be6d84476232612e567b239beff99648ada975921dc51
-  data.tar.gz: 12dc859d0cfd9307bc4fcd6ed5858e75af83179ad59c1a17ac21d83955e04ba5
+SHA1:
+  metadata.gz: ea40b0df03085beb5350590ed0336f4bbac760ff
+  data.tar.gz: 93427f8d7a3d1906d8f5ac082b54ee7a343afbec
 SHA512:
-  metadata.gz: 06f7ddbab9f8369e52fd3ecf467a2afcb12536b59ab50c97f2aa731ebac12af6f0b4bac9c0034309451073331472fa04aeeb6d11e8541e27fd5387f7028ee453
-  data.tar.gz: 227eeefc6c59f2bd6a9f02470070c5424fa3b53e4f872613da31026bf342909d432b8d5e2a49ded2b28372b435ab96d92c616a810dc2d9dd4fb5484702670d5f
+  metadata.gz: 9e5125c223b8e4733a018cbfc31239f6f9dc9a7b6912785f3167cebf67f07886f64106f64940e1f5fe50e7516d76b5c0dddbbfe4ed53d7b2edc837a08b193068
+  data.tar.gz: 052fb31ba933ffaf3520669830d37bf292f325c1d54072ce29642b20d3dac53d71f76ef9afb7eb5e6eb1ecd8d76da0a3dc7368c66b17b65cceaec387c1296a05

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,35 @@
+# typed: true
+require 'sorbet-runtime'
+
+module Spud
+  module CLI
+    class Options
+      extend T::Sig
+
+      attr_writer :help
+      attr_writer :files
+      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 files?
+        !!@files
+      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,60 +43,60 @@ 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 '-w', '--watch' then options.watches << take!
-        when '--debug' then options.debug = true
+        when '-f', '--files' then options.files = 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,136 @@
+# 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'
+
+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
+
+      if options.files?
+        lister.list_filenames!
+        return
+      end
+
+      unless args.task
+        lister.list_tasks!
+        return
+      end
+
+      task = T.must(args.task)
+      if options.inspect?
+        puts get_task(task).details
+        return
+      end
+
+      unless options.watches.empty?
+        watch!
+        return
+      end
+
+      invoke(task, args.ordered, args.named)
+    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 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
+
+    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 watch!
+      Watch.run!(
+        driver: self,
+        task: T.must(args.task),
+        ordered: args.ordered,
+        named: args.named,
+        watches: options.watches,
+      )
+    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: true
+require 'sorbet-runtime'
+
 module Spud
   class Error < StandardError
-    # @return [String]
+    extend T::Sig
+
+    sig {override.returns(String)}
     def message
       "spud: #{super}"
     end