| # Frozen-string-literal: true |
| # Copyright: 2015-2016 Jordon Bedwell - MIT License |
| # Encoding: utf-8 |
| |
| require "pathutil/helpers" |
| require "forwardable/extended" |
| require "find" |
| |
| class Pathutil |
| attr_writer :encoding |
| extend Forwardable::Extended |
| extend Helpers |
| |
| # -- |
| # @note A lot of this class can be compatible with Pathname. |
| # Initialize a new instance. |
| # @return Pathutil |
| # -- |
| def initialize(path) |
| return @path = path if path.is_a?(String) |
| return @path = path.to_path if path.respond_to?(:to_path) |
| return @path = path.to_s |
| end |
| |
| # -- |
| # Make a path relative. |
| # -- |
| |
| def relative |
| return self if relative? |
| self.class.new(strip_windows_drive.gsub( |
| %r!\A(\\+|/+)!, "" |
| )) |
| end |
| |
| # -- |
| # Make a path absolute |
| # -- |
| |
| def absolute |
| return self if absolute? |
| self.class.new("/").join( |
| @path |
| ) |
| end |
| |
| # -- |
| # @see Pathname#cleanpath. |
| # @note This is a wholesale rip and cleanup of Pathname#cleanpath |
| # @return Pathutil |
| # -- |
| def cleanpath(symlink = false) |
| symlink ? conservative_cleanpath : aggressive_cleanpath |
| end |
| |
| # -- |
| # @yield Pathutil |
| # @note It will return all results that it finds across all ascending paths. |
| # @example Pathutil.new("~/").expand_path.search_backwards(".bashrc") => [#<Pathutil:/home/user/.bashrc>] |
| # Search backwards for a file (like Rakefile, _config.yml, opts.yml). |
| # @return Enum |
| # -- |
| def search_backwards(file, backwards: Float::INFINITY) |
| ary = [] |
| |
| ascend.with_index(1).each do |path, index| |
| if index > backwards |
| break |
| |
| else |
| Dir.chdir path do |
| if block_given? |
| file = self.class.new(file) |
| if yield(file) |
| ary.push( |
| file |
| ) |
| end |
| |
| elsif File.exist?(file) |
| ary.push(self.class.new( |
| path.join(file) |
| )) |
| end |
| end |
| end |
| end |
| |
| ary |
| end |
| |
| # -- |
| # Read the file as a YAML file turning it into an object. |
| # @see self.class.load_yaml as this a direct alias of that method. |
| # @return Hash |
| # -- |
| def read_yaml(throw_missing: false, **kwd) |
| self.class.load_yaml( |
| read, **kwd |
| ) |
| |
| rescue Errno::ENOENT |
| throw_missing ? raise : ( |
| return {} |
| ) |
| end |
| |
| # -- |
| # Read the file as a JSON file turning it into an object. |
| # @see self.class.read_json as this is a direct alias of that method. |
| # @return Hash |
| # -- |
| def read_json(throw_missing: false) |
| JSON.parse( |
| read |
| ) |
| |
| rescue Errno::ENOENT |
| throw_missing ? raise : ( |
| return {} |
| ) |
| end |
| |
| # -- |
| # @note The blank part is intentionally left there so that you can rejoin. |
| # Splits the path into all parts so that you can do step by step comparisons |
| # @example Pathutil.new("/my/path").split_path # => ["", "my", "path"] |
| # @return Array<String> |
| # -- |
| def split_path |
| @path.split( |
| %r!\\+|/+! |
| ) |
| end |
| |
| # -- |
| # @see `String#==` for more details. |
| # A stricter version of `==` that also makes sure the object matches. |
| # @return true|false |
| # -- |
| def ===(other) |
| other.is_a?(self.class) && @path == other |
| end |
| |
| # -- |
| # @example Pathutil.new("/hello") >= Pathutil.new("/") # => true |
| # @example Pathutil.new("/hello") >= Pathutil.new("/hello") # => true |
| # Checks to see if a path falls within a path and deeper or is the other. |
| # @return true|false |
| # -- |
| def >=(other) |
| mine, other = expanded_paths(other) |
| return true if other == mine |
| mine.in_path?(other) |
| end |
| |
| # -- |
| # @example Pathutil.new("/hello/world") > Pathutil.new("/hello") # => true |
| # Strictly checks to see if a path is deeper but within the path of the other. |
| # @return true|false |
| # -- |
| def >(other) |
| mine, other = expanded_paths(other) |
| return false if other == mine |
| mine.in_path?(other) |
| end |
| |
| # -- |
| # @example Pathutil.new("/") < Pathutil.new("/hello") # => true |
| # Strictly check to see if a path is behind other path but within it. |
| # @return true|false |
| # -- |
| def <(other) |
| mine, other = expanded_paths(other) |
| return false if other == mine |
| other.in_path?(mine) |
| end |
| |
| # -- |
| # Check to see if a path is behind the other path but within it. |
| # @example Pathutil.new("/hello") < Pathutil.new("/hello") # => true |
| # @example Pathutil.new("/") < Pathutil.new("/hello") # => true |
| # @return true|false |
| # -- |
| def <=(other) |
| mine, other = expanded_paths(other) |
| return true if other == mine |
| other.in_path?(mine) |
| end |
| |
| # -- |
| # @note "./" is considered relative. |
| # Check to see if the path is absolute, as in: starts with "/" |
| # @return true|false |
| # -- |
| def absolute? |
| return !!( |
| @path =~ %r!\A(?:[A-Za-z]:)?(?:\\+|/+)! |
| ) |
| end |
| |
| # -- |
| # @yield Pathutil |
| # Break apart the path and yield each with the previous parts. |
| # @example Pathutil.new("/hello/world").ascend.to_a # => ["/", "/hello", "/hello/world"] |
| # @example Pathutil.new("/hello/world").ascend { |path| $stdout.puts path } |
| # @return Enum |
| # -- |
| def ascend |
| unless block_given? |
| return to_enum( |
| __method__ |
| ) |
| end |
| |
| yield( |
| path = self |
| ) |
| |
| while (new_path = path.dirname) |
| if path == new_path || new_path == "." |
| break |
| else |
| path = new_path |
| yield new_path |
| end |
| end |
| |
| nil |
| end |
| |
| # -- |
| # @yield Pathutil |
| # Break apart the path in reverse order and descend into the path. |
| # @example Pathutil.new("/hello/world").descend.to_a # => ["/hello/world", "/hello", "/"] |
| # @example Pathutil.new("/hello/world").descend { |path| $stdout.puts path } |
| # @return Enum |
| # -- |
| def descend |
| unless block_given? |
| return to_enum( |
| __method__ |
| ) |
| end |
| |
| ascend.to_a.reverse_each do |val| |
| yield val |
| end |
| |
| nil |
| end |
| |
| # -- |
| # @yield Pathutil |
| # @example Pathutil.new("/hello/world").each_line { |line| $stdout.puts line } |
| # Wraps `readlines` and allows you to yield on the result. |
| # @return Enum |
| # -- |
| def each_line |
| return to_enum(__method__) unless block_given? |
| readlines.each do |line| |
| yield line |
| end |
| |
| nil |
| end |
| |
| # -- |
| # @example Pathutil.new("/hello").fnmatch?("/hello") # => true |
| # Unlike traditional `fnmatch`, with this one `Regexp` is allowed. |
| # @example Pathutil.new("/hello").fnmatch?(/h/) # => true |
| # @see `File#fnmatch` for more information. |
| # @return true|false |
| # -- |
| def fnmatch?(matcher) |
| matcher.is_a?(Regexp) ? !!(self =~ matcher) : \ |
| File.fnmatch(matcher, self) |
| end |
| |
| # -- |
| # Allows you to quickly determine if the file is the root folder. |
| # @return true|false |
| # -- |
| def root? |
| !!(self =~ %r!\A(?:[A-Za-z]:)?(?:\\+|/+)\z!) |
| end |
| |
| # -- |
| # Allows you to check if the current path is in the path you want. |
| # @return true|false |
| # -- |
| def in_path?(path) |
| path = self.class.new(path).expand_path.split_path |
| mine = (symlink?? expand_path.realpath : expand_path).split_path |
| path.each_with_index { |part, index| return false if mine[index] != part } |
| true |
| end |
| |
| # -- |
| |
| def inspect |
| "#<#{self.class}:#{@path}>" |
| end |
| |
| # -- |
| # @return Array<Pathutil> |
| # Grab all of the children from the current directory, including hidden. |
| # @yield Pathutil |
| # -- |
| def children |
| ary = [] |
| |
| Dir.foreach(@path) do |path| |
| if path == "." || path == ".." |
| next |
| else |
| path = self.class.new(File.join(@path, path)) |
| yield path if block_given? |
| ary.push( |
| path |
| ) |
| end |
| end |
| |
| ary |
| end |
| |
| # -- |
| # @yield Pathutil |
| # Allows you to glob however you wish to glob in the current `Pathutil` |
| # @see `File::Constants` for a list of flags. |
| # @return Enum |
| # -- |
| def glob(pattern, flags = 0) |
| unless block_given? |
| return to_enum( |
| __method__, pattern, flags |
| ) |
| end |
| |
| chdir do |
| Dir.glob(pattern, flags).each do |file| |
| yield self.class.new( |
| File.join(@path, file) |
| ) |
| end |
| end |
| |
| nil |
| end |
| |
| # -- |
| # @yield &block |
| # Move to the current directory temporarily (or for good) and do work son. |
| # @note you do not need to ship a block at all. |
| # @return nil |
| # -- |
| def chdir |
| if !block_given? |
| Dir.chdir( |
| @path |
| ) |
| |
| else |
| Dir.chdir @path do |
| yield |
| end |
| end |
| end |
| |
| # -- |
| # @yield Pathutil |
| # Find all files without care and yield the given block. |
| # @return Enum |
| # -- |
| def find |
| return to_enum(__method__) unless block_given? |
| Find.find @path do |val| |
| yield self.class.new(val) |
| end |
| end |
| |
| # -- |
| # @yield Pathutil |
| # Splits the path returning each part (filename) back to you. |
| # @return Enum |
| # -- |
| def each_filename |
| return to_enum(__method__) unless block_given? |
| @path.split(File::SEPARATOR).delete_if(&:empty?).each do |file| |
| yield file |
| end |
| end |
| |
| # -- |
| # Get the parent of the current path. |
| # @note This will simply return self if "/". |
| # @return Pathutil |
| # -- |
| def parent |
| return self if @path == "/" |
| self.class.new(absolute?? File.dirname(@path) : File.join( |
| @path, ".." |
| )) |
| end |
| |
| # -- |
| # @yield Pathutil |
| # Split the file into its dirname and basename, so you can do stuff. |
| # @return nil |
| # -- |
| def split |
| File.split(@path).collect! do |path| |
| self.class.new(path) |
| end |
| end |
| |
| # -- |
| # @note Your extension should start with "." |
| # Replace a files extension with your given extension. |
| # @return Pathutil |
| # -- |
| def sub_ext(ext) |
| self.class.new(@path.chomp(File.extname(@path)) + ext) |
| end |
| |
| # -- |
| # A less complex version of `relative_path_from` that simply uses a |
| # `Regexp` and returns the full path if it cannot be determined. |
| # @return Pathutil |
| # -- |
| def relative_path_from(from) |
| from = self.class.new(from).expand_path.gsub(%r!/$!, "") |
| self.class.new(expand_path.gsub(%r!^#{ |
| from.regexp_escape |
| }/!, "")) |
| end |
| |
| # -- |
| # Expands the path and left joins the root to the path. |
| # @return Pathutil |
| # -- |
| def enforce_root(root) |
| return self if !relative? && in_path?(root) |
| self.class.new(root).join( |
| self |
| ) |
| end |
| |
| # -- |
| # Copy a directory, allowing symlinks if the link falls inside of the root. |
| # This is indented for people who wish some safety to their copies. |
| # @note Ignore is ignored on safe_copy file because it's explicit. |
| # @return nil |
| # -- |
| def safe_copy(to, root: nil, ignore: []) |
| raise ArgumentError, "must give a root" unless root |
| root = self.class.new(root) |
| to = self.class.new(to) |
| |
| if directory? |
| safe_copy_directory(to, { |
| :root => root, :ignore => ignore |
| }) |
| |
| else |
| safe_copy_file(to, { |
| :root => root |
| }) |
| end |
| end |
| |
| # -- |
| # @see `self.class.normalize` as this is an alias. |
| # -- |
| def normalize |
| return @normalize ||= begin |
| self.class.normalize |
| end |
| end |
| |
| # -- |
| # @see `self.class.encoding` as this is an alias. |
| # -- |
| def encoding |
| return @encoding ||= begin |
| self.class.encoding |
| end |
| end |
| |
| # -- |
| # @note You can set the default encodings via the class. |
| # Read took two steroid shots: it can normalize your string, and encode. |
| # @return String |
| # -- |
| def read(*args, **kwd) |
| kwd[:encoding] ||= encoding |
| |
| if normalize[:read] |
| File.read(self, *args, kwd).encode({ |
| :universal_newline => true |
| }) |
| |
| else |
| File.read( |
| self, *args, kwd |
| ) |
| end |
| end |
| |
| # -- |
| # @note You can set the default encodings via the class. |
| # Binread took two steroid shots: it can normalize your string, and encode. |
| # @return String |
| # -- |
| def binread(*args, **kwd) |
| kwd[:encoding] ||= encoding |
| |
| if normalize[:read] |
| File.binread(self, *args, kwd).encode({ |
| :universal_newline => true |
| }) |
| |
| else |
| File.read( |
| self, *args, kwd |
| ) |
| end |
| end |
| |
| # -- |
| # @note You can set the default encodings via the class. |
| # Readlines took two steroid shots: it can normalize your string, and encode. |
| # @return Array<String> |
| # -- |
| def readlines(*args, **kwd) |
| kwd[:encoding] ||= encoding |
| |
| if normalize[:read] |
| File.readlines(self, *args, kwd).encode({ |
| :universal_newline => true |
| }) |
| |
| else |
| File.readlines( |
| self, *args, kwd |
| ) |
| end |
| end |
| |
| # -- |
| # @note You can set the default encodings via the class. |
| # Write took two steroid shots: it can normalize your string, and encode. |
| # @return Fixnum<Bytes> |
| # -- |
| def write(data, *args, **kwd) |
| kwd[:encoding] ||= encoding |
| |
| if normalize[:write] |
| File.write(self, data.encode( |
| :crlf_newline => true |
| ), *args, kwd) |
| |
| else |
| File.write( |
| self, data, *args, kwd |
| ) |
| end |
| end |
| |
| # -- |
| # @note You can set the default encodings via the class. |
| # Binwrite took two steroid shots: it can normalize your string, and encode. |
| # @return Fixnum<Bytes> |
| # -- |
| def binwrite(data, *args, **kwd) |
| kwd[:encoding] ||= encoding |
| |
| if normalize[:write] |
| File.binwrite(self, data.encode( |
| :crlf_newline => true |
| ), *args, kwd) |
| |
| else |
| File.binwrite( |
| self, data, *args, kwd |
| ) |
| end |
| end |
| |
| # -- |
| |
| def to_regexp(guard: true) |
| Regexp.new((guard ? "\\A" : "") + Regexp.escape( |
| self |
| )) |
| end |
| |
| # -- |
| # Strips the windows drive from the path. |
| # -- |
| |
| def strip_windows_drive(path = @path) |
| self.class.new(path.gsub( |
| %r!\A[A-Za-z]:(?:\\+|/+)!, "" |
| )) |
| end |
| |
| # -- |
| # rubocop:disable Metrics/AbcSize |
| # rubocop:disable Metrics/CyclomaticComplexity |
| # rubocop:disable Metrics/PerceivedComplexity |
| # -- |
| |
| def aggressive_cleanpath |
| return self.class.new("/") if root? |
| |
| _out = split_path.each_with_object([]) do |part, out| |
| next if part == "." || (part == ".." && out.last == "") |
| if part == ".." && out.last && out.last != ".." |
| out.pop |
| |
| else |
| out.push( |
| part |
| ) |
| end |
| end |
| |
| # -- |
| |
| return self.class.new("/") if _out == [""].freeze |
| return self.class.new(".") if _out.empty? && (end_with?(".") || relative?) |
| self.class.new(_out.join("/")) |
| end |
| |
| # -- |
| |
| def conservative_cleanpath |
| _out = split_path.each_with_object([]) do |part, out| |
| next if part == "." || (part == ".." && out.last == "") |
| out.push( |
| part |
| ) |
| end |
| |
| # -- |
| |
| if !_out.empty? && basename == "." && _out.last != "" && _out.last != ".." |
| _out << "." |
| end |
| |
| # -- |
| |
| return self.class.new("/") if _out == [""].freeze |
| return self.class.new(".") if _out.empty? && (end_with?(".") || relative?) |
| return self.class.new(_out.join("/")).join("") if @path =~ %r!/\z! \ |
| && _out.last != "." && _out.last != ".." |
| self.class.new(_out.join("/")) |
| end |
| |
| # -- |
| # rubocop:enable Metrics/AbcSize |
| # rubocop:enable Metrics/CyclomaticComplexity |
| # rubocop:enable Metrics/PerceivedComplexity |
| # Expand the paths and return. |
| # -- |
| private |
| def expanded_paths(path) |
| return expand_path, self.class.new(path).expand_path |
| end |
| |
| # -- |
| # Safely copy a file. |
| # -- |
| private |
| def safe_copy_file(to, root: nil) |
| raise Errno::EPERM, "#{self} not in #{root}" unless in_path?(root) |
| FileUtils.cp(self, to, { |
| :preserve => true |
| }) |
| end |
| |
| # -- |
| # Safely copy a directory and it's sub-files. |
| # -- |
| private |
| def safe_copy_directory(to, root: nil, ignore: []) |
| ignore = [ignore].flatten.uniq |
| |
| if !in_path?(root) |
| raise Errno::EPERM, "#{self} not in #{ |
| root |
| }" |
| |
| else |
| to.mkdir_p unless to.exist? |
| children do |file| |
| unless ignore.any? { |path| file.in_path?(path) } |
| if !file.in_path?(root) |
| raise Errno::EPERM, "#{file} not in #{ |
| root |
| }" |
| |
| elsif file.file? |
| FileUtils.cp(file, to, { |
| :preserve => true |
| }) |
| |
| else |
| path = file.realpath |
| path.safe_copy(to.join(file.basename), { |
| :root => root, :ignore => ignore |
| }) |
| end |
| end |
| end |
| end |
| end |
| |
| class << self |
| attr_writer :encoding |
| |
| # -- |
| # @note We do nothing special here. |
| # Get the current directory that Ruby knows about. |
| # @return Pathutil |
| # -- |
| def pwd |
| new( |
| Dir.pwd |
| ) |
| end |
| |
| alias gcwd pwd |
| alias cwd pwd |
| |
| # -- |
| # @note you are encouraged to override this if you need to. |
| # Aliases the default system encoding to us so that we can do most read |
| # and write operations with that encoding, instead of being crazy. |
| # -- |
| def encoding |
| return @encoding ||= begin |
| Encoding.default_external |
| end |
| end |
| |
| # -- |
| # Normalize CRLF -> LF on Windows reads, to ease your troubles. |
| # Normalize LF -> CLRF on Windows write, to ease your troubles. |
| # -- |
| def normalize |
| return @normalize ||= { |
| :read => Gem.win_platform?, |
| :write => Gem.win_platform? |
| } |
| end |
| |
| # -- |
| # Make a temporary directory. |
| # @note if you adruptly exit it will not remove the dir. |
| # @note this directory is removed on exit. |
| # @return Pathutil |
| # -- |
| def tmpdir(*args) |
| rtn = new(make_tmpname(*args)).tap(&:mkdir) |
| ObjectSpace.define_finalizer(rtn, proc do |
| rtn.rm_rf |
| end) |
| |
| rtn |
| end |
| |
| # -- |
| # Make a temporary file. |
| # @note if you adruptly exit it will not remove the dir. |
| # @note this file is removed on exit. |
| # @return Pathutil |
| # -- |
| def tmpfile(*args) |
| rtn = new(make_tmpname(*args)).tap(&:touch) |
| ObjectSpace.define_finalizer(rtn, proc do |
| rtn.rm_rf |
| end) |
| |
| rtn |
| end |
| end |
| |
| # -- |
| |
| rb_delegate :gcwd, :to => :"self.class" |
| rb_delegate :pwd, :to => :"self.class" |
| |
| # -- |
| |
| rb_delegate :sub, :to => :@path, :wrap => true |
| rb_delegate :chomp, :to => :@path, :wrap => true |
| rb_delegate :gsub, :to => :@path, :wrap => true |
| rb_delegate :=~, :to => :@path |
| rb_delegate :==, :to => :@path |
| rb_delegate :to_s, :to => :@path |
| rb_delegate :freeze, :to => :@path |
| rb_delegate :end_with?, :to => :@path |
| rb_delegate :start_with?, :to => :@path |
| rb_delegate :frozen?, :to => :@path |
| rb_delegate :to_str, :to => :@path |
| rb_delegate :"!~", :to => :@path |
| rb_delegate :<=>, :to => :@path |
| |
| # -- |
| |
| rb_delegate :chmod, :to => :File, :args => { :after => :@path } |
| rb_delegate :lchown, :to => :File, :args => { :after => :@path } |
| rb_delegate :lchmod, :to => :File, :args => { :after => :@path } |
| rb_delegate :chown, :to => :File, :args => { :after => :@path } |
| rb_delegate :basename, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :dirname, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :readlink, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :expand_path, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :realdirpath, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :realpath, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :rename, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :join, :to => :File, :args => :@path, :wrap => true |
| rb_delegate :size, :to => :File, :args => :@path |
| rb_delegate :link, :to => :File, :args => :@path |
| rb_delegate :atime, :to => :File, :args => :@path |
| rb_delegate :ctime, :to => :File, :args => :@path |
| rb_delegate :lstat, :to => :File, :args => :@path |
| rb_delegate :utime, :to => :File, :args => :@path |
| rb_delegate :sysopen, :to => :File, :args => :@path |
| rb_delegate :birthtime, :to => :File, :args => :@path |
| rb_delegate :mountpoint?, :to => :File, :args => :@path |
| rb_delegate :truncate, :to => :File, :args => :@path |
| rb_delegate :symlink, :to => :File, :args => :@path |
| rb_delegate :extname, :to => :File, :args => :@path |
| rb_delegate :zero?, :to => :File, :args => :@path |
| rb_delegate :ftype, :to => :File, :args => :@path |
| rb_delegate :mtime, :to => :File, :args => :@path |
| rb_delegate :open, :to => :File, :args => :@path |
| rb_delegate :stat, :to => :File, :args => :@path |
| |
| # -- |
| |
| rb_delegate :pipe?, :to => :FileTest, :args => :@path |
| rb_delegate :file?, :to => :FileTest, :args => :@path |
| rb_delegate :owned?, :to => :FileTest, :args => :@path |
| rb_delegate :setgid?, :to => :FileTest, :args => :@path |
| rb_delegate :socket?, :to => :FileTest, :args => :@path |
| rb_delegate :readable?, :to => :FileTest, :args => :@path |
| rb_delegate :blockdev?, :to => :FileTest, :args => :@path |
| rb_delegate :directory?, :to => :FileTest, :args => :@path |
| rb_delegate :readable_real?, :to => :FileTest, :args => :@path |
| rb_delegate :world_readable?, :to => :FileTest, :args => :@path |
| rb_delegate :executable_real?, :to => :FileTest, :args => :@path |
| rb_delegate :world_writable?, :to => :FileTest, :args => :@path |
| rb_delegate :writable_real?, :to => :FileTest, :args => :@path |
| rb_delegate :executable?, :to => :FileTest, :args => :@path |
| rb_delegate :writable?, :to => :FileTest, :args => :@path |
| rb_delegate :grpowned?, :to => :FileTest, :args => :@path |
| rb_delegate :chardev?, :to => :FileTest, :args => :@path |
| rb_delegate :symlink?, :to => :FileTest, :args => :@path |
| rb_delegate :sticky?, :to => :FileTest, :args => :@path |
| rb_delegate :setuid?, :to => :FileTest, :args => :@path |
| rb_delegate :exist?, :to => :FileTest, :args => :@path |
| rb_delegate :size?, :to => :FileTest, :args => :@path |
| |
| # -- |
| |
| rb_delegate :rm_rf, :to => :FileUtils, :args => :@path |
| rb_delegate :rm_r, :to => :FileUtils, :args => :@path |
| rb_delegate :rm_f, :to => :FileUtils, :args => :@path |
| rb_delegate :rm, :to => :FileUtils, :args => :@path |
| rb_delegate :cp_r, :to => :FileUtils, :args => :@path |
| rb_delegate :touch, :to => :FileUtils, :args => :@path |
| rb_delegate :mkdir_p, :to => :FileUtils, :args => :@path |
| rb_delegate :mkpath, :to => :FileUtils, :args => :@path |
| rb_delegate :cp, :to => :FileUtils, :args => :@path |
| |
| # -- |
| |
| rb_delegate :each_child, :to => :children |
| rb_delegate :each_entry, :to => :children |
| rb_delegate :to_a, :to => :children |
| |
| # -- |
| |
| rb_delegate :opendir, :to => :Dir, :alias_of => :open |
| rb_delegate :relative?, :to => :self, :alias_of => :absolute?, :bool => :reverse |
| rb_delegate :regexp_escape, :to => :Regexp, :args => :@path, :alias_of => :escape |
| rb_delegate :shellescape, :to => :Shellwords, :args => :@path |
| rb_delegate :mkdir, :to => :Dir, :args => :@path |
| |
| # -- |
| |
| alias + join |
| alias delete rm |
| alias rmtree rm_r |
| alias to_path to_s |
| alias last basename |
| alias entries children |
| alias make_symlink symlink |
| alias cleanpath_conservative conservative_cleanpath |
| alias cleanpath_aggressive aggressive_cleanpath |
| alias prepend enforce_root |
| alias fnmatch fnmatch? |
| alias make_link link |
| alias first dirname |
| alias rmdir rm_r |
| alias unlink rm |
| alias / join |
| end |
