spud 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c426d3d847aaa06b411cb1eba2e84ddf7ea45ff43d9d02781075637cac24f395
-  data.tar.gz: 2e37705b14ca816367dd038eb51d402e20d4fac00e144f263fcc8a930654023e
+  metadata.gz: f3508c944aca0510946f7705ce2f1fb057632619f11182a872affe5bced27a8e
+  data.tar.gz: 3f6c06be53831bad47cfcee5314982e1d2cd165078607b98b2f48b25a75ca2f6
 SHA512:
-  metadata.gz: 44a4bd5790ca2613a7af968fc04c7460264a83743ca68ce77513eaafa41098b4fedea9d8a95163100eef2ddb48f2f91182ba7d38df0cdf4a04ae05d8f146b641
-  data.tar.gz: 17f6f57907780792ee7606520a53a2b373b722ab88bf981eb8193663975e716583f3597835035c228e79c9b8d7c6ea43ea88ab3d63be615b1c6530949c1da7cc
+  metadata.gz: b4f6ed2d24030f329187f61475ccfebddf169cec0fdc7c17a8679de302747da7fe1ce74d8a4d92b000af8e50e3e927f103f00d445861e0e6b8cc8f85d8ff62b7
+  data.tar.gz: 7a68fd902c3a6494fd2659edf642b924d10a240b59fa7b0780b42392bf69b0dd5f254872ced0490911870b7f49a2eda8f4451b4547140dca89214473c41e02a3

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,61 +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 '-w', '--watch' then options.watches << take!
         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
         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,134 @@
+# 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 SystemExit, 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]).void}
+    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,3 +1,4 @@
+# typed: true
 module Spud
   class Error < StandardError
     # @return [String]

data/lib/spud/help.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'stringio'
 require 'spud/version'
 
@@ -5,20 +6,18 @@ module Spud
   module Help
     # @return [void]
     def self.print!
-      help = StringIO.new
-
-      help.puts "spud #{VERSION}"
-      help.puts
-      help.puts 'usage:'
-      help.puts '  spud [options] <task> [args]'
-      help.puts
-      help.puts 'options:'
-      help.puts '  -h, --help     show this help dialog'
-      help.puts '  -f, --files    list parsed files'
-      help.puts '  -i, --inspect  show details about a task'
-      help.puts '  --debug        run in debug mode'
-
-      puts help.string
+      puts <<~HELP
+        spud #{VERSION}
+        
+        usage:
+          spud [options] <task> [args]
+        
+        options:
+          -h, --help          show this help dialog
+          -w, --watch <glob>  re-run task any time glob changes
+          -f, --files         list parsed files
+          -i, --inspect       show details about a task
+      HELP
     end
   end
 end