fs 0.1.0 → 0.1.1

data/README.mdown

@@ -55,7 +55,6 @@ Here is my mind … here is my mind …
 - remove! to force something
 - maybe makedir! to mkdir -p
 - use Find#find in FS#find ;)
-- some kind of #tree output
 - file type
 - exist?
 - list_dirs

data/lib/fs.rb

@@ -2,6 +2,8 @@ $LOAD_PATH.unshift(File.dirname(__FILE__)) unless $LOAD_PATH.include?(File.dirna
 
 require 'fileutils'
 require 'etc'
+require 'tmpdir'
+
 require 'fs/base'
 require 'fs/alias'
 

data/lib/fs/alias.rb

@@ -7,11 +7,14 @@ module FS
       :rmdir   => :removedir,
       :rm_r    => :removedirs,
       :cd      => :changedir,
+      :pwd     => :currentdir,
       :mv      => :move,
       :cp      => :copy,
       :rm      => :remove,
       :cat     => :read,
       :ln      => :link,
+      :dir?    => :directory?,
+      :expand  => :expand_path,
     }
     
     def self.included(base)

data/lib/fs/base.rb

@@ -111,6 +111,112 @@ module FS
     def currentdir
       Dir.pwd
     end
+    
+    # tmpdir / Dir.tmpdir
+    def tempdir
+      Dir.tmpdir
+    end
+    
+    # TODO: use separate options for prefix, suffix and target_dir
+    # tmpdir / Dir.mktmpdir
+    def maketempdir(prefix_suffix=nil, parent_dir=nil)
+      Dir.mktmpdir(prefix_suffix, parent_dir)
+    end
+
+    # uses the methods of the tmpdir library to touch a new file in tempdir
+    def maketempfile(prefix_suffix=nil, parent_dir=nil)
+      Dir::Tmpname.create(prefix_suffix || "f", parent_dir || Dir.tmpdir) {|n| FileUtils.touch(n)}
+    end
+
+    # same as the `tree` shell command
+    def tree(dir='.')
+      output = []
+      visit_tree(output, '.', '', '', '', dir)
+      output.join("\n")
+    end
+
+    # File.exist?
+    def exist?(path)
+      File.exist?(path)
+    end
+
+    # File.directory?
+    def directory?(path)
+      File.directory?(path)
+    end
+
+    # File.file?
+    def file?(path)
+      File.file?(path)
+    end
+
+    # uses File.size and Dir.entries
+    # for files it returns `nil` if file does not exist, `true` if it's empty
+    def empty?(path)
+      if !File.exist?(path)
+        nil
+      elsif File.directory?(path)
+        Dir.entries(path) == ['.', '..']
+      else
+        File.size(path) == 0
+      end
+    end
+
+    # File.join
+    def join(*args)
+      File.join(*args)
+    end
+
+    # File.expand_path
+    def expand_path(path)
+      File.expand_path(path)
+    end
+
+    # checks for a slash at the beginning
+    def absolute?(path)
+      %r{\A/} =~ path ? true : false
+    end
+
+    # File.dirname
+    # "tmp/foo/bar.todo" => "tmp/foo"
+    def dirname(path)
+      File.dirname(path)
+    end
+
+    # File.basename
+    # "tmp/foo/bar.todo" => "bar.todo"
+    def basename(path)
+      File.basename(path)
+    end
+
+    # File.extname
+    # "tmp/foo/bar.todo" => ".todo"
+    def extname(path)
+      File.extname(path)
+    end
+
+    # "tmp/foo/bar.todo" => "bar"
+    def filename(path)
+      return '' if path == '/' || path == '.'
+      base = File.basename(path)
+      ext = File.extname(path)
+      ext.empty? ? base :base[0...-ext.size]  
+    end
+
+    # "tmp/foo/bar.todo" => ["tmp/foo", "bar", ".todo"]
+    def splitname(path)
+      [dirname(path), filename(path), extname(path)]
+    end
+    
+    # __FILE__ of the caller
+    def this_file
+      caller_file(caller)
+    end
+    
+    # File.dirname(__FILE__) of the caller
+    def this_dir
+      File.dirname(caller_file(caller))
+    end
 
     private
     
@@ -120,8 +226,46 @@ module FS
 
     def glob(dir, *patterns)
       fulldir = File.expand_path(dir)
+      regexp = /^#{Regexp.escape(fulldir)}\/?/
       Dir.glob(File.join(fulldir, patterns)).map do |path|
-        path.gsub(/^#{fulldir}\/?/, '')
+        path.gsub(regexp, '')
+      end
+    end
+    
+    def visit_tree(output, parent_path, indent, arm, tie, node)
+      output << "#{indent}#{arm}#{tie}#{node}"
+      
+      node_path = File.expand_path(node, parent_path)
+      return unless File.directory?(node_path) && File.readable?(node_path)
+      
+      subnodes = FS.list(node_path)
+      return if subnodes.empty?
+      
+      arms = Array.new(subnodes.length - 1, '|') << '`'
+      arm_to_indent = {
+        ''  => '',
+        '|' => '|   ',
+        '`' => '    '
+      }
+      subnodes.each_with_index do |subnode, index|
+        visit_tree(output, node_path, indent + arm_to_indent[arm], arms[index], '-- ', subnode)
+      end
+    end
+
+    def caller_file(trace)
+      if arr = parse_caller(trace.first)
+        arr.first
+      end
+    end
+
+    # http://grosser.it/2009/07/01/getting-the-caller-method-in-ruby/
+    # Stolen from ActionMailer, where this was used but was not made reusable
+    def parse_caller(at)
+      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+        file   = Regexp.last_match[1]
+        line   = Regexp.last_match[2].to_i
+        method = Regexp.last_match[3]
+        [file, line, method]
       end
     end
     

data/lib/fs/version.rb

@@ -1,3 +1,3 @@
 module FS
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/base_spec.rb

@@ -322,4 +322,253 @@ describe FS::Base do
     end
   end
   
+  describe 'tree' do
+    before(:each) do
+      FS.touch('a.file')
+      FS.makedir('baz')
+      FS.touch('baz/b.file')
+      FS.mkdir('baz/bar')
+      FS.touch('baz/bar/c.file')
+      FS.touch('baz/d.file')
+      FS.makedir('foo')
+      FS.touch('foo/e.file')
+    end
+
+    it 'returns the tree of the current dir' do
+      tree = <<-TXT
+.
+|-- a.file
+|-- baz
+|   |-- b.file
+|   |-- bar
+|   |   `-- c.file
+|   `-- d.file
+`-- foo
+    `-- e.file
+TXT
+      FS.tree.should eql(tree.strip)
+    end
+
+    it 'returns the tree of a dir' do
+      tree = <<-TXT
+baz
+|-- b.file
+|-- bar
+|   `-- c.file
+`-- d.file
+TXT
+      FS.tree('baz').should eql(tree.strip)
+    end
+
+  end
+  
+  describe 'exist?' do
+    it 'returns if a path exist' do
+      FS.makedir('foo')
+      FS.touch('bar')
+      FS.exist?('foo').should be_true
+      FS.exist?('bar').should be_true
+      FS.exist?('baz').should be_false
+    end
+  end
+
+  describe 'directory?' do
+    it 'checks for a directory' do
+      FS.makedir('foo')
+      FS.touch('bar')
+      FS.directory?('foo').should be_true
+      FS.directory?('bar').should be_false
+      FS.directory?('baz').should be_false
+    end
+  end
+  
+  describe 'file?' do
+    it 'checks for a file' do
+      FS.makedir('foo')
+      FS.touch('bar')
+      FS.file?('foo').should be_false
+      FS.file?('bar').should be_true
+      FS.file?('baz').should be_false
+    end
+  end
+  
+  describe 'empty?' do
+    it 'returns nil if the path does not exist' do
+      FS.exist?('foobar').should be_false
+      FS.empty?('foobar').should be_nil
+    end
+    
+    it 'returns if a file is empty' do
+      FS.touch('empty.file')
+      FS.write('content.file', 'something')
+      FS.empty?('empty.file').should be_true
+      FS.empty?('content.file').should be_false
+    end
+    
+    it 'returns if a dir is empty' do
+      FS.mkdir('empty.dir')
+      FS.mkdir('content.dir')
+      FS.touch('content.dir/some.file')
+      FS.empty?('empty.dir').should be_true
+      FS.empty?('content.dir').should be_false
+    end
+  end
+  
+  describe 'join' do
+    it 'joins pathes' do
+      FS.join('foo', 'bar').should eql('foo/bar')
+      FS.join('foo', '/bar').should eql('foo/bar')
+      FS.join('foo/', 'bar').should eql('foo/bar')
+    end 
+  end
+  
+  describe 'expand_path' do
+    it 'expands pathes' do
+      here = File.expand_path('.')
+      FS.expand_path('.').should eql(here)
+      FS.expand_path('foo').should eql(File.join(here, 'foo'))
+      FS.expand_path('foo/bar').should eql(File.join(here, 'foo', 'bar'))
+    end
+  end
+
+  describe 'absolute?' do
+    it 'checks for an absolute path' do
+      FS.absolute?('/').should be_true
+      FS.absolute?('/foo').should be_true
+      FS.absolute?('.').should be_false
+      FS.absolute?('foo').should be_false
+    end
+  end
+
+  describe 'dirname' do
+    it 'extracts the dir of a path' do
+      FS.dirname('tmp/foo/bar.todo').should eql('tmp/foo')
+      FS.dirname('tmp/foo').should eql('tmp')
+      FS.dirname('tmp/foo/').should eql('tmp')
+      FS.dirname('/tmp').should eql('/')
+      FS.dirname('/').should eql('/')
+      FS.dirname('.').should eql('.')
+    end
+  end
+
+  describe 'basename' do
+    it 'extracts the base of a path' do
+      FS.basename('tmp/foo/bar.todo').should eql('bar.todo')
+      FS.basename('tmp/foo').should eql('foo')
+      FS.basename('tmp/foo/').should eql('foo')
+      FS.basename('/tmp').should eql('tmp')
+      FS.basename('/').should eql('/')
+      FS.basename('.').should eql('.')
+    end
+  end
+  
+  describe 'filename' do
+    it 'extracts the filename of a path' do
+      FS.filename('tmp/foo/bar.todo').should eql('bar')
+      FS.filename('tmp/foo').should eql('foo')
+      FS.filename('tmp/foo/').should eql('foo')
+      FS.filename('/tmp').should eql('tmp')
+      FS.filename('/').should eql('') # this is not like FS.basename
+      FS.filename('.').should eql('') # this is not like FS.basename
+      FS.filename('foo.bar.txt').should eql('foo.bar')
+    end
+  end
+  
+  describe 'extname' do
+    it 'extracts the extension of a path' do
+      FS.extname('tmp/foo/bar.todo').should eql('.todo')
+      FS.extname('tmp/foo').should eql('')
+      FS.extname('tmp/foo/').should eql('')
+      FS.extname('/tmp').should eql('')
+      FS.extname('/').should eql('')
+      FS.extname('.').should eql('')
+      FS.extname('foo.bar.txt').should eql('.txt')
+    end
+  end
+  
+  describe 'splitname' do
+    it 'splits the parts of a path' do
+      FS.splitname('tmp/foo/bar.todo').should eql(["tmp/foo", "bar", ".todo"])
+      FS.splitname('tmp/foo').should eql(['tmp', 'foo', ''])
+      FS.splitname('tmp/foo/').should eql(['tmp', 'foo', ''])
+      FS.splitname('/tmp').should eql(['/', 'tmp', ''])
+      FS.splitname('/').should eql(['/', '', ''])
+      FS.splitname('.').should eql(['.', '', ''])
+    end
+  end
+  
+  describe 'this_file' do
+    it 'returns this file' do
+      FS.this_file.should eql(__FILE__)
+    end
+  end
+
+  describe 'this_dir' do
+    it 'returns the dir of this file' do
+      FS.this_dir.should eql(File.dirname(__FILE__))
+    end
+  end
+  
+  describe 'tempdir' do
+    it 'returns the current temp dir' do
+      FS.tempdir.should eql(Dir.tmpdir)
+    end
+  end
+  
+  describe 'maketempdir' do
+    it 'creates a new dir in the default temp dir' do
+      dir = FS.maketempdir
+      File.exist?(dir).should be_true
+      File.directory?(dir).should be_true
+      Dir.entries(dir).should eql([".", ".."])
+      Dir.entries(Dir.tmpdir).should include(File.basename(dir))
+    end
+    
+    it 'creates a new temp dir with the given prefix' do
+      dir = FS.maketempdir('my_dir')
+      dir.should match(/\/my_dir/)
+      File.exist?(dir).should be_true
+      File.directory?(dir).should be_true
+      Dir.entries(dir).should eql([".", ".."])
+      Dir.entries(Dir.tmpdir).should include(File.basename(dir))
+    end
+    
+    it 'creates a new temp dir inside of the given dir' do
+      parent_dir = FS.maketempdir('parent_dir')
+      dir = FS.maketempdir(nil, parent_dir)
+      File.exist?(dir).should be_true
+      File.directory?(dir).should be_true
+      Dir.entries(dir).should eql([".", ".."])
+      Dir.entries(parent_dir).should include(File.basename(dir))
+    end
+  end
+  
+  describe 'maketempfile' do
+    it 'creates a new file in the default temp dir' do
+      file = FS.maketempfile
+      FS.exist?(file).should be_true
+      FS.file?(file).should be_true
+      FS.empty?(file).should be_true
+      FS.list(Dir.tmpdir).should include(File.basename(file))
+    end
+
+    it 'creates a new temp file with the given prefix' do
+      file = FS.maketempfile('my_file')
+      file.should match(/\/my_file/)
+      FS.exist?(file).should be_true
+      FS.file?(file).should be_true
+      FS.empty?(file).should be_true
+      FS.list(Dir.tmpdir).should include(File.basename(file))
+    end
+    
+    it 'creates a new temp file inside of the given dir' do
+      parent_dir = FS.maketempdir('parent_dir')
+      file = FS.maketempfile(nil, parent_dir)
+      FS.exist?(file).should be_true
+      FS.file?(file).should be_true
+      FS.empty?(file).should be_true
+      FS.list(parent_dir).should include(File.basename(file))
+    end
+  end
+  
 end

data/spec/support/test_dir_support.rb

@@ -12,8 +12,7 @@ module FS
     def use_helper(describe_block)
       describe_block.before :each do
         unless @test_dir
-          @test_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'tmp', 'test'))
-          FileUtils.mkdir_p(@test_dir)
+          @test_dir = File.realpath(Dir.mktmpdir('test_'))
           Dir.chdir(@test_dir)
         end
       end

metadata

@@ -2,7 +2,7 @@
 name: fs
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - "Bernd J\xC3\xBCnger"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-29 00:00:00 +02:00
+date: 2011-04-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency