summaryrefslogtreecommitdiffstats
path: root/debian/vendor-h2o/deps/mruby/minirake
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-13 21:12:02 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-13 21:12:02 +0000
commit77e50caaf2ef81cd91075cf836fed0e75718ffb4 (patch)
tree53b7b411290b63192fc9e924a3b6b65cdf67e9d0 /debian/vendor-h2o/deps/mruby/minirake
parentAdding upstream version 1.8.3. (diff)
downloaddnsdist-77e50caaf2ef81cd91075cf836fed0e75718ffb4.tar.xz
dnsdist-77e50caaf2ef81cd91075cf836fed0e75718ffb4.zip
Adding debian version 1.8.3-2.debian/1.8.3-2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'debian/vendor-h2o/deps/mruby/minirake')
-rwxr-xr-xdebian/vendor-h2o/deps/mruby/minirake484
1 files changed, 484 insertions, 0 deletions
diff --git a/debian/vendor-h2o/deps/mruby/minirake b/debian/vendor-h2o/deps/mruby/minirake
new file mode 100755
index 0000000..542c37a
--- /dev/null
+++ b/debian/vendor-h2o/deps/mruby/minirake
@@ -0,0 +1,484 @@
+#!/usr/bin/env ruby
+
+# Original is https://github.com/jimweirich/rake/
+# Copyright (c) 2003 Jim Weirich
+# License: MIT-LICENSE
+
+require 'getoptlong'
+require 'fileutils'
+
+class String
+ def ext(newext='')
+ return self.dup if ['.', '..'].include? self
+ if newext != ''
+ newext = (newext =~ /^\./) ? newext : ("." + newext)
+ end
+ self.chomp(File.extname(self)) << newext
+ end
+
+ def pathmap(spec=nil, &block)
+ return self if spec.nil?
+ result = ''
+ spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
+ case frag
+ when '%f'
+ result << File.basename(self)
+ when '%n'
+ result << File.basename(self).ext
+ when '%d'
+ result << File.dirname(self)
+ when '%x'
+ result << File.extname(self)
+ when '%X'
+ result << self.ext
+ when '%p'
+ result << self
+ when '%s'
+ result << (File::ALT_SEPARATOR || File::SEPARATOR)
+ when '%-'
+ # do nothing
+ when '%%'
+ result << "%"
+ when /%(-?\d+)d/
+ result << pathmap_partial($1.to_i)
+ when /^%\{([^}]*)\}(\d*[dpfnxX])/
+ patterns, operator = $1, $2
+ result << pathmap('%' + operator).pathmap_replace(patterns, &block)
+ when /^%/
+ fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
+ else
+ result << frag
+ end
+ end
+ result
+ end
+end
+
+module MiniRake
+ class Task
+ TASKS = Hash.new
+ RULES = Array.new
+
+ # List of prerequisites for a task.
+ attr_reader :prerequisites
+
+ # Source dependency for rule synthesized tasks. Nil if task was not
+ # sythesized from a rule.
+ attr_accessor :source
+
+ # Create a task named +task_name+ with no actions or prerequisites..
+ # use +enhance+ to add actions and prerequisites.
+ def initialize(task_name)
+ @name = task_name
+ @prerequisites = []
+ @actions = []
+ end
+
+ # Enhance a task with prerequisites or actions. Returns self.
+ def enhance(deps=nil, &block)
+ @prerequisites |= deps if deps
+ @actions << block if block_given?
+ self
+ end
+
+ # Name of the task.
+ def name
+ @name.to_s
+ end
+
+ # Invoke the task if it is needed. Prerequites are invoked first.
+ def invoke
+ puts "Invoke #{name} (already=[#{@already_invoked}], needed=[#{needed?}])" if $trace
+ return if @already_invoked
+ @already_invoked = true
+ prerequisites = @prerequisites.collect{ |n| n.is_a?(Proc) ? n.call(name) : n }.flatten
+ prerequisites.each { |n| Task[n].invoke }
+ execute if needed?
+ end
+
+ # Execute the actions associated with this task.
+ def execute
+ puts "Execute #{name}" if $trace
+ self.class.enhance_with_matching_rule(name) if @actions.empty?
+ unless $dryrun
+ @actions.each { |act| act.call(self) }
+ end
+ end
+
+ # Is this task needed?
+ def needed?
+ true
+ end
+
+ # Timestamp for this task. Basic tasks return the current time for
+ # their time stamp. Other tasks can be more sophisticated.
+ def timestamp
+ Time.now
+ end
+
+ # Class Methods ----------------------------------------------------
+
+ class << self
+
+ # Clear the task list. This cause rake to immediately forget all
+ # the tasks that have been assigned. (Normally used in the unit
+ # tests.)
+ def clear
+ TASKS.clear
+ RULES.clear
+ end
+
+ # List of all defined tasks.
+ def tasks
+ TASKS.keys.sort.collect { |tn| Task[tn] }
+ end
+
+ # Return a task with the given name. If the task is not currently
+ # known, try to synthesize one from the defined rules. If no
+ # rules are found, but an existing file matches the task name,
+ # assume it is a file task with no dependencies or actions.
+ def [](task_name)
+ task_name = task_name.to_s
+ if task = TASKS[task_name]
+ return task
+ end
+ if task = enhance_with_matching_rule(task_name)
+ return task
+ end
+ if File.exist?(task_name)
+ return FileTask.define_task(task_name)
+ end
+ fail "Don't know how to rake #{task_name}"
+ end
+
+ # Define a task given +args+ and an option block. If a rule with
+ # the given name already exists, the prerequisites and actions are
+ # added to the existing task.
+ def define_task(args, &block)
+ task_name, deps = resolve_args(args)
+ lookup(task_name).enhance([deps].flatten, &block)
+ end
+
+ # Define a rule for synthesizing tasks.
+ def create_rule(args, &block)
+ pattern, deps = resolve_args(args)
+ pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
+ RULES << [pattern, deps, block]
+ end
+
+
+ # Lookup a task. Return an existing task if found, otherwise
+ # create a task of the current type.
+ def lookup(task_name)
+ name = task_name.to_s
+ TASKS[name] ||= self.new(name)
+ end
+
+ # If a rule can be found that matches the task name, enhance the
+ # task with the prerequisites and actions from the rule. Set the
+ # source attribute of the task appropriately for the rule. Return
+ # the enhanced task or nil of no rule was found.
+ def enhance_with_matching_rule(task_name)
+ RULES.each do |pattern, extensions, block|
+ if pattern.match(task_name)
+ ext = extensions.first
+ deps = extensions[1..-1]
+ case ext
+ when String
+ source = task_name.sub(/\.[^.]*$/, ext)
+ when Proc
+ source = ext.call(task_name)
+ else
+ fail "Don't know how to handle rule dependent: #{ext.inspect}"
+ end
+ if File.exist?(source)
+ task = FileTask.define_task({task_name => [source]+deps}, &block)
+ task.source = source
+ return task
+ end
+ end
+ end
+ nil
+ end
+
+ private
+
+ # Resolve the arguments for a task/rule.
+ def resolve_args(args)
+ case args
+ when Hash
+ fail "Too Many Task Names: #{args.keys.join(' ')}" if args.size > 1
+ fail "No Task Name Given" if args.size < 1
+ task_name = args.keys[0]
+ deps = args[task_name]
+ deps = [deps] if (String===deps) || (Regexp===deps) || (Proc===deps)
+ else
+ task_name = args
+ deps = []
+ end
+ [task_name, deps]
+ end
+ end
+ end
+
+
+ ######################################################################
+ class FileTask < Task
+ # Is this file task needed? Yes if it doesn't exist, or if its time
+ # stamp is out of date.
+ def needed?
+ return true unless File.exist?(name)
+ prerequisites = @prerequisites.collect{ |n| n.is_a?(Proc) ? n.call(name) : n }.flatten
+ latest_prereq = prerequisites.collect{|n| Task[n].timestamp}.max
+ return false if latest_prereq.nil?
+ timestamp < latest_prereq
+ end
+
+ # Time stamp for file task.
+ def timestamp
+ return Time.at(0) unless File.exist?(name)
+ stat = File::stat(name.to_s)
+ stat.directory? ? Time.at(0) : stat.mtime
+ end
+ end
+
+ module DSL
+ # Declare a basic task.
+ def task(args, &block)
+ MiniRake::Task.define_task(args, &block)
+ end
+
+ # Declare a file task.
+ def file(args, &block)
+ MiniRake::FileTask.define_task(args, &block)
+ end
+
+ # Declare a set of files tasks to create the given directories on
+ # demand.
+ def directory(args, &block)
+ MiniRake::FileTask.define_task(args) do |t|
+ block.call(t) unless block.nil?
+ dir = args.is_a?(Hash) ? args.keys.first : args
+ (dir.split(File::SEPARATOR) + ['']).inject do |acc, part|
+ (acc + File::SEPARATOR).tap do |d|
+ Dir.mkdir(d) unless File.exists? d
+ end + part
+ end
+ end
+ end
+
+ # Declare a rule for auto-tasks.
+ def rule(args, &block)
+ MiniRake::Task.create_rule(args, &block)
+ end
+
+ # Write a message to standard out if $verbose is enabled.
+ def log(msg)
+ print " " if $trace && $verbose
+ puts msg if $verbose
+ end
+
+ # Run the system command +cmd+.
+ def sh(cmd)
+ puts cmd if $verbose
+ system(cmd) or fail "Command Failed: [#{cmd}]"
+ end
+
+ def desc(text)
+ end
+ end
+end
+
+Rake = MiniRake
+extend MiniRake::DSL
+
+
+######################################################################
+# Task Definition Functions ...
+
+######################################################################
+# Rake main application object. When invoking +rake+ from the command
+# line, a RakeApp object is created and run.
+#
+class RakeApp
+ RAKEFILES = ['rakefile', 'Rakefile']
+
+ OPTIONS = [
+ ['--dry-run', '-n', GetoptLong::NO_ARGUMENT,
+ "Do a dry run without executing actions."],
+ ['--help', '-H', GetoptLong::NO_ARGUMENT,
+ "Display this help message."],
+ ['--libdir', '-I', GetoptLong::REQUIRED_ARGUMENT,
+ "Include LIBDIR in the search path for required modules."],
+ ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
+ "Do not search parent directories for the Rakefile."],
+ ['--quiet', '-q', GetoptLong::NO_ARGUMENT,
+ "Do not log messages to standard output (default)."],
+ ['--rakefile', '-f', GetoptLong::REQUIRED_ARGUMENT,
+ "Use FILE as the rakefile."],
+ ['--require', '-r', GetoptLong::REQUIRED_ARGUMENT,
+ "Require MODULE before executing rakefile."],
+ ['--tasks', '-T', GetoptLong::NO_ARGUMENT,
+ "Display the tasks and dependencies, then exit."],
+ ['--pull-gems','-p', GetoptLong::NO_ARGUMENT,
+ "Pull all git mrbgems."],
+ ['--trace', '-t', GetoptLong::NO_ARGUMENT,
+ "Turn on invoke/execute tracing."],
+ ['--usage', '-h', GetoptLong::NO_ARGUMENT,
+ "Display usage."],
+ ['--verbose', '-v', GetoptLong::NO_ARGUMENT,
+ "Log message to standard output."],
+ ['--directory', '-C', GetoptLong::REQUIRED_ARGUMENT,
+ "Change executing directory of rakefiles."]
+ ]
+
+ # Create a RakeApp object.
+ def initialize
+ @rakefile = nil
+ @nosearch = false
+ end
+
+ # True if one of the files in RAKEFILES is in the current directory.
+ # If a match is found, it is copied into @rakefile.
+ def have_rakefile
+ RAKEFILES.each do |fn|
+ if File.exist?(fn)
+ @rakefile = fn
+ return true
+ end
+ end
+ return false
+ end
+
+ # Display the program usage line.
+ def usage
+ puts "rake [-f rakefile] {options} targets..."
+ end
+
+ # Display the rake command line help.
+ def help
+ usage
+ puts
+ puts "Options are ..."
+ puts
+ OPTIONS.sort.each do |long, short, mode, desc|
+ if mode == GetoptLong::REQUIRED_ARGUMENT
+ if desc =~ /\b([A-Z]{2,})\b/
+ long = long + "=#{$1}"
+ end
+ end
+ printf " %-20s (%s)\n", long, short
+ printf " %s\n", desc
+ end
+ end
+
+ # Display the tasks and dependencies.
+ def display_tasks
+ MiniRake::Task.tasks.each do |t|
+ puts "#{t.class} #{t.name}"
+ t.prerequisites.each { |pre| puts " #{pre}" }
+ end
+ end
+
+ # Return a list of the command line options supported by the
+ # program.
+ def command_line_options
+ OPTIONS.collect { |lst| lst[0..-2] }
+ end
+
+ # Do the option defined by +opt+ and +value+.
+ def do_option(opt, value)
+ case opt
+ when '--dry-run'
+ $dryrun = true
+ $trace = true
+ when '--help'
+ help
+ exit
+ when '--libdir'
+ $:.push(value)
+ when '--nosearch'
+ @nosearch = true
+ when '--quiet'
+ $verbose = false
+ when '--rakefile'
+ RAKEFILES.clear
+ RAKEFILES << value
+ when '--require'
+ require value
+ when '--tasks'
+ $show_tasks = true
+ when '--pull-gems'
+ $pull_gems = true
+ when '--trace'
+ $trace = true
+ when '--usage'
+ usage
+ exit
+ when '--verbose'
+ $verbose = true
+ when '--version'
+ puts "rake, version #{RAKEVERSION}"
+ exit
+ when '--directory'
+ Dir.chdir value
+ else
+ fail "Unknown option: #{opt}"
+ end
+ end
+
+ # Read and handle the command line options.
+ def handle_options
+ $verbose = false
+ $pull_gems = false
+ opts = GetoptLong.new(*command_line_options)
+ opts.each { |opt, value| do_option(opt, value) }
+ end
+
+ # Run the +rake+ application.
+ def run
+ handle_options
+ begin
+ here = Dir.pwd
+ while ! have_rakefile
+ Dir.chdir("..")
+ if Dir.pwd == here || @nosearch
+ fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
+ end
+ here = Dir.pwd
+ end
+ tasks = []
+ ARGV.each do |task_name|
+ if /^(\w+)=(.*)/.match(task_name)
+ ENV[$1] = $2
+ else
+ tasks << task_name
+ end
+ end
+ puts "(in #{Dir.pwd})"
+ $rakefile = @rakefile
+ load @rakefile
+ if $show_tasks
+ display_tasks
+ else
+ tasks.push("default") if tasks.size == 0
+ tasks.each do |task_name|
+ MiniRake::Task[task_name].invoke
+ end
+ end
+ rescue Exception => ex
+ puts "rake aborted!"
+ puts ex.message
+ if $trace
+ puts ex.backtrace.join("\n")
+ else
+ puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+ end
+ exit 1
+ end
+ end
+end
+
+if __FILE__ == $0 then
+ RakeApp.new.run
+end