rush2 0.7.1 → 0.8.0

data/spec/commands_spec.rb

@@ -1,47 +1,47 @@
 require_relative 'base'
 
 describe Rush::Commands do
-	before do
-		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
-		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
-
-		@filename = "test_file"
-		system "echo thing_to_find > #{@sandbox_dir}/#{@filename}"
-		system "echo dont_find_me > #{@sandbox_dir}/some_other_file"
-
-		@dir = Rush::Dir.new(@sandbox_dir)
-		@array = @dir.files
-	end
-
-	after do
-		system "rm -rf #{@sandbox_dir}"
-	end
-
-	it "searches a list of files" do
-		results = @dir.files.search(/thing_to_find/)
-		results.should be_kind_of(Rush::SearchResults)
-		results.entries.should == [ @dir[@filename] ]
-		results.lines.should == [ "thing_to_find" ]
-	end
-
-	it "searches a dir" do
-		@dir.search(/thing_to_find/).entries.should == [ @dir[@filename] ]
-	end
-
-	it "searchs a dir's nested files" do
-		@dir.create_dir('sub').create_file('file').write('nested')
-		@dir['**'].search(/nested/).entries.should == [ @dir['sub/file'] ]
-	end
-
-	it "search and replace contents on all files in the glob" do
-		@dir['1'].create.write('xax')
-		@dir['2'].create.write('-a-')
-		@dir.replace_contents!(/a/, 'b')
-		@dir['1'].contents.should == "xbx"
-		@dir['2'].contents.should == "-b-"
-	end
-
-	it "counts lines of the contained files" do
-		@dir.files.line_count.should == 2
-	end
+  before do
+    @sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+    system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+    @filename = 'test_file'
+    system "echo thing_to_find > #{@sandbox_dir}/#{@filename}"
+    system "echo dont_find_me > #{@sandbox_dir}/some_other_file"
+
+    @dir = Rush::Dir.new(@sandbox_dir)
+    @array = @dir.files
+  end
+
+  after do
+    system "rm -rf #{@sandbox_dir}"
+  end
+
+  it 'searches a list of files' do
+    results = @dir.files.search(/thing_to_find/)
+    expect(results).to be_kind_of(Rush::SearchResults)
+    expect(results.entries).to eq [@dir[@filename]]
+    expect(results.lines).to eq ['thing_to_find']
+  end
+
+  it 'searches a dir' do
+    expect(@dir.search(/thing_to_find/).entries).to eq [@dir[@filename]]
+  end
+
+  it 'searchs a dir\'s nested files' do
+    @dir.create_dir('sub').create_file('file').write('nested')
+    expect(@dir['**'].search(/nested/).entries).to eq [@dir['sub/file']]
+  end
+
+  it 'search and replace contents on all files in the glob' do
+    @dir['1'].create.write('xax')
+    @dir['2'].create.write('-a-')
+    @dir.replace_contents!(/a/, 'b')
+    expect(@dir['1'].contents).to eq 'xbx'
+    expect(@dir['2'].contents).to eq '-b-'
+  end
+
+  it 'counts lines of the contained files' do
+    expect(@dir.files.line_count).to eq 2
+  end
 end

data/spec/embeddable_shell_spec.rb

@@ -6,12 +6,12 @@ describe Rush::EmbeddableShell do
 	end
 
 	it "should execute unknown methods against a Rush::Shell instance" do
-		@shell.root.class.should == Rush::Dir
+		expect(@shell.root.class).to eq(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
-		}
+		expect(@shell.execute_in_shell {
+			root.class
+		}).to eq Rush::Dir
 	end
 end

data/spec/entry_spec.rb

@@ -1,133 +1,133 @@
 require_relative 'base'
 
 describe Rush::Entry do
-	before do
-		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}/"
-		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+  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}"
+    @filename = "#{@sandbox_dir}/test_file"
+    system "touch #{@filename}"
 
-		@entry = Rush::Entry.new(@filename)
-	end
+    @entry = Rush::Entry.new(@filename)
+  end
 
-	after do
-		system "rm -rf #{@sandbox_dir}"
-	end
+  after do
+    system "rm -rf #{@sandbox_dir}"
+  end
 
-	it "knows its name" do
-		@entry.name.should == File.basename(@filename)
-	end
+  it 'knows its name' do
+    expect(@entry.name).to eq 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 changed_at time" do
-		@entry.changed_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 "rename returns the renamed file" do
-		@entry.rename('file2').should == @entry.parent['file2']
-	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 'knows its parent dir' do
+    expect(@entry.parent).to be_kind_of(Rush::Dir)
+    expect(@entry.parent.name).to eq File.basename(@sandbox_dir)
+    expect(@entry.parent.full_path).to eq @sandbox_dir
+  end
+
+  it 'cleans its pathname' do
+    expect(Rush::Entry.new('/a//b//c').full_path).to eq '/a/b/c'
+    expect(Rush::Entry.new('/1/2/../3').full_path).to eq '/1/3'
+  end
+
+  it 'knows its changed_at time' do
+    expect(@entry.changed_at).to eq File.stat(@filename).ctime
+  end
+
+  it 'knows its last_modified time' do
+    expect(@entry.last_modified).to eq File.stat(@filename).mtime
+  end
+
+  it 'knows its last_accessed time' do
+    expect(@entry.last_accessed).to eq File.stat(@filename).atime
+  end
+
+  it 'considers itself equal to other instances with the same full path' do
+    expect(Rush::Entry.new('/not/the/same')).to_not eq @entry
+    expect(Rush::Entry.new(@entry.full_path)).to eq @entry
+  end
+
+  it 'can rename itself' do
+    new_file = 'test2'
+
+    @entry.rename(new_file)
+
+    expect(File.exist?(@filename)).to eq false
+    expect(File.exist?("#{@sandbox_dir}/#{new_file}")).to eq true
+  end
+
+  it 'rename returns the renamed file' do
+    expect(@entry.rename('file2')).to eq @entry.parent['file2']
+  end
+
+  it 'can\'t rename itself if another file already exists with that name' do
+    new_file = 'test3'
+    system "touch #{@sandbox_dir}/#{new_file}"
+
+      expect { @entry.rename(new_file) }.to raise_error(Rush::NameAlreadyExists, /#{new_file}/)
+  end
+
+  it "can't rename itself to something with a slash in it" do
+    expect { @entry.rename('has/slash') }.to raise_error(Rush::NameCannotContainSlash, /slash/)
+  end
+
+  it 'can duplicate itself within the directory' do
+    expect(@entry.duplicate('newfile')).to eq 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)
+
+    expect(File.exist?(@filename)).to eq false
+    expect(File.exist?("#{newdir}/#{@entry.name}")).to eq 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)
+
+    expect(File.exist?(@filename)).to eq true
+    expect(File.exist?("#{newdir}/#{@entry.name}")).to eq true
+
+      expect(@copied_dir.full_path).to eq "#{@sandbox_dir}newdir/#{@entry.name}"
+  end
+
+  it 'considers dotfiles to be hidden' do
+    expect(Rush::Entry.new("#{@sandbox_dir}/show")).to_not be_hidden
+    expect(Rush::Entry.new("#{@sandbox_dir}/.dont_show")).to 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
+  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)
+    expect(@entry).to eq 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'))
+    expect(@entry).to_not eq same
+  end
+
+  it 'can mimic another entry' do
+    copy = Rush::Entry.new('abc', :dummy)
+    copy.mimic(@entry)
+    expect(copy.path).to eq @entry.path
+  end
+
+  it 'can update the read access permission' do
+    system "chmod 666 #{@filename}"
+    @entry.access = { :user_can => :read }
+    expect(`ls -l #{@filename}`).to match(/^-r--------/)
+  end
+
+  it 'reads the file permissions in the access hash' do
+    system "chmod 640 #{@filename}"
+    expect(@entry.access).to eq({ user_can_read: true, user_can_write: true, group_can_read: true })
+  end
 end

data/spec/file_spec.rb

@@ -1,83 +1,83 @@
 require_relative '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 "read is an alias for contents" do
-		@file.read.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
+  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
+    expect(@file).to be_kind_of(Rush::Entry)
+  end
+
+  it 'is not a dir' do
+    expect(@file).to_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")
+    expect(create_me.create).to eq create_me
+    expect(File.exist?("#{@sandbox_dir}/create_me")).to eq true
+  end
+
+  it 'knows its size in bytes' do
+    expect(@file.size).to eq @contents.length
+  end
+
+  it 'can read its contents' do
+    expect(@file.contents).to eq @contents
+  end
+
+  it 'read is an alias for contents' do
+    expect(@file.read).to eq @contents
+  end
+
+  it 'can write new contents' do
+    @file.write('write test')
+    expect(@file.contents).to eq 'write test'
+  end
+
+  it 'can count the number of lines it contains' do
+    @file.write("1\n2\n3\n")
+    expect(@file.line_count).to eq 3
+  end
+
+  it 'searches its contents for matching lines' do
+    @file.write("a\n1\nb\n2\n")
+    expect(@file.search(/\d/)).to eq %w(1 2)
+  end
+
+  it 'search returns nil if no lines match' do
+    @file.write("a\nb\nc\n")
+    expect(@file.search(/\d/)).to eq nil
+  end
+
+  it 'find-in-file replace' do
+    @file.replace_contents!(/\d/, 'x')
+    expect(@file.contents).to eq "xxxx\n"
+  end
+
+  it 'can destroy itself' do
+    @file.destroy
+    expect(::File.exist?(@filename)).to eq false
+  end
+
+  it "can fetch contents or blank if doesn't exist" do
+    expect(Rush::File.new('/does/not/exist').contents_or_blank).to eq ''
+  end
+
+  it 'can fetch lines, or empty if doesn\'t exist' do
+    expect(Rush::File.new('/does/not/exist').lines_or_empty).to eq []
+  end
 end