spud 0.2.3 → 0.2.4

data/lib/spud/build_tools/build_tools.rb

@@ -1,13 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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, dependencies = {}, &block)
-            BuildTools::Spud::Task.add_task(name, dependencies, &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

@@ -1,63 +0,0 @@
-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

data/lib/spud/build_tools/spud/shell/command.rb

@@ -1,52 +0,0 @@
-require 'stringio'
-require 'open3'
-require 'spud/build_tools/spud/shell/result'
-
-module Spud
-  module BuildTools
-    module Spud
-      module Shell
-        class Command
-          attr_reader :result
-
-          # @param command [String]
-          # @param silent [Boolean]
-          # @param handle [IO]
-          def self.call(command, silent: false, handle: STDOUT)
-            cmd = new(command, silent: silent, handle: handle)
-            cmd.issue!
-            cmd.result
-          end
-
-          # @param command [String]
-          # @param silent [Boolean]
-          # @param handle [IO]
-          def initialize(command, silent: false, handle: STDOUT)
-            @command = command
-            @silent = silent
-            @handle = handle
-
-            @result = nil
-          end
-
-          # @return [void]
-          def issue!
-            capturer = StringIO.new
-
-            Open3.popen2e(@command) do |_stdin, stdout, thread|
-              loop do
-                line = stdout.gets
-                break unless line
-
-                @handle.write line unless @silent
-                capturer.puts line
-              end
-
-              @result = Result.new(capturer.string, thread.value)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,177 +0,0 @@
-require 'stringio'
-require 'spud/error'
-require 'spud/task_args'
-require 'spud/build_tools/task'
-require 'spud/build_tools/spud/dependency'
-require 'spud/build_tools/spud/task'
-require 'spud/build_tools/spud/dsl/file'
-require 'spud/build_tools/spud/dsl/task'
-
-module Spud
-  module BuildTools
-    module Spud
-      class Task < BuildTools::Task
-        # @return [void]
-        def self.mount!
-          Dir['**/Spudfile', '**/*.spud'].each do |filename|
-            @filename = filename
-            file_dsl.instance_eval(File.read(filename), filename)
-          end
-
-          @filename = nil
-        end
-
-        # @return [Spud::DSL::File]
-        def self.file_dsl
-          @file_dsl ||= DSL::File.new
-        end
-
-        # @param task [String]
-        # @param block [Proc]
-        # @return [void]
-        def self.add_task(task, dependencies, &block)
-          new(
-            name: qualified_name(@filename, task.to_s),
-            filename: @filename,
-            dependencies: dependencies,
-            &block
-          )
-        end
-
-        # @param filename [String]
-        # @param task [String]
-        # @param positional [Array]
-        # @param named [Hash]
-        def self.invoke(filename, task, positional, named)
-          task = task.to_s
-          task_obj = task_for(filename, task)
-          if task_obj
-            Runtime.invoke(task_obj.name, positional, named)
-          else
-            Runtime.invoke(task, positional, named)
-          end
-        end
-
-        # @param filename [String]
-        # @param task [String]
-        # @return [BuildTools::Spud::Task]
-        def self.task_for(filename, task)
-          Runtime.tasks[qualified_name(filename, task.to_s)]
-        end
-
-        # @param filename [String]
-        # @param task [String]
-        # @return [String]
-        def self.qualified_name(filename, task)
-          raise "task '#{task}' somehow created without filename" unless filename
-
-          [qualified_prefix(filename), task.to_s].join('.').gsub(/^\./, '')
-        end
-
-        # @param filename [String]
-        # @return [String]
-        def self.qualified_prefix(filename)
-          dirname = File.dirname(filename)
-          dirname = '' if dirname == '.'
-
-          basename = File.basename(filename, '.spud')
-          basename_array = basename == 'Spudfile' ? [] : [basename]
-
-          (dirname.split('/') + basename_array).join('.')
-        end
-
-        # @param name [String]
-        # @param filename [String]
-        # @param dependencies [Hash]
-        # @param block [Proc]
-        def initialize(name:, filename:, dependencies:, &block)
-          super(name: name, filename: filename)
-          @dependencies = dependencies.map { |to, from| Dependency.new(to, from) }
-          @block = block
-        end
-
-        # @param positional [Array]
-        # @param named [Hash]
-        # @return [Object]
-        def invoke(positional, named)
-          if up_to_date?
-            puts "'#{name}' up to date"
-            return
-          end
-
-          check_required_args!(positional)
-
-          return task_dsl.instance_exec(*positional, &@block) unless args.any_named?
-
-          task_dsl.instance_exec(*positional, **symbolize_keys(named), &@block)
-        rescue ArgumentError => error
-          raise Error, "invocation of '#{name}' with #{error.message}"
-        end
-
-        # @return [Spud::TaskArgs]
-        def args
-          @args ||= ::Spud::TaskArgs.from_block(filename, &@block)
-        end
-
-        # @return [String]
-        def details
-          filename, line_cursor = @block.source_location
-          line_cursor -= 1
-
-          lines = File.read(filename).split("\n")
-          builder = StringIO.new
-
-          while lines[line_cursor - 1] && lines[line_cursor - 1].start_with?('#')
-            line_cursor -= 1
-          end
-
-          while lines[line_cursor].start_with?('#')
-            builder.puts lines[line_cursor]
-            line_cursor += 1
-          end
-
-          until lines[line_cursor].start_with?('end')
-            builder.puts lines[line_cursor]
-            line_cursor += 1
-          end
-
-          builder.puts lines[line_cursor]
-          builder.string
-        end
-
-        private
-
-        # @param positional [Array<String>]
-        # @return [void]
-        def check_required_args!(positional)
-          required_positional = args.required_positional
-          missing_positional = required_positional.length - positional.length
-          if missing_positional > 0
-            arguments = required_positional.length - missing_positional > 1 ? 'arguments' : 'argument'
-            raise Error, "invocation of '#{name}' missing required #{arguments} #{required_positional.join(', ')}"
-          end
-        end
-
-        # @return [Boolean]
-        def up_to_date?
-          return false if @dependencies.empty?
-
-          @dependencies.all?(&:up_to_date?)
-        end
-
-        # @return [Spud::DSL::Task]
-        def task_dsl
-          @task_dsl ||= DSL::Task.new(filename)
-        end
-
-        # @param hash [Hash]
-        # @return [Hash]
-        def symbolize_keys(hash)
-          hash.each_with_object({}) do |(key, value), new_hash|
-            new_hash[key.is_a?(String) ? key.to_sym : key] = value
-          end
-        end
-      end
-    end
-  end
-end