githug 0.4.2 → 0.4.3

data/spec/githug/profile_spec.rb

@@ -2,33 +2,39 @@ require 'spec_helper'
 
 describe Githug::Profile do
 
-  it "should load the profile" do
-    settings = {:level => 1, :current_attempts => 0, :current_hint_index => 0, :current_levels => [], :completed_levels => []}
-    File.should_receive(:exists?).with(Githug::Profile::PROFILE_FILE).and_return(true)
-    File.should_receive(:open).with(Githug::Profile::PROFILE_FILE).and_return("settings")
-    YAML.should_receive(:load).with("settings").and_return(settings)
-    Githug::Profile.should_receive(:new).with(settings)
-    Githug::Profile.load
-  end
+  describe ".load" do
+    it "loads the profile" do
+      settings = {:level => 1, :current_attempts => 0, :current_hint_index => 0, :current_levels => [], :completed_levels => []}
+      File.should_receive(:exists?).with(Githug::Profile::PROFILE_FILE).and_return(true)
+      File.should_receive(:open).with(Githug::Profile::PROFILE_FILE).and_return("settings")
+      YAML.should_receive(:load).with("settings").and_return(settings)
+      Githug::Profile.should_receive(:new).with(settings)
+      Githug::Profile.load
+    end
 
-  it "should load the defaults if the file does not exist" do
-    defaults = {:level => nil, :current_attempts => 0, :current_hint_index => 0, :current_levels => [], :completed_levels => []}
-    File.should_receive(:exists?).with(Githug::Profile::PROFILE_FILE).and_return(false)
-    Githug::Profile.should_receive(:new).with(defaults)
-    Githug::Profile.load
+    it "loads the defaults if the file does not exist" do
+      defaults = {:level => nil, :current_attempts => 0, :current_hint_index => 0, :current_levels => [], :completed_levels => []}
+      File.should_receive(:exists?).with(Githug::Profile::PROFILE_FILE).and_return(false)
+      Githug::Profile.should_receive(:new).with(defaults)
+      Githug::Profile.load
+    end
   end
 
-  it "should allow method acces to getters and setters" do
+  it "allows method acces to getters and setters" do
     profile = Githug::Profile.load
     profile.level.should eql(nil)
     profile.level = 1
     profile.level.should eql(1)
   end
 
-  it "should save the file" do
-    profile = Githug::Profile.load
-    File.should_receive(:open).with(Githug::Profile::PROFILE_FILE, "w")
-    profile.save
+  describe ".save" do
+
+    it "saves the file" do
+      profile = Githug::Profile.load
+      File.should_receive(:open).with(Githug::Profile::PROFILE_FILE, "w")
+      profile.save
+    end
+
   end
 
   describe "level methods" do
@@ -46,30 +52,30 @@ describe Githug::Profile do
       Githug::Level::LEVELS = @levels
     end
 
-    describe "level_bump" do
+    describe "#level_bump" do
 
-
-      it "should bump the level" do
+      it "bumps the level" do
         profile.should_receive(:set_level).with("add")
         profile.level_bump
       end
 
-      it "should reset the current_attempts" do
+      it "resets the current_attempts" do
         profile.current_attempts = 1
         profile.level_bump
         profile.current_attempts.should eql(0)
       end
 
-      it "should set the level to the first incomplete level" do
-        profile.settings.stub(:[]).with(:level).and_return("rm_cached")
-        profile.settings.stub(:[]).with(:completed_levels).and_return(["init", "add"])
-        profile.level_bump.should eql("rm")
+      it "sets the level to the first incomplete level" do
+        profile.level = "rm_cached"
+        profile.completed_levels = ["init", "add"]
+        profile.level_bump
+        profile.level.should eql("rm")
       end
     end
 
-    describe "set_level" do
+    describe "#set_level" do
 
-      it "should set the level" do
+      it "sets the level" do
         profile.should_receive(:save)
         profile.should_receive(:reset!)
         profile.set_level("rm")

data/spec/githug/repository_spec.rb

@@ -2,95 +2,94 @@ require 'spec_helper'
 
 describe Githug::Repository do
 
+  let(:grit) { mock }
+
   before(:each) do
-    @grit = mock
-    Grit::Repo.stub(:new).and_return(@grit)
-    @repository = Githug::Repository.new
-    @repository.stub(:create_gitignore)
+    Grit::Repo.stub(:new).and_return(grit)
+    subject.stub(:create_gitignore)
   end
 
-  describe "initialize" do
+  describe "#initialize" do
 
-    it "should call grit on initialize" do
-      Grit::Repo.should_receive(:new).with(".").and_return(@grit)
+    it "calls grit on initialize" do
+      Grit::Repo.should_receive(:new).with(".").and_return(grit)
       repo = Githug::Repository.new
-      repo.grit.should equal(@grit)
+      repo.grit.should equal(grit)
     end
 
-    it "should contain a nil grit if the repo is invalid" do
+    it "contains a nil grit if the repo is invalid" do
       Grit::Repo.should_receive(:new).and_raise(Grit::InvalidGitRepositoryError)
       repo = Githug::Repository.new
       repo.grit.should equal(nil)
     end
 
-    it "should initialize with a location" do
-      Grit::Repo.should_receive(:new).with("test").and_return(@grit)
+    it "initializes with a location" do
+      Grit::Repo.should_receive(:new).with("test").and_return(grit)
       repo = Githug::Repository.new("test")
     end
 
   end
 
-  describe "reset" do
+  describe "#reset" do
 
     before(:each) do
       FileUtils.stub(:rm_rf)
     end
 
-    it "should do nothing if the current directory isn't git_hug" do
+    it "does nothing if the current directory isn't git_hug" do
       Dir.stub(:pwd).and_return("/tmp/foo")
       FileUtils.should_not_receive(:rm_rf)
-      @repository.reset
+      subject.reset
     end
 
-    it "should remove all the files except .gitignore and .profile.yml" do
+    it "removes all the files except .gitignore and .profile.yml" do
       Dir.stub(:pwd).and_return("/tmp/git_hug")
       Dir.stub(:entries).and_return([".profile.yml", ".gitignore", "..", ".", "README", ".git"])
       FileUtils.should_receive(:rm_rf).with("README")
       FileUtils.should_receive(:rm_rf).with(".git")
-      @repository.reset
+      subject.reset
     end
   end
 
 
-  describe "create_gitignore" do
-    it "should create a gitignore" do
-      @repository.unstub(:create_gitignore)
+  describe "#create_gitignore" do
+    it "creates a gitignore" do
+      subject.unstub(:create_gitignore)
       File.stub(:exists?).and_return(true)
       Dir.should_receive(:chdir).with("git_hug")
       File.should_receive(:open).with(".gitignore", "w")
-      @repository.create_gitignore
+      subject.create_gitignore
     end
   end
 
-  describe "valid?" do
-    it "should be valid if grit exists" do
-      @repository.should be_valid
+  describe "#valid?" do
+    it "is valid if grit exists" do
+      subject.should be_valid
     end
 
-    it "should not be valid if grit does not exist" do
-      @repository.instance_variable_set("@grit", nil)
-      @repository.should_not be_valid
+    it "is not valid if grit does not exist" do
+      subject.instance_variable_set("@grit", nil)
+      subject.should_not be_valid
     end
   end
 
-  describe "init" do
-    it "should not add and commit gitignore if prompted" do
-      @repo = mock
-      Grit::Repo.should_receive(:init).with(".").and_return(@repo)
-      @repository.init
+  describe "#init" do
+    it "does not add and commit gitignore if prompted" do
+      Grit::Repo.should_receive(:init).with(".")
+      subject.init
     end
   end
 
-  describe "method_missing" do
-    it "should deletegate to grit if the method exists" do
-      @grit.should_receive(:respond_to?).with(:valid_method).and_return(true)
-      @grit.should_receive(:valid_method)
-      @repository.valid_method
+  describe "#method_missing" do
+    it "deletegates to grit if the method exists" do
+      grit.should_receive(:respond_to?).with(:valid_method).and_return(true)
+      grit.should_receive(:valid_method)
+      subject.valid_method
     end
 
     it "should not deletegate to grit if the method does not exist" do
-      @grit.should_receive(:respond_to?).with(:invalid_method).and_return(false)
-      lambda { @repository.invalid_method }.should raise_error(NoMethodError)
+      grit.should_receive(:respond_to?).with(:invalid_method).and_return(false)
+      lambda { subject.invalid_method }.should raise_error(NoMethodError)
     end
   end
 

data/spec/githug/ui_spec.rb

@@ -4,73 +4,73 @@ require 'spec_helper'
 
 describe Githug::UI do
 
+  let(:ui_out) { StringIO.new }
+  let(:ui_in) { StringIO.new }
+
   before(:each) do
-    @ui = Githug::UI
-    @out = StringIO.new
-    @in = StringIO.new
-    @ui.out_stream = @out
-    @ui.in_stream = @in
+    subject.out_stream = ui_out
+    subject.in_stream = ui_in
   end
 
-  it "should put to the stream" do
-    @ui.puts("hello")
-    @out.string.should eql("hello\n")
+  it "puts to the stream" do
+    subject.puts("hello")
+    ui_out.string.should eql("hello\n")
   end
 
-  it "should print an empty line with no arguments" do
-    @ui.puts
-    @out.string.should eql("\n")
+  it "prints an empty line with no arguments" do
+    subject.puts
+    ui_out.string.should eql("\n")
   end
 
-  it "should print without a new line" do
-    @ui.print("hello")
-    @out.string.should eql("hello")
+  it "prints without a new line" do
+    subject.print("hello")
+    ui_out.string.should eql("hello")
   end
 
-  it "should fetch gets from input stream" do
-    @in.puts "bar"
-    @in.rewind
-    @ui.gets.should == "bar\n"
+  it "fetches gets from input stream" do
+    ui_in.puts "bar"
+    ui_in.rewind
+    subject.gets.should == "bar\n"
   end
 
-  it "should make a wordbox" do
+  it "makes a wordbox" do
     word_box = <<-eof
 ********************************************************************************
 *                                    Githug                                    *
 ********************************************************************************
     eof
-    @ui.word_box("Githug")
-    @out.string.should eql(word_box)
+    subject.word_box("Githug")
+    ui_out.string.should eql(word_box)
   end
 
-  it "should print a correct wordbox for uneven msg length" do
-    @ui.word_box("odd",80)
-    printed = @out.string.lines
+  it "prints a correct wordbox for uneven msg length" do
+    subject.word_box("odd",80)
+    printed = ui_out.string.lines
     first_size = printed.first.chomp.length
 
     printed.map{ |line| line.chomp.length.should eq(first_size) }
   end
 
-  it "should request text input" do
-    @in.puts "bar"
-    @in.rewind
-    @ui.request("foo").should == "bar"
-    @out.string.should == "foo "
+  it "requests text input" do
+    ui_in.puts "bar"
+    ui_in.rewind
+    subject.request("foo").should == "bar"
+    ui_out.string.should == "foo "
   end
 
-  it "should ask for yes/no and return true when yes" do
-    @ui.should_receive(:request).with('foo? [yn] ').and_return('y')
-    @ui.ask("foo?").should be_true
+  it "asks for yes/no and return true when yes" do
+    subject.should_receive(:request).with('foo? [yn] ').and_return('y')
+    subject.ask("foo?").should be_true
   end
 
-  it "should ask for yes/no and return false when no" do
-    @ui.stub(:request).and_return('n')
-    @ui.ask("foo?").should be_false
+  it "asks for yes/no and return false when no" do
+    subject.stub(:request).and_return('n')
+    subject.ask("foo?").should be_false
   end
 
-  it "should ask for yes/no and return false for any input" do
-    @ui.stub(:request).and_return('aklhasdf')
-    @ui.ask("foo?").should be_false
+  it "asks for yes/no and return false for any input" do
+    subject.stub(:request).and_return('aklhasdf')
+    subject.ask("foo?").should be_false
   end
 
   describe "Non Windows Platform" do
@@ -78,32 +78,32 @@ describe Githug::UI do
       ENV.stub(:[]).with("OS").and_return(nil)
     end
 
-    it "should print out a success message in green" do
-      @ui.success("success")
-      @out.string.should eql("\033[32msuccess\033[0m\n")
+    it "prints out a success message in green" do
+      subject.success("success")
+      ui_out.string.should eql("\033[32msuccess\033[0m\n")
     end
 
-    it "should print out a error message in red" do
-      @ui.error("error")
-      @out.string.should eql("\033[31merror\033[0m\n")
+    it "prints out a error message in red" do
+      subject.error("error")
+      ui_out.string.should eql("\033[31merror\033[0m\n")
     end
 
   end
 
-  describe "Non Windows Platform" do
+  describe "Windows Platform" do
 
     before(:each) do
       ENV.stub(:[]).with("OS").and_return("Windows_NT")
     end
 
-    it "should print out a success message in white" do
-      @ui.success("success")
-      @out.string.should eql("success\n")
+    it "prints out a success message in white" do
+      subject.success("success")
+      ui_out.string.should eql("success\n")
     end
 
-    it "should print out a error message in white" do
-      @ui.error("error")
-      @out.string.should eql("error\n")
+    it "prints out a error message in white" do
+      subject.error("error")
+      ui_out.string.should eql("error\n")
     end
 
   end

data/spec/githug_spec.rb

@@ -14,6 +14,7 @@ end
 
 describe "The Game" do
 
+
   before(:all) do
     @dir = Dir.pwd
     `rake build`
@@ -28,12 +29,12 @@ describe "The Game" do
     Dir.chdir(@dir)
   end
 
-  it "should complete the init level" do
+  it "solves the init level" do
     `git init`
     `githug`.should be_solved
   end
 
-  it "should complete the config level" do
+  it "solves the config level" do
     skip_level #The CI server does not have git config set
     #full_name = `git config --get user.name`.chomp
     #email = `git config --get user.email`.chomp
@@ -43,93 +44,93 @@ describe "The Game" do
     #f.close
   end
 
-  it "should complete the add level" do
+  it "solves the add level" do
     `git add README`
     `githug`.should be_solved
   end
 
-  it "should complete the commit level" do
+  it "solves the commit level" do
     `git commit -m "test message"`
     `githug`.should be_solved
   end
 
-  it "should complete the clone level" do
+  it "solves the clone level" do
     `git clone https://github.com/Gazler/cloneme`
     `githug`.should be_solved
   end
 
-  it "should complete the clone_to_folder level" do
+  it "solves the clone_to_folder level" do
     `git clone https://github.com/Gazler/cloneme my_cloned_repo`
     `githug`.should be_solved
   end
 
-  it "should complete the ignore level" do
+  it "solves the ignore level" do
     `echo "*.swp" >> .gitignore`
     `githug`.should be_solved
   end
-  
-  it "should complete the include level" do
+
+  it "solves the include level" do
     `echo "*.a\n!lib.a" >> .gitignore`
     `githug`.should be_solved
   end
 
-  it "should complete the status level" do
+  it "solves the status level" do
     `git ls-files --other --exclude-standard | githug`.should be_solved
   end
 
-  it "should complete the number of files committed level" do
+  it "solves the number of files committed level" do
     `git diff --name-only --cached | wc -l | githug`.should be_solved
   end
 
-  it "should complete the rm level" do
+  it "solves the rm level" do
     file_name = `git status | grep deleted | cut -d " " -f 5`
     `git rm #{file_name}`
     `githug`.should be_solved
   end
 
-  it "should complete the rm cached level" do
+  it "solves the rm cached level" do
     file_name = `git status | grep "new file" | cut -d " " -f 5`
     `git rm --cached #{file_name}`
     `githug`.should be_solved
   end
 
-  it "should complete the stash level" do
+  it "solves the stash level" do
     `git stash save`
     `githug`.should be_solved
   end
 
-  it "should complete the rename level" do
+  it "solves the rename level" do
     `git mv oldfile.txt newfile.txt`
     `githug`.should be_solved
   end
 
-  it "should complete the restructure level" do
+  it "solves the restructure level" do
     `mkdir src`
     `git mv *.html src`
     `githug`.should be_solved
   end
 
-  it "should complete the log level" do
+  it "solves the log level" do
     `git log --pretty=short | grep commit | cut -c 8-14 | githug`.should be_solved
   end
 
-  it "should complete the tag level" do
+  it "solves the tag level" do
     `git tag new_tag`
     `githug`.should be_solved
   end
 
-  it "should complete the push_tags level" do
+  it "solves the push_tags level" do
     `git push origin master --tags`
     `githug`.should be_solved
   end
 
-  it "should complete the commit_amend level" do
+  it "solves the commit_amend level" do
     `git add forgotten_file.rb`
     `git commit --amend -C HEAD`
     `githug`.should be_solved
   end
 
-  it "should complete the commit_in_future level" do
+  it "solves the commit_in_future level" do
     authored_date = Time.now + 14
     authored_date = authored_date.rfc2822
 
@@ -137,85 +138,85 @@ describe "The Game" do
     `githug`.should be_solved
   end
 
-  it "should complete the reset level" do
+  it "solves the reset level" do
     `git reset HEAD to_commit_second.rb`
     `githug`.should be_solved
   end
 
-  it "should complete the reset_soft level" do
+  it "solves the reset_soft level" do
     `git reset --soft HEAD^`
     `githug`.should be_solved
   end
 
-  it "should complete the checkout_file level" do
+  it "solves the checkout_file level" do
     `git checkout -- config.rb`
     `githug`.should be_solved
   end
 
-  it "should complete the remove level" do
+  it "solves the remove level" do
     `git remote | githug`.should be_solved
   end
 
-  it "should complete the remote_url level" do
+  it "solves the remote_url level" do
     `git remote -v | tail -2 | head -1 | cut -c 17-52 | githug`.should be_solved
   end
 
-  it "should complete the pull level" do
+  it "solves the pull level" do
     `git pull origin master`
     `githug`.should be_solved
   end
 
-  it "should complete the remote_add level" do
+  it "solves the remote_add level" do
     `git remote add origin https://github.com/githug/githug`
     `githug`.should be_solved
   end
 
-  it "should complete the push level" do
+  it "solves the push level" do
     `git rebase origin/master`
     `git push origin`
     `githug`.should be_solved
   end
 
-  it "should complete the diff level" do
+  it "solves the diff level" do
     `echo "26" | githug`.should be_solved
   end
 
-  it "should complete the blame level" do
+  it "solves the blame level" do
     `echo "spider man" | githug`.should be_solved
   end
 
-  it "should complete the branch level" do
+  it "solves the branch level" do
     `git branch test_code`
     `githug`.should be_solved
   end
 
-  it "should complete the checkout level" do
+  it "solves the checkout level" do
     `git checkout -b my_branch`
     `githug`.should be_solved
   end
 
-  it "should complete the checkout_tag level" do
+  it "solves the checkout_tag level" do
     `git checkout v1.2`
     `githug`.should be_solved
   end
 
-  it "should complete the checkout_tag_over_branch level" do
+  it "solves the checkout_tag_over_branch level" do
     `git checkout tags/v1.2`
     `githug`.should be_solved
   end
 
-  it "should complete the branch_at level" do
+  it "solves the branch_at level" do
     commit = `git log HEAD~1 --pretty=short | head -1 | cut -d " " -f 2`
     `git branch test_branch #{commit}`
     `githug`.should be_solved
   end
 
-  it "should complete the delete_branch level" do
+  it "solves the delete_branch level" do
     `git branch -d delete_me`
     `githug`.should be_solved
   end
 
-  it "should complete the push_branch level" do
+  it "solves the push_branch level" do
     `git push origin test_branch`
     `githug`.should be_solved
   end
@@ -225,73 +226,79 @@ describe "The Game" do
     `githug`.should be_solved
   end
 
-  it "should complete the fetch level" do
+  it "solves the fetch level" do
     `git fetch`
     `githug`.should be_solved
   end
 
-  it "should complete the repack level" do
+  it "solves the rebase level" do
+    `git checkout feature`
+    `git rebase master`
+    `githug`.should be_solved
+  end
+
+  it "solves the repack level" do
     `git repack -d`
     `githug`.should be_solved
   end
 
-  it "should complete the cherry-pick level" do
+  it "solves the cherry-pick level" do
     commit = `git log new-feature --oneline  -n 3 | tail -1 | cut -d " " -f 1`
     `git cherry-pick #{commit}`
     `githug`.should be_solved
   end
 
-  it "should complete the grep level" do
+  it "solves the grep level" do
     `echo "4" | githug`.should be_solved
   end
 
-  it "should complete the rename_commit level" do
+  it "solves the rename_commit level" do
     skip_level
   end
 
-  it "should complete the squash level" do
+  it "solves the squash level" do
     skip_level
   end
 
-  it "should complete the merge squash level" do
+  it "solves the merge squash level" do
     `git merge --squash long-feature-branch`
     `git commit -m "Merged Long Feature Branch"`
     `githug`.should be_solved
   end
 
-  it "should complete the reorder level" do
+  it "solves the reorder level" do
     skip_level
   end
 
-  it "should complete the bisect level" do
+  it "solves the bisect level" do
     `echo "18ed2ac" | githug`.should be_solved
   end
 
-  it "should complete the stage_lines level" do
+  it "solves the stage_lines level" do
     skip_level
   end
 
-  it "should complete the find_old_branch level" do
+  it "solves the find_old_branch level" do
     `git checkout solve_world_hunger`
     `githug`.should be_solved
   end
 
-  it "should complete the revert level" do
+  it "solves the revert level" do
     sleep 1
     `git revert HEAD~1 --no-edit`
     `githug`.should be_solved
   end
 
-  it "should complete the restore level" do
+  it "solves the restore level" do
     `git reflog | grep "Restore this commit" | awk '{print $1}' | xargs git checkout`
     `githug`.should be_solved
   end
 
-  it "should complete the conflict level" do
+  it "solves the conflict level" do
     skip_level
   end
 
-  it "should complete the contribute level" do
+  it "solves the contribute level" do
     skip_level
   end