Class: Pathname

Inherits:
Object show all
Defined in:
lib/standard/facets/pathname/glob.rb,
lib/standard/facets/pathname/home.rb,
lib/standard/facets/pathname/null.rb,
lib/standard/facets/pathname/root.rb,
lib/standard/facets/pathname/safe.rb,
lib/standard/facets/pathname/work.rb,
lib/standard/facets/pathname/chdir.rb,
lib/standard/facets/pathname/empty.rb,
lib/standard/facets/pathname/visit.rb,
lib/standard/facets/pathname/exists.rb,
lib/standard/facets/pathname/op_div.rb,
lib/standard/facets/pathname/to_str.rb,
lib/standard/facets/pathname/op_fetch.rb,
lib/standard/facets/pathname/readline.rb,
lib/standard/facets/pathname/rootname.rb,
lib/standard/facets/pathname/uptodate.rb,
lib/standard/facets/pathname/outofdate.rb,
lib/standard/facets/pathname/split_root.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

./(path) ⇒ Object

Start a path. Another alias for #new.

Pathname / 'usr'



7
8
9
 
# File 'lib/standard/facets/pathname/op_div.rb', line 7

def self./(path)
  new(path)
end

.[](path) ⇒ Object

Alternate to Pathname#new.

Pathname['/usr/share']

Returns [Pathname]



9
10
11
 
# File 'lib/standard/facets/pathname/op_fetch.rb', line 9

def self.[](path)
  new(path)
end

.home ⇒ Object

Home constant for building paths from root directory onward.

TODO: Pathname#home needs to be more robust.

Returns [Pathname]



8
9
10
 
# File 'lib/standard/facets/pathname/home.rb', line 8

def self.home
  Pathname.new('~')
end

.null ⇒ Object

Platform dependent null device.

CREDIT: Daniel Burger



7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/standard/facets/pathname/null.rb', line 7

def self.null
  case RUBY_PLATFORM
  when /mswin/i
    'NUL'
  when /amiga/i
    'NIL:'
  when /openvms/i
    'NL:'
  else
    '/dev/null'
  end
end

.root ⇒ Object

Root constant for building paths from root directory onward.

Returns [Pathname]



6
7
8
 
# File 'lib/standard/facets/pathname/root.rb', line 6

def self.root
  Pathname.new('/')
end

.work ⇒ Object

Work constant for building paths from root directory onward.

Returns [Pathname]



6
7
8
 
# File 'lib/standard/facets/pathname/work.rb', line 6

def self.work
  Pathname.new('.')
end

Instance Method Details

#chdir(&block) ⇒ Object

Change current working directory of the process to the given path

See Dir.chdir

CREDIT: Ryan Duryea



10
11
12
 
# File 'lib/standard/facets/pathname/chdir.rb', line 10

def chdir(&block)
  Dir.chdir(self, &block)
end

#empty? ⇒ Boolean

Is a directory path empty?

Returns [Boolean]

Returns:

  • (Boolean) 


6
7
8
 
# File 'lib/standard/facets/pathname/empty.rb', line 6

def empty?
  Dir.glob(::File.join(to_s, '*')).empty?
end

#glob(match, *opts) ⇒ Object

Glob pathnames.



4
5
6
7
 
# File 'lib/standard/facets/pathname/glob.rb', line 4

def glob(match, *opts)
  flags = glob_flags(opts)
  Dir.glob(::File.join(self.to_s, match), flags).collect{ |m| self.class.new(m) }
end

#glob_first(match, *opts) ⇒ Object

Return the first glob match.

DEPRECATE: While slightly faster then glob().first, not really worth it unless this can be rewritten to shortcut on first match (using fnmatch?). In wich case, is there a better name for this method?



14
15
16
17
18
 
# File 'lib/standard/facets/pathname/glob.rb', line 14

def glob_first(match, *opts)
  flags = glob_flags(opts)
  file = ::Dir.glob(::File.join(self.to_s, match), flags).first
  file ? self.class.new(file) : nil
end

#glob_flags(opts) ⇒ Object (private) 



45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/standard/facets/pathname/glob.rb', line 45

def glob_flags(opts)
  flags = 0
  opts.each do |opt|
    case opt when Symbol, String
      flags += ::File.const_get("FNM_#{opt}".upcase)
    else
      flags += opt
    end
  end
  flags
end

#glob_relative(match, *opts) ⇒ Object

Return globbed matches with pathnames relative to the current pathname.



21
22
23
24
25
26
 
# File 'lib/standard/facets/pathname/glob.rb', line 21

def glob_relative(match, *opts)
  flags = glob_flags(opts)
  files = Dir.glob(::File.join(self.to_s, match), flags)
  files = files.map{ |f| f.sub(self.to_s.chomp('/') + '/', '') }
  files.collect{ |m| self.class.new(m) }
end

#include?(pattern, *opts) ⇒ Boolean

Does a directory contain a matching entry? Or if the pathname is a file, same as #fnmatch.

TODO: Move to own file? Better name?

Returns [Pathname]

Returns:

  • (Boolean) 


35
36
37
38
39
40
41
 
# File 'lib/standard/facets/pathname/glob.rb', line 35

def include?(pattern,*opts)
  if directory?
    glob_first(pattern,*opts)
  else
    fnmatch(pattern,*opts)
  end
end

#outofdate?(*sources) ⇒ Boolean

Is a path out of date relative a set of source files.

Returns [Boolean]

Returns:

  • (Boolean) 


9
10
11
 
# File 'lib/standard/facets/pathname/outofdate.rb', line 9

def outofdate?(*sources)
  ::FileUtils.outofdate?(to_s, sources.flatten)
end

#readline(*args) ⇒ Object

Reads the first line of the file

Captures the best practice from this post at stack overflow: stackoverflow.com/questions/1490138/reading-the-first-line-of-a-file-in-ruby

Credit: Ryan Duryea



8
9
10
 
# File 'lib/standard/facets/pathname/readline.rb', line 8

def readline(*args)
  open { |f| f.readline(*args) }
end

#rootname ⇒ Object 



6
7
8
 
# File 'lib/standard/facets/pathname/rootname.rb', line 6

def rootname
  self.class.new(File.rootname(to_s))
end

#safe? ⇒ Boolean

Is a path reasonably safe?

Do not mistake this for a perfect solution!

Returns [Boolean]

Returns:

  • (Boolean) 


11
12
13
 
# File 'lib/standard/facets/pathname/safe.rb', line 11

def safe?
  FileTest.safe?(to_s)
end

#split_root ⇒ Object 



4
5
6
7
 
# File 'lib/standard/facets/pathname/split_root.rb', line 4

def split_root
  head, tail = *::File.split_root(to_s)
  [self.class.new(head), self.class.new(tail)]
end

#uptodate?(*sources) ⇒ Boolean

Is a path up to date relative to a set of source files?

Returns [Boolean]

Returns:

  • (Boolean) 


7
8
9
 
# File 'lib/standard/facets/pathname/uptodate.rb', line 7

def uptodate?(*sources)
  ::FileUtils.uptodate?(to_s, sources.flatten)
end

#visit(options = {:all => false, :hidden => false}) ⇒ Object

Recursively visit a directory located by its path, yielding each resource as its full matching pathname object. If called on a file, yield the file.

call-seq:

visit => yield each file
visit(all: true) => yield visited directories as well
visit(hidden: true) => yield hidden files and directories as well

Examples

# Locate any file but *.haml within app/**/*
Pathname.new("app").visit do |f|
  next unless f.to_s =~ /\.haml$/
  f
end

TODO: Use #map instead of #each?

CREDIT: Jean-Denis Vauguet



23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/standard/facets/pathname/visit.rb', line 23

def visit(options = {:all => false, :hidden => false})
  if self.directory?
    children.each do |entry|
      next if entry.basename.to_s[0] == "." && !options[:hidden]
      yield(entry) unless entry.directory? && !options[:all]
      ##entry.visit(:all => options[:all]) { |sub_entry| yield sub_entry } if entry.directory?
      entry.visit(:all => options[:all], :hidden => options[:hidden]) do |sub_entry|
        yield(sub_entry)
      end if entry.directory?
    end
  else
    yield self
  end
end