mygithug 0.5.1

data/spec/githug/game_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Githug::Game do
+
+  let(:profile) { mock(:level => 1,
+                       :current_attempts => 0).as_null_object }
+  let(:game) { Githug::Game.new }
+  let(:level) { mock(:full_description => nil, :setup_level => nil) }
+
+  before(:each) do
+    Githug::Profile.stub(:new).and_return(profile)
+    profile.stub(:save)
+    profile.stub(:level_bump)
+
+    Githug::UI.stub(:puts)
+
+    Githug::Level.stub(:load).and_return(level)
+  end
+
+  it "has a profile" do
+    game.profile.should eql(profile)
+  end
+
+  it "shows a description if the level is 0" do
+    level.should_not_receive(:solve)
+    profile.stub(:level).and_return(nil)
+    profile.should_receive(:level_bump)
+    Githug::UI.should_receive(:puts).with("Welcome to Githug!")
+    game.play_level
+  end
+
+  describe "play_level" do
+
+    it "outputs congratulations if the level is solved" do
+      level.stub(:solve).and_return(true)
+      profile.should_receive(:level_bump)
+      Githug::UI.should_receive(:success).with("Congratulations, you have solved the level!")
+      game.play_level
+    end
+
+    it "outputs a message if the solution is not right" do
+      level.stub(:solve).and_return(false)
+      Githug::UI.should_receive(:error).with("Sorry, this solution is not quite right!")
+      game.play_level
+    end
+
+    it "increments the number of failed attempts" do
+      level.stub(:solve).and_return(false)
+      profile.should_receive(:current_attempts=).with(1)
+      profile.should_receive(:save)
+      game.play_level
+    end
+
+    it "prompts for a hint if the user has failed 3 times." do
+      profile.stub(:current_attempts).and_return(3)
+      level.stub(:solve).and_return(false)
+      Githug::UI.should_receive(:error).with("Sorry, this solution is not quite right!")
+      Githug::UI.should_receive(:error).with("Don't forget you can type `githug hint` for a hint and `githug reset` to reset the current level.")
+      game.play_level
+    end
+
+  end
+
+
+  describe "test_level" do
+    it "outputs Valid solution if the solution is valid" do
+      level.stub(:solve).and_return(true)
+      Githug::UI.should_receive(:success).with("Valid solution")
+      game.test_level(level)
+    end
+
+    it "outputs Invalid solution if the solution is invalid" do
+      level.stub(:solve).and_return(false)
+      Githug::UI.should_receive(:error).with("Invalid solution")
+      game.test_level(level)
+    end
+
+    it "calls test when errors is true" do
+      level.should_receive(:test)
+      game.test_level(level, true)
+    end
+  end
+
+  it "outputs the description of the next level" do
+    level.should_receive(:full_description)
+    profile.stub(:level=)
+    game.level_bump
+  end
+
+  it "calls setup_level for the next level" do
+    level.should_receive(:setup_level)
+    profile.stub(:level=)
+    game.level_bump
+  end
+
+end

data/spec/githug/level_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+require 'grit'
+
+describe Githug::Level do
+
+  let(:subject) { Githug::Level.load_from_file(File.expand_path("spec/support/files/test_level.rb")) }
+  let(:repo) { mock(:reset) }
+
+  before(:each) do
+    Githug::Repository.stub(:new).and_return(repo)
+    Githug::UI.stub(:puts)
+    Githug::UI.stub(:print)
+  end
+
+  it "should mixin UI" do
+    Githug::Level.ancestors.should include(Githug::UI)
+  end
+
+  describe ".load" do
+
+    it "loads the level" do
+      File.stub(:dirname).and_return("")
+      Githug::Level.should_receive(:setup).with("/../../levels/init.rb")
+      Githug::Level.load("init")
+    end
+
+    it "returns false if the level does not exist" do
+      File.stub(:exists?).and_return(false)
+      Githug::Level.load(1).should eql(false)
+    end
+
+  end
+
+  describe ".list" do
+    it "lists the levels without nil" do
+      Githug::Level.list.should eql(Githug::Level::LEVELS - [nil])
+    end
+  end
+
+  describe ".load_from_file" do
+    it "loads the level" do
+      subject.instance_variable_get("@difficulty").should eql(1)
+      subject.instance_variable_get("@description").should eql("A test description")
+    end
+
+    it "return false if the level does not exist" do
+      File.stub(:exists?).and_return(false)
+      Githug::Level.load_from_file("/foo/bar/test/level.rb").should eql(false)
+    end
+  end
+
+  describe ".setup" do
+
+    it "returns false if the level does not exist" do
+      File.stub(:exists?).and_return(false)
+      Githug::Level.setup("/foo/bar/test/level.rb").should eql(false)
+    end
+
+  end
+
+
+  describe "#solve" do
+
+    it "returns false if the level requirements have not been met" do
+      subject.solve.should eql(false)
+    end
+
+    it "returns true if the level requirements have been met" do
+      Grit::Repo.stub(:new).and_return(true)
+      subject.solve.should eql(true)
+    end
+
+  end
+
+  describe "#test" do
+    it "calls solve" do
+      subject.should_receive(:_solution)
+      subject.test
+    end
+  end
+
+
+  describe "#full_description" do
+
+    it "displays a full description" do
+      Githug::UI.stub(:puts)
+      Githug::UI.should_receive(:puts).with("Level: 1")
+      Githug::UI.should_receive(:puts).with("Difficulty: *")
+      Githug::UI.should_receive(:puts).with("A test description")
+      subject.full_description
+    end
+
+  end
+
+  describe "#setup" do
+
+    it "calls setup" do
+      repo.should_receive(:reset)
+      subject.setup_level.should eql("test")
+    end
+
+    it "does not call the setup if none exists" do
+      subject.instance_variable_set("@setup", nil)
+      lambda {subject.setup_level}.should_not raise_error(NoMethodError)
+    end
+
+  end
+
+
+  describe "#repo" do
+
+    it "initializes a repository when repo is called" do
+      subject.repo.should equal(repo)
+      Githug::Repository.should_not_receive(:new)
+      subject.repo.should equal(repo)
+    end
+
+  end
+
+  describe "#hint" do
+
+    let(:profile) { mock.as_null_object }
+
+    before(:each) do
+      profile.stub(:current_hint_index).and_return(0,0,1,0)
+      Githug::Profile.stub(:load).and_return(profile)
+    end
+
+    it "returns sequential hint if there are multiple" do
+      subject.should_receive(:puts).ordered.with("this is hint 1")
+      subject.show_hint
+
+      subject.should_receive(:puts).ordered.with("this is hint 2")
+      subject.show_hint
+
+      subject.should_receive(:puts).ordered.with("this is hint 1")
+      subject.show_hint
+    end
+
+    it "displays a hint if there are not multiple" do
+      subject.instance_variable_set("@hints", nil)
+      subject.should_receive(:puts).with("this is a hint")
+      subject.show_hint
+    end
+
+    it "does not call the hint if none exist" do
+      subject.instance_variable_set("@hint", nil)
+      lambda {subject.show_hint}.should_not raise_error(NoMethodError)
+    end
+  end
+
+  describe "#init_from_level" do
+    it "copies the files from the level folder" do
+      FileUtils.should_receive(:cp_r).with("#{subject.level_path}/.", ".")
+      FileUtils.should_receive(:mv).with(".githug", ".git")
+      subject.init_from_level
+    end
+  end
+end

data/spec/githug/profile_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Githug::Profile do
+
+  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 "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 "allows method access to getters and setters" do
+    profile = Githug::Profile.load
+    profile.level.should eql(nil)
+    profile.level = 1
+    profile.level.should eql(1)
+  end
+
+  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
+
+    let(:profile) { Githug::Profile.load }
+
+    before(:each) do
+      profile.stub(:save)
+      @levels = Githug::Level::LEVELS
+      Githug::Level::LEVELS = ["init", "add", "rm", "rm_cached", "diff"]
+      profile.level = "init"
+    end
+
+    after(:each) do
+      Githug::Level::LEVELS = @levels
+    end
+
+    describe "#level_bump" do
+
+      it "bumps the level" do
+        profile.should_receive(:set_level).with("add")
+        profile.level_bump
+      end
+
+      it "resets the current_attempts" do
+        profile.current_attempts = 1
+        profile.level_bump
+        profile.current_attempts.should eql(0)
+      end
+
+      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
+
+      it "sets the level" do
+        profile.should_receive(:save)
+        profile.should_receive(:reset!)
+        profile.set_level("rm")
+        profile.settings[:level].should eql("rm")
+      end
+
+    end
+
+  end
+
+end

data/spec/githug/repository_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Githug::Repository do
+
+  let(:grit) { mock }
+
+  before(:each) do
+    Grit::Repo.stub(:new).and_return(grit)
+    subject.stub(:create_gitignore)
+  end
+
+  describe "#initialize" do
+
+    it "calls grit on initialize" do
+      Grit::Repo.should_receive(:new).with(".").and_return(grit)
+      repo = Githug::Repository.new
+      repo.grit.should equal(grit)
+    end
+
+    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 "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
+
+    before(:each) do
+      FileUtils.stub(:rm_rf)
+    end
+
+    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)
+      subject.reset
+    end
+
+    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")
+      subject.reset
+    end
+  end
+
+
+  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")
+      subject.create_gitignore
+    end
+  end
+
+  describe "#valid?" do
+    it "is valid if grit exists" do
+      subject.should be_valid
+    end
+
+    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 "does not add and commit gitignore if prompted" do
+      Grit::Repo.should_receive(:init).with(".")
+      subject.init
+    end
+  end
+
+  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 { subject.invalid_method }.should raise_error(NoMethodError)
+    end
+  end
+
+
+end

data/spec/githug/ui_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+require 'spec_helper'
+
+describe Githug::UI do
+
+  let(:ui_out) { StringIO.new }
+  let(:ui_in) { StringIO.new }
+
+  before(:each) do
+    subject.out_stream = ui_out
+    subject.in_stream = ui_in
+  end
+
+  it "puts to the stream" do
+    subject.puts("hello")
+    ui_out.string.should eql("hello\n")
+  end
+
+  it "prints an empty line with no arguments" do
+    subject.puts
+    ui_out.string.should eql("\n")
+  end
+
+  it "prints without a new line" do
+    subject.print("hello")
+    ui_out.string.should eql("hello")
+  end
+
+  it "fetches gets from input stream" do
+    ui_in.puts "bar"
+    ui_in.rewind
+    subject.gets.should == "bar\n"
+  end
+
+  it "makes a wordbox" do
+    word_box = <<-eof
+********************************************************************************
+*                                    Githug                                    *
+********************************************************************************
+    eof
+    subject.word_box("Githug")
+    ui_out.string.should eql(word_box)
+  end
+
+  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 "requests text input" do
+    ui_in.puts "bar"
+    ui_in.rewind
+    subject.request("foo").should == "bar"
+    ui_out.string.should == "foo "
+  end
+
+  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 "asks for yes/no and return false when no" do
+    subject.stub(:request).and_return('n')
+    subject.ask("foo?").should be_false
+  end
+
+  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
+    before(:each) do
+      ENV.stub(:[]).with("OS").and_return(nil)
+    end
+
+    it "prints out a success message in green" do
+      subject.success("success")
+      ui_out.string.should eql("\033[32msuccess\033[0m\n")
+    end
+
+    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 "Windows Platform" do
+
+    before(:each) do
+      ENV.stub(:[]).with("OS").and_return("Windows_NT")
+    end
+
+    it "prints out a success message in white" do
+      subject.success("success")
+      ui_out.string.should eql("success\n")
+    end
+
+    it "prints out a error message in white" do
+      subject.error("error")
+      ui_out.string.should eql("error\n")
+    end
+
+  end
+
+
+end