dysinger-rush 0.4

data/spec/dir_spec.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Dir do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@dirname = "#{@sandbox_dir}/test_dir/"
+		system "mkdir -p #{@dirname}"
+
+		@dir = Rush::Dir.new(@dirname)
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "is a child of Rush::Entry" do
+		@dir.should be_kind_of(Rush::Entry)
+	end
+
+	it "can create itself, returning itself" do
+		system "rm -rf #{@sandbox_dir}"
+		@dir.create.should == @dir
+		File.directory?(@dir.full_path).should be_true
+	end
+
+	it "can create a new file" do
+		newfile = @dir.create_file('one.txt')
+		newfile.name.should == 'one.txt'
+		newfile.parent.should == @dir
+	end
+
+	it "can create a new subdir" do
+		newfile = @dir['two/'].create
+		newfile.name.should == 'two'
+		newfile.parent.should == @dir
+	end
+
+	it "find_by_name finds a single entry in the contents" do
+		file = @dir.create_file('one.rb')
+		@dir.find_by_name('one.rb').should == file
+	end
+
+	it "find_by_glob finds a list of entries by wildcard" do
+		file1 = @dir.create_file('one.rb')
+		file2 = @dir.create_file('two.txt')
+		@dir.find_by_glob('*.rb').should == [ file1 ]
+	end
+
+	it "lists files" do
+		@dir.create_file('a')
+		@dir.files.should == [ Rush::File.new("#{@dirname}/a") ]
+	end
+
+	it "lists dirs" do
+		system "mkdir -p #{@dir.full_path}/b"
+		@dir.dirs.should == [ Rush::Dir.new("#{@dirname}/b") ]
+	end
+
+	it "lists combined files and dirs" do
+		@dir['c'].create
+		@dir['d/'].create
+		@dir.contents.size.should == 2
+	end
+
+	it "fetches the entry_tree of all contents recursively" do
+		@dir['a/'].create['b/'].create['c'].create
+		@dir.entries_tree.should == @dir.make_entries(%w(a/ a/b/ a/b/c))
+	end
+
+	it "maps [] to find_by_name" do
+		@dir.should_receive(:find_by_name).once
+		@dir['one']
+	end
+
+	it "maps [] with a wildcard character to find_by_glob" do
+		@dir.should_receive(:find_by_glob).once
+		@dir['*']
+	end
+
+	it "can use symbols or strings for [] access" do
+		@dir.should_receive(:find_by_name).once.with('subdir')
+		@dir[:subdir]
+	end
+
+	it "[] can return a file that has yet to be created" do
+		@dir['not_yet'].class.should == Rush::File
+	end
+
+	it "makes a list of entries from an array of filenames" do
+		@dir['a'].create
+		@dir['b/c/'].create
+		@dir.make_entries(%w(a b/c)).should == [ @dir['a'], @dir['b/c'] ]
+	end
+
+	it "lists flattened files from all nested subdirectories" do
+		@dir['1'].create
+		@dir['2/3/'].create['4'].create
+		@dir['a/b/c/'].create['d'].create
+		@dir.files_flattened.should == @dir.make_entries(%w(1 2/3/4 a/b/c/d))
+	end
+
+	it "lists flattened dirs from all nested subdirectories" do
+		@dir.create_dir('1/2')
+		@dir.dirs_flattened.should == @dir.make_entries(%w(1/ 1/2/))
+	end
+
+	it "** as a shortcut to flattened_files" do
+		@dir['**'].should == @dir.files_flattened
+	end
+
+	it "**/ as a shortcut to flattened_files + regular globbing" do
+		@dir.create_file('1.rb')
+		@dir.create_file('ignore.txt')
+		@dir.create_dir('2').create_file('3.rb')
+		@dir.create_dir('a/b').create_file('c.rb')
+		@dir['**/*.rb'].should == @dir.make_entries(%w(1.rb 2/3.rb a/b/c.rb))
+	end
+
+	it "lists nonhidden files" do
+		@dir.create_file('show')
+		@dir.create_file('.dont_show')
+		@dir.nonhidden_files.should == @dir.make_entries(%(show))
+	end
+
+	it "lists nonhidden dirs" do
+		@dir.create_dir('show')
+		@dir.create_dir('.dont_show')
+		@dir.nonhidden_dirs.should == @dir.make_entries(%(show/))
+	end
+
+	if !RUBY_PLATFORM.match(/darwin/)   # doesn't work on OS X 'cause du switches are different
+		it "knows its size in bytes, which includes its contents recursively" do
+			@dir.create_file('a').write('1234')
+			@dir.size.should be(4096 + 4)
+		end
+	end
+
+	it "can destroy itself when empty" do
+		@dir.destroy
+	end
+
+	it "can destroy itself when not empty" do
+		@dir.create_dir('a').create_file('b').write('c')
+		@dir.destroy
+	end
+
+	it "can run a bash command within itself" do
+		system "echo test > #{@dir.full_path}/file"
+		@dir.bash("cat file").should == "test\n"
+	end
+
+	it "passes bash options (e.g., :user) through to the box bash command" do
+		@box.should_receive(:bash).with('cmd', :opt1 => 1, :opt2 => 2)
+		@box.bash('cmd', :opt1 => 1, :opt2 => 2)
+	end
+
+end

data/spec/embeddable_shell_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::EmbeddableShell do
+	before do
+		@shell = Rush::EmbeddableShell.new
+	end
+
+	it "should execute unknown methods against a Rush::Shell instance" do
+		@shell.root.class.should == Rush::Dir
+	end
+	
+	it "should executes a block as if it were inside the shell" do
+		@shell.execute_in_shell {
+			root.class.should == Rush::Dir
+		}
+	end
+end

data/spec/entry_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Entry do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}/"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@filename = "#{@sandbox_dir}/test_file"
+		system "touch #{@filename}"
+
+		@entry = Rush::Entry.new(@filename)
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "knows its name" do
+		@entry.name.should == File.basename(@filename)
+	end
+
+	it "knows its parent dir" do
+		@entry.parent.should be_kind_of(Rush::Dir)
+		@entry.parent.name.should == File.basename(@sandbox_dir)
+		@entry.parent.full_path.should == @sandbox_dir
+	end
+
+	it "cleans its pathname" do
+		Rush::Entry.new('/a//b//c').full_path.should == '/a/b/c'
+		Rush::Entry.new('/1/2/../3').full_path.should == '/1/3'
+	end
+
+	it "knows its created_at time" do
+		@entry.created_at.should == File.stat(@filename).ctime
+	end
+
+	it "knows its last_modified time" do
+		@entry.last_modified.should == File.stat(@filename).mtime
+	end
+
+	it "knows its last_accessed time" do
+		@entry.last_accessed.should == File.stat(@filename).atime
+	end
+
+	it "considers itself equal to other instances with the same full path" do
+		Rush::Entry.new('/not/the/same').should_not == @entry
+		Rush::Entry.new(@entry.full_path).should == @entry
+	end
+
+	it "can rename itself" do
+		new_file = "test2"
+
+		@entry.rename(new_file)
+
+		File.exists?(@filename).should be_false
+		File.exists?("#{@sandbox_dir}/#{new_file}").should be_true
+	end
+
+	it "can't rename itself if another file already exists with that name" do
+		new_file = "test3"
+		system "touch #{@sandbox_dir}/#{new_file}"
+
+		lambda { @entry.rename(new_file) }.should raise_error(Rush::NameAlreadyExists, /#{new_file}/)
+	end
+
+	it "can't rename itself to something with a slash in it" do
+		lambda { @entry.rename('has/slash') }.should raise_error(Rush::NameCannotContainSlash, /slash/)
+	end
+
+	it "can duplicate itself within the directory" do
+		@entry.duplicate('newfile').should == Rush::File.new("#{@sandbox_dir}/newfile")
+	end
+
+	it "can move itself to another dir" do
+		newdir = "#{@sandbox_dir}/newdir"
+		system "mkdir -p #{newdir}"
+
+		dst = Rush::Dir.new(newdir)
+		@entry.move_to(dst)
+
+		File.exists?(@filename).should be_false
+		File.exists?("#{newdir}/#{@entry.name}").should be_true
+	end
+
+	it "can copy itself to another directory" do
+		newdir = "#{@sandbox_dir}/newdir"
+		system "mkdir -p #{newdir}"
+
+		dst = Rush::Dir.new(newdir)
+		@copied_dir = @entry.copy_to(dst)
+
+		File.exists?(@filename).should be_true
+		File.exists?("#{newdir}/#{@entry.name}").should be_true
+
+		@copied_dir.full_path.should == "#{@sandbox_dir}newdir/#{@entry.name}"
+	end
+
+	it "considers dotfiles to be hidden" do
+		Rush::Entry.new("#{@sandbox_dir}/show").should_not be_hidden
+		Rush::Entry.new("#{@sandbox_dir}/.dont_show").should be_hidden
+	end
+
+	it "is considered equal to entries with the same full path and on the same box" do
+		same = Rush::Entry.new(@entry.full_path, @entry.box)
+		@entry.should == same
+	end
+
+	it "is considered not equal to entries with the same full path on a different box" do
+		same = Rush::Entry.new(@entry.full_path, Rush::Box.new('dummy'))
+		@entry.should_not == same
+	end
+
+	it "can mimic another entry" do
+		copy = Rush::Entry.new('abc', :dummy)
+		copy.mimic(@entry)
+		copy.path.should == @entry.path
+	end
+
+	it "can update the read access permission" do
+		system "chmod 666 #{@filename}"
+		@entry.access = { :user_can => :read }
+		`ls -l #{@filename}`.should match(/^-r--------/)
+	end
+
+	it "reads the file permissions in the access hash" do
+		system "chmod 640 #{@filename}"
+		@entry.access.should == { :user_can_read => true, :user_can_write => true, :group_can_read => true }
+	end
+end

data/spec/file_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::File do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@filename = "#{@sandbox_dir}/test_file"
+		@contents = "1234"
+		system "echo #{@contents} > #{@filename}"
+		@contents += "\n"
+
+		@file = Rush::File.new(@filename)
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "is a child of Rush::Entry" do
+		@file.should be_kind_of(Rush::Entry)
+	end
+
+	it "is not a dir" do
+		@file.should_not be_dir
+	end
+
+	it "can create itself as a blank file, and return itself" do
+		create_me = Rush::File.new("#{@sandbox_dir}/create_me")
+		create_me.create.should == create_me
+		File.exists?("#{@sandbox_dir}/create_me").should == true
+	end
+
+	it "knows its size in bytes" do
+		@file.size.should == @contents.length
+	end
+
+	it "can read its contents" do
+		@file.contents.should == @contents
+	end
+
+	it "can write new contents" do
+		@file.write('write test')
+		@file.contents.should == 'write test'
+	end
+
+	it "can count the number of lines it contains" do
+		@file.write("1\n2\n3\n")
+		@file.line_count.should == 3
+	end
+
+	it "searches its contents for matching lines" do
+		@file.write("a\n1\nb\n2\n")
+		@file.search(/\d/).should == %w(1 2)
+	end
+
+	it "search returns nil if no lines match" do
+		@file.write("a\nb\nc\n")
+		@file.search(/\d/).should be_nil
+	end
+
+	it "find-in-file replace" do
+		@file.replace_contents!(/\d/, 'x')
+		@file.contents.should == "xxxx\n"
+	end
+
+	it "can destroy itself" do
+		@file.destroy
+		::File.exists?(@filename).should be_false
+	end
+
+	it "can fetch contents or blank if doesn't exist" do
+		Rush::File.new('/does/not/exist').contents_or_blank.should == ""
+	end
+
+	it "can fetch lines, or empty if doesn't exist" do
+		Rush::File.new('/does/not/exist').lines_or_empty.should == []
+	end
+end

data/spec/find_by_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::FindBy do
+	before do
+		class Foo
+			attr_accessor :bar
+
+			def initialize(bar)
+				@bar = bar
+			end end
+
+		@one = Foo.new('one')
+		@two = Foo.new('two')
+		@three = Foo.new('three')
+
+		@list = [ @one, @two, @three ]
+	end
+
+	it "compare_or_match exact match success" do
+		@list.compare_or_match('1', '1').should == true
+	end
+
+	it "compare_or_match exact match failure" do
+		@list.compare_or_match('1', '2').should == false
+	end
+
+	it "compare_or_match regexp match success" do
+		@list.compare_or_match('123', /2/).should == true
+	end
+
+	it "compare_or_match regexp match failure" do
+		@list.compare_or_match('123', /x/).should == false
+	end
+
+	it "find_by_ extact match" do
+		@list.find_by_bar('two').should == @two
+	end
+
+	it "find_by_ regexp match" do
+		@list.find_by_bar(/.hree/).should == @three
+	end
+
+	it "find_all_by_ exact match" do
+		@list.find_all_by_bar('one').should == [ @one ]
+	end
+
+	it "find_all_by_ regexp match" do
+		@list.find_all_by_bar(/^...$/).should == [ @one, @two ]
+	end
+
+	it "find_by_ with field not recognized by objects raises no errors" do
+		@list.find_by_nothing('x')
+	end
+
+	it "raises NoMethodError for things other than find_by" do
+		lambda { @list.does_not_exist }.should raise_error(NoMethodError)
+	end
+end

data/spec/fixnum_ext_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Fixnum do
+	before do
+		@num = 2
+	end
+
+	it "counts kb" do
+		@num.kb.should == 2*1024
+	end
+
+	it "counts mb" do
+		@num.mb.should == 2*1024*1024
+	end
+
+	it "counts gb" do
+		@num.gb.should == 2*1024*1024*1024
+	end
+end