spud 0.1.15 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff2253281ad17fa26000da387d071fca88fe39e6c01913573bf1aa78148c9302
-  data.tar.gz: 449e2aead6ea9686659c8b928ca9f4fa07f582156d30e2ae24bbc5680382cd58
+  metadata.gz: c55ea01a3c22d6170762c1097849e93cdd4d0444b4b1bd7bed95ecd73a642ded
+  data.tar.gz: a2744808ed721659bef1b3af24c87fee6913795dca9631ab86f7058b714e110c
 SHA512:
-  metadata.gz: 3f29e51971b0f78eb223e0561bc28a641fa167d72a5e10f996752fffefe8ead8c8fbb09707a24b2192c72b341dd039711808cfe2d6b7dbe78e5cb416c71075a8
-  data.tar.gz: 244352f4d935f8f00bc307b88f810743358e1eed079c9f7ef8ffabaca55df1929e9eb7933c5ae76a29bdfa4f9037a519b1ee205e592e49ed3e49f1207a1d4f51
+  metadata.gz: 09f1d72b9df4f1c0d6eda2815b1c508e2c06bb33d7d9f68829681b50ae3d04ac09b59afd47eaed0eb2952f25c29142fe9306791fd1e46aad3f25a5add8d8ff0e
+  data.tar.gz: d5379e5f5e250da3dec466f4cebe063e994a62c618cff987b202fd650be9a8e3a95fe61bce853b4d0ff8eaaa448883522306efc5c15d3da96d2672d27e1f743a

data/lib/spud.rb

@@ -1,192 +1,7 @@
-require 'stringio'
-require_relative 'args'
-require_relative 'version'
-require_relative 'build_tools/build_tools'
-require_relative 'build_tools/spud/shell_error'
+require_relative 'spud/runtime'
 
 module Spud
   def self.run!
-    Spud.new.run!
-  end
-
-  class Spud
-    def run!
-      if options[:help]
-        print_help!
-        return
-      end
-
-      if options[:version]
-        puts VERSION
-        return
-      end
-
-      unless rule_name
-        print_rules!
-        return
-      end
-
-      unless options[:watches].empty?
-        watch(options[:watches], rule_name, *args[:positional], **args[:keyword])
-        return
-      end
-
-      invoke(rule_name, *args[:positional], **args[:keyword])
-    rescue BuildTools::SpudBuild::ShellError => e
-      raise e if options[:debug]
-
-    rescue => e
-      raise e if options[:debug]
-      puts e.message
-    end
-
-    def invoke(name, *args, **kwargs)
-      rule = rules[name.to_s]
-      raise Error, "no rule found for '#{name}'" unless rule
-      rule.invoke(*args, **kwargs)
-    end
-
-    def watch(globs, name, *args, **kwargs)
-      rule = rules[name.to_s]
-      raise Error, "no rule found for '#{name}'" unless rule
-
-      thread = nil
-      timestamps = {}
-      loop do
-        begin
-          filenames = Dir.glob(*globs)
-          filenames.each do |filename|
-            new_timestamp = File.mtime(filename)
-            old_timestamp = timestamps[filename]
-
-            if !old_timestamp || new_timestamp > old_timestamp
-              timestamps[filename] = new_timestamp
-
-              thread.kill if thread
-              thread = Thread.new { invoke(name, *args, **kwargs) }
-              break
-            end
-          end
-
-          sleep 0.1
-        rescue Interrupt
-          thread.kill if thread
-          break
-        end
-      end
-    end
-
-    private
-
-    # Rules
-    def rules
-      @rules ||= build_tools.reduce({}) { |rules, tool| rules.merge(tool.rules) }
-    end
-
-    def build_tools
-      @build_tools ||= BuildTools::BUILD_TOOLS
-        .reverse
-        .map { |tool| tool.new(self) }
-        .each(&:mount!)
-    end
-
-    def print_rules!
-      #table = rules.map { |name, rule| { name: name, filename: rule.filename } }
-
-      longest_name = 0
-      longest_filename = 0
-      longest_positional = 0
-      longest_keyword = 0
-      table = []
-      rules.each do |name, rule|
-        longest_name = name.length if name.length > longest_name
-
-        positional = rule.positional_params.map(&method(:wrap_param)).join(' ')
-        longest_positional = positional.length if positional.length > longest_positional
-
-        keyword = rule.keyword_params.map(&method(:prefix_param)).join(' ')
-        longest_keyword = keyword.length if keyword.length > longest_keyword
-
-        longest_filename = rule.filename.length if rule.filename.length > longest_filename
-
-        table << [name, positional, keyword, rule.filename]
-      end
-
-      table.each do |(name, positional, keyword, filename)|
-        fields = [name.ljust(longest_name)]
-        fields << positional.ljust(longest_positional) unless longest_positional == 0
-        fields << keyword.ljust(longest_keyword) unless longest_keyword == 0
-        fields << filename.ljust(longest_filename)
-
-        puts fields.join('  ')
-      end
-
-      return
-
-      longest_rule = 0
-      longest_filename = 0
-      longest_positional = 0
-      longest_keyword = 0
-      table.each do |(rule, filename)|
-        longest_rule = rule.length if rule.length > longest_rule
-        longest_filename = filename.length if filename.length > longest_filename
-
-        positional = rule.positional_params.map(&method(:wrap_param)).join(' ')
-        longest_positional = positional.length if positional.length > longest_positional
-
-        keyword = rule.keyword_params.map(&method(:prefix_param)).join(' ')
-        longest_keyword = keyword.length if keyword.length > longest_keyword
-      end
-
-      table.each do |(rule, filename)|
-        [
-          [rule, longest_rule],
-          [positional, longest_positional],
-          [filename, longest_filename],
-          [filename, longest_filename],
-        ]
-
-        puts "#{rule.ljust(longest_rule)}  #{filename.ljust(longest_filename)}"
-      end
-    end
-
-    def wrap_param(name)
-      "<#{name}>"
-    end
-
-    def prefix_param(name)
-      name.length == 1 ? "-#{name}" : "--#{name}"
-    end
-
-    # Help
-    def print_help!
-      help = StringIO.new
-
-      help.puts "spud #{VERSION}"
-      help.puts
-      help.puts 'usage:'
-      help.puts '  spud [options] <rule> [args]'
-      help.puts
-      help.puts 'options:'
-      help.puts '  -h, --help           show this help dialog dialog'
-      help.puts '  -v, --version        show spud version'
-      help.puts '  -w, --watch <files>  watch files for changes'
-      help.puts '  --debug              run in debug mode'
-
-      puts help.string
-    end
-
-    # Args
-    def options
-      @options ||= args[:options]
-    end
-
-    def rule_name
-      @rule_name ||= args[:rule]
-    end
-
-    def args
-      @args ||= Args.parse_args!
-    end
+    Runtime.run!
   end
 end

data/lib/spud/build_tools/build_tools.rb

@@ -0,0 +1,13 @@
+require 'spud/build_tools/spud/task'
+require 'spud/build_tools/make/task'
+require 'spud/build_tools/package.json/task'
+
+module Spud
+  module BuildTools
+    BUILD_TOOLS = [
+      Spud::Task,
+      Make::Task,
+      PackageJSON::Task,
+    ]
+  end
+end

data/lib/spud/build_tools/make/task.rb

@@ -0,0 +1,27 @@
+require 'spud/build_tools/task'
+
+module Spud
+  module BuildTools
+    module Make
+      class Task < BuildTools::Task
+        def self.mount!
+          return unless File.exist?('Makefile')
+
+          if `command -v make`.empty?
+            puts 'Makefile detected, but no installation of `make` exists. Skipping make...'
+            return
+          end
+
+          source = File.read('Makefile')
+          source.scan(/^(\S+):.*/).map(&:first).each do |name|
+            new(name: name, filename: 'Makefile')
+          end
+        end
+
+        def invoke(*)
+          system('make', name)
+        end
+      end
+    end
+  end
+end

data/lib/spud/build_tools/package.json/task.rb

@@ -0,0 +1,47 @@
+require 'json'
+require 'spud/build_tools/task'
+
+module Spud
+  module BuildTools
+    module PackageJSON
+      class Task < BuildTools::Task
+        def self.mount!
+          return unless File.exist?('package.json')
+
+          opening_commands = %w[npm run]
+          if File.exist?('package.lock')
+            if `command -v npm`.empty?
+              puts 'package.json detected, but no installation of `npm` exists. Skipping npm...'
+              return
+            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
+              opening_commands = %w[yarn run]
+            end
+          end
+
+          source = File.read('package.json')
+          json = JSON.parse(source)
+          scripts = json['scripts']
+          return unless scripts
+
+          scripts.keys.each do |name|
+            new(name: name, filename: 'package.json', opening_commands: opening_commands)
+          end
+        end
+
+        def initialize(name:, filename:, opening_commands:)
+          super(name: name, filename: filename)
+          @opening_commands = opening_commands
+        end
+
+        def invoke(*)
+          system(*(@opening_commands + [name]))
+        end
+      end
+    end
+  end
+end

data/lib/spud/build_tools/spud/block_param_info.rb

@@ -0,0 +1,77 @@
+require 'spud/task_arg'
+
+module Spud
+  module BuildTools
+    module Spud
+      class BlockParamInfo
+        # @param filename [String]
+        # @param block [Proc]
+        def initialize(filename, &block)
+          @filename = filename
+          @block = block
+        end
+
+        # @return [Array<Spud::TaskArg>]
+        def task_args
+          parameters.map do |type, name|
+            case type
+            when :req
+              TaskArg.new(name, 'positional')
+            when :opt
+              TaskArg.new(name, 'positional', default: arg_values[name])
+            when :keyreq
+              TaskArg.new(name, 'named')
+            when :key
+              TaskArg.new(name, 'named', default: arg_values[name])
+            end
+          end
+        end
+
+        # @return [Array]
+        def dummy_args
+          [dummy_positional_args, dummy_named_args]
+        end
+
+        # @return [Array<NilClass>]
+        def dummy_positional_args
+          Array.new(parameters.count { |p| p.first == :req })
+        end
+
+        # @return [Hash{Symbol->NilClass}]
+        def dummy_named_args
+          parameters.select { |p| p.first == :keyreq }.map(&:last).each_with_object({}) { |n, h| h[n] = nil }
+        end
+
+        # @return [String]
+        def arg_hash_string
+          "{ #{parameters.map(&:last).map { |n| "#{n}: #{n}" }.join(', ')} }"
+        end
+
+        # @return [Hash]
+        def arg_values
+          @arg_values ||= begin
+            positional, named = dummy_args
+            lambda(arg_hash_string).call(*positional, **named)
+          end
+        end
+
+        # @return [Array<Array<Symbol>>]
+        def parameters
+          @parameters ||= lambda.parameters
+        end
+
+        # @return [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 = match[:params]
+          param_source += ', _: nil, __: nil, ___: nil' if body
+          eval "-> (#{param_source}) { #{body} }"
+        end
+      end
+    end
+  end
+end

data/lib/spud/build_tools/spud/dsl/file.rb

@@ -0,0 +1,23 @@
+require 'spud/build_tools/spud/task'
+
+module Spud
+  module BuildTools
+    module Spud
+      module DSL
+        class File
+          def require_relative(name)
+            require("./#{name}")
+          end
+
+          def task(name, *, &block)
+            BuildTools::Spud::Task.add_task(name, &block)
+          end
+
+          def method_missing(name, *args, &block)
+            task(name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spud/build_tools/spud/dsl/task.rb

@@ -0,0 +1,63 @@
+require 'spud/error'
+require 'spud/build_tools/spud/task'
+require 'spud/build_tools/spud/shell/command'
+
+module Spud
+  module BuildTools
+    module Spud
+      module DSL
+        class Task
+          def initialize(filename)
+            @filename = filename
+          end
+
+          def sh(command)
+            puts command
+            Shell::Command.(command)
+          end
+
+          def shh(command)
+            Shell::Command.(command)
+          end
+
+          def shhh(command)
+            Shell::Command.(command, silent: true)
+          end
+
+          def sh!(command)
+            puts command
+            result = Shell::Command.(command)
+            raise Error, "sh failed for '#{command}'" unless result.success?
+            result
+          end
+
+          def shh!(command)
+            result = Shell::Command.(command)
+            raise Error, "sh failed for '#{command}'" unless result.success?
+            result
+          end
+
+          def shhh!(command)
+            result = Shell::Command.(command, silent: true)
+            raise Error, "sh failed for '#{command}'" unless result.success?
+            result
+          end
+
+          def invoke(task, *positional, **named)
+            Spud::Task.invoke(@filename, task, positional, named)
+          rescue Error => error
+            puts "invoke failed for #{task}: #{error}"
+          end
+
+          def invoke!(task, *positional, **named)
+            Spud::Task.invoke(@filename, task, positional, named)
+          end
+
+          def method_missing(symbol, *positional, **named)
+            Spud::Task.task_for(@filename, symbol) ? Spud::Task.invoke(@filename, symbol, positional, named) : super
+          end
+        end
+      end
+    end
+  end
+end