spud 0.1.16 → 0.2.1

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

@@ -0,0 +1,52 @@
+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/shell/result.rb

@@ -0,0 +1,26 @@
+module Spud
+  module BuildTools
+    module Spud
+      module Shell
+        class Result < String
+          attr_reader :status
+
+          # @param output [String]
+          # @param status [Process::Status]
+          def initialize(output, status)
+            super(output)
+            @status = status
+          end
+
+          def method_missing(symbol, *args)
+            status.respond_to?(symbol) ? status.send(symbol, *args) : super
+          end
+
+          def respond_to_missing?(symbol, *)
+            status.respond_to?(symbol) || super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+require 'spud/error'
+require 'spud/task_args'
+require 'spud/build_tools/task'
+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, &block)
+          raise "task '#{task}' somehow created without filename" unless @filename
+
+          new(name: qualified_name(@filename, task.to_s), filename: @filename, &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]
+        def self.task_for(filename, task)
+          Runtime.tasks[qualified_name(filename, task.to_s)]
+        end
+
+        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
+
+        def initialize(name:, filename:, &block)
+          super
+          @block = block
+        end
+
+        # @param positional [Array]
+        # @param named [Hash]
+        # @return [Object]
+        def invoke(positional, named)
+          check_required!(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
+
+        private
+
+        # @param positional [Array<String>]
+        # @return [void]
+        def check_required!(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 [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

data/lib/spud/build_tools/task.rb

@@ -0,0 +1,33 @@
+module Spud
+  module BuildTools
+    class Task
+      # @return [String]
+      attr_reader :name
+      # @return [String]
+      attr_reader :filename
+      # @return [Spud::TaskArgs]
+      attr_reader :args
+
+      # @return [void]
+      def self.mount!
+        raise NotImplementedError
+      end
+
+      # @param name [String]
+      # @param filename [String]
+      def initialize(name:, filename:)
+        @name = name
+        @filename = filename
+
+        Runtime.tasks[name.to_s] = self
+      end
+
+      # @param positional [Array]
+      # @param named [Hash]
+      # @return [Object]
+      def invoke(positional = [], named = {})
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/spud/cli/parser.rb

@@ -0,0 +1,101 @@
+require 'spud/cli/results'
+
+module Spud
+  module CLI
+    class Parser
+      # @return [Spud::CLI::Results]
+      attr_reader :results
+
+      # @return [void]
+      def self.parse!
+        parse(ARGV)
+      end
+
+      # @param args [Array<String>]
+      # @return [Spud::CLI::Results]
+      def self.parse(args)
+        new(args).parse!
+      end
+
+      # @param args [Array<String>]
+      def initialize(args)
+        @args = args.dup
+        @results = Results.new
+      end
+
+      # @return [void]
+      def parse!
+        parse_arg! until done?
+        results
+      end
+
+      private
+
+      # @return [void]
+      def parse_arg!
+        if before_task_name?
+          flag? ? handle_option! : set_task_name!
+        else
+          if flag?
+            results.named[lstrip_hyphens(take!)] = take!
+          else
+            results.positional << take!
+          end
+        end
+      end
+
+      # @return [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
+        else raise Error, "invalid option: '#{flag}'"
+        end
+      end
+
+      # @return [Spud::Options]
+      def options
+        results.options
+      end
+
+      # @param flag [String]
+      # @return [String]
+      def lstrip_hyphens(flag)
+        flag.gsub(/^-+/, '')
+      end
+
+      # @return [Boolean]
+      def before_task_name?
+        !results.task
+      end
+
+      # @return [void]
+      def set_task_name!
+        results.task = take!
+      end
+
+      # @return [String]
+      def take!
+        @args.shift
+      end
+
+      # @return [String]
+      def arg
+        @args.first
+      end
+
+      # @return [Boolean]
+      def flag?
+        arg.start_with?('-')
+      end
+
+      # @return [Boolean]
+      def done?
+        @args.empty?
+      end
+    end
+  end
+end

data/lib/spud/cli/results.rb

@@ -0,0 +1,25 @@
+require 'spud/options'
+
+module Spud
+  module CLI
+    class Results
+      # @return [String]
+      attr_accessor :task
+
+      # @return [Spud::Options]
+      def options
+        @options ||= Options.new
+      end
+
+      # @return [Array<String>]
+      def positional
+        @positional ||= []
+      end
+
+      # @return [Hash{String->String}]
+      def named
+        @named ||= {}
+      end
+    end
+  end
+end

data/lib/{error.rb → spud/error.rb}

@@ -1,5 +1,6 @@
 module Spud
   class Error < StandardError
+    # @return [String]
     def message
       "spud: #{super}"
     end

data/lib/spud/help.rb

@@ -0,0 +1,23 @@
+require 'stringio'
+require 'spud/version'
+
+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 '  --debug      run in debug mode'
+
+      puts help.string
+    end
+  end
+end

data/lib/spud/lister.rb

@@ -0,0 +1,86 @@
+require 'stringio'
+
+module Spud
+  class Lister
+    # @param tasks [Array<BuildTools::Task>]
+    def initialize(tasks)
+      @tasks = tasks
+    end
+
+    # @return [void]
+    def list!
+      builder = StringIO.new
+
+      @tasks.each do |task|
+        builder.write task.name.ljust(max_task_length)
+
+        if show_positional_args?
+          builder.write '  '
+          builder.write task.args.positional.join(' ').ljust(max_positional_string_length)
+        end
+
+        if show_named_args?
+          builder.write '  '
+          builder.write task.args.named.join(' ').ljust(max_named_string_length)
+        end
+
+        if show_filenames?
+          builder.write '  '
+          builder.write task.filename
+        end
+
+        builder.write "\n"
+      end
+
+      puts builder.string
+    end
+
+    # @return [void]
+    def list_filenames!
+      puts filenames.join("\n")
+    end
+
+    private
+
+    # @return [Integer]
+    def max_task_length
+      @max_task_length ||= @tasks.map { |task| task.name.length }.max
+    end
+
+    # @return [Integer]
+    def max_positional_string_length
+      @max_positional_string_length ||= @tasks
+        .map { |task| task.args.positional.join(' ') }
+        .map(&:length)
+        .max
+    end
+
+    # @return [Boolean]
+    def show_positional_args?
+      @show_positional_args ||= @tasks.any? { |task| task.args.any_positional? }
+    end
+
+    # @return [Integer]
+    def max_named_string_length
+      @max_named_string_length ||= @tasks
+        .map { |task| task.args.named.join(' ') }
+        .map(&:length)
+        .max
+    end
+
+    # @return [Boolean]
+    def show_named_args?
+      @show_named_args ||= @tasks.any? { |task| task.args.any_named? }
+    end
+
+    # @return [Array<String>]
+    def filenames
+      @filenames ||= @tasks.map(&:filename).uniq
+    end
+
+    # @return [Boolean]
+    def show_filenames?
+      filenames.length > 1
+    end
+  end
+end