diff options
Diffstat (limited to 'jni/ruby/lib/rake/ext')
| -rw-r--r-- | jni/ruby/lib/rake/ext/core.rb | 25 | ||||
| -rw-r--r-- | jni/ruby/lib/rake/ext/module.rb | 2 | ||||
| -rw-r--r-- | jni/ruby/lib/rake/ext/pathname.rb | 25 | ||||
| -rw-r--r-- | jni/ruby/lib/rake/ext/string.rb | 173 | ||||
| -rw-r--r-- | jni/ruby/lib/rake/ext/time.rb | 16 |
5 files changed, 241 insertions, 0 deletions
diff --git a/jni/ruby/lib/rake/ext/core.rb b/jni/ruby/lib/rake/ext/core.rb new file mode 100644 index 0000000..7575df1 --- /dev/null +++ b/jni/ruby/lib/rake/ext/core.rb @@ -0,0 +1,25 @@ +class Module + # Check for an existing method in the current class before extending. If + # the method already exists, then a warning is printed and the extension is + # not added. Otherwise the block is yielded and any definitions in the + # block will take effect. + # + # Usage: + # + # class String + # rake_extension("xyz") do + # def xyz + # ... + # end + # end + # end + # + def rake_extension(method) # :nodoc: + if method_defined?(method) + $stderr.puts "WARNING: Possible conflict with Rake extension: " + + "#{self}##{method} already exists" + else + yield + end + end +end diff --git a/jni/ruby/lib/rake/ext/module.rb b/jni/ruby/lib/rake/ext/module.rb new file mode 100644 index 0000000..3ee155f --- /dev/null +++ b/jni/ruby/lib/rake/ext/module.rb @@ -0,0 +1,2 @@ + +# TODO: remove in Rake 11 diff --git a/jni/ruby/lib/rake/ext/pathname.rb b/jni/ruby/lib/rake/ext/pathname.rb new file mode 100644 index 0000000..49e2cd4 --- /dev/null +++ b/jni/ruby/lib/rake/ext/pathname.rb @@ -0,0 +1,25 @@ +require 'rake/ext/core' +require 'pathname' + +class Pathname + + rake_extension("ext") do + # Return a new Pathname with <tt>String#ext</tt> applied to it. + # + # This Pathname extension comes from Rake + def ext(newext='') + Pathname.new(Rake.from_pathname(self).ext(newext)) + end + end + + rake_extension("pathmap") do + # Apply the pathmap spec to the Pathname, returning a + # new Pathname with the modified paths. (See String#pathmap for + # details.) + # + # This Pathname extension comes from Rake + def pathmap(spec=nil, &block) + Pathname.new(Rake.from_pathname(self).pathmap(spec, &block)) + end + end +end diff --git a/jni/ruby/lib/rake/ext/string.rb b/jni/ruby/lib/rake/ext/string.rb new file mode 100644 index 0000000..b47b055 --- /dev/null +++ b/jni/ruby/lib/rake/ext/string.rb @@ -0,0 +1,173 @@ +require 'rake/ext/core' + +class String + + rake_extension("ext") do + # Replace the file extension with +newext+. If there is no extension on + # the string, append the new extension to the end. If the new extension + # is not given, or is the empty string, remove any existing extension. + # + # +ext+ is a user added method for the String class. + # + # This String extension comes from Rake + def ext(newext='') + return self.dup if ['.', '..'].include? self + newext = (newext =~ /^\./) ? newext : ("." + newext) if newext != '' + self.chomp(File.extname(self)) << newext + end + end + + rake_extension("pathmap") do + # Explode a path into individual components. Used by +pathmap+. + # + # This String extension comes from Rake + def pathmap_explode + head, tail = File.split(self) + return [self] if head == self + return [tail] if head == '.' || tail == '/' + return [head, tail] if head == '/' + return head.pathmap_explode + [tail] + end + protected :pathmap_explode + + # Extract a partial path from the path. Include +n+ directories from the + # front end (left hand side) if +n+ is positive. Include |+n+| + # directories from the back end (right hand side) if +n+ is negative. + # + # This String extension comes from Rake + def pathmap_partial(n) + dirs = File.dirname(self).pathmap_explode + partial_dirs = + if n > 0 + dirs[0...n] + elsif n < 0 + dirs.reverse[0...-n].reverse + else + "." + end + File.join(partial_dirs) + end + protected :pathmap_partial + + # Perform the pathmap replacement operations on the given path. The + # patterns take the form 'pat1,rep1;pat2,rep2...'. + # + # This String extension comes from Rake + def pathmap_replace(patterns, &block) + result = self + patterns.split(';').each do |pair| + pattern, replacement = pair.split(',') + pattern = Regexp.new(pattern) + if replacement == '*' && block_given? + result = result.sub(pattern, &block) + elsif replacement + result = result.sub(pattern, replacement) + else + result = result.sub(pattern, '') + end + end + result + end + protected :pathmap_replace + + # Map the path according to the given specification. The specification + # controls the details of the mapping. The following special patterns are + # recognized: + # + # <tt>%p</tt> :: The complete path. + # <tt>%f</tt> :: The base file name of the path, with its file extension, + # but without any directories. + # <tt>%n</tt> :: The file name of the path without its file extension. + # <tt>%d</tt> :: The directory list of the path. + # <tt>%x</tt> :: The file extension of the path. An empty string if there + # is no extension. + # <tt>%X</tt> :: Everything *but* the file extension. + # <tt>%s</tt> :: The alternate file separator if defined, otherwise use # + # the standard file separator. + # <tt>%%</tt> :: A percent sign. + # + # The <tt>%d</tt> specifier can also have a numeric prefix (e.g. '%2d'). + # If the number is positive, only return (up to) +n+ directories in the + # path, starting from the left hand side. If +n+ is negative, return (up + # to) +n+ directories from the right hand side of the path. + # + # Examples: + # + # 'a/b/c/d/file.txt'.pathmap("%2d") => 'a/b' + # 'a/b/c/d/file.txt'.pathmap("%-2d") => 'c/d' + # + # Also the <tt>%d</tt>, <tt>%p</tt>, <tt>%f</tt>, <tt>%n</tt>, + # <tt>%x</tt>, and <tt>%X</tt> operators can take a pattern/replacement + # argument to perform simple string substitutions on a particular part of + # the path. The pattern and replacement are separated by a comma and are + # enclosed by curly braces. The replacement spec comes after the % + # character but before the operator letter. (e.g. "%{old,new}d"). + # Multiple replacement specs should be separated by semi-colons (e.g. + # "%{old,new;src,bin}d"). + # + # Regular expressions may be used for the pattern, and back refs may be + # used in the replacement text. Curly braces, commas and semi-colons are + # excluded from both the pattern and replacement text (let's keep parsing + # reasonable). + # + # For example: + # + # "src/org/onestepback/proj/A.java".pathmap("%{^src,class}X.class") + # + # returns: + # + # "class/org/onestepback/proj/A.class" + # + # If the replacement text is '*', then a block may be provided to perform + # some arbitrary calculation for the replacement. + # + # For example: + # + # "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext| + # ext.downcase + # } + # + # Returns: + # + # "/path/to/file.txt" + # + # This String extension comes from Rake + 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 + +end diff --git a/jni/ruby/lib/rake/ext/time.rb b/jni/ruby/lib/rake/ext/time.rb new file mode 100644 index 0000000..d3b8cf9 --- /dev/null +++ b/jni/ruby/lib/rake/ext/time.rb @@ -0,0 +1,16 @@ +#-- +# Extensions to time to allow comparisons with early and late time classes. + +require 'rake/early_time' +require 'rake/late_time' + +class Time # :nodoc: all + alias rake_original_time_compare :<=> + def <=>(other) + if Rake::EarlyTime === other || Rake::LateTime === other + - other.<=>(self) + else + rake_original_time_compare(other) + end + end +end |