gitit 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d6eccd073e28fa27af29c78a39eea588380603d
-  data.tar.gz: bdb4ea6a45379dd2bfd0f8e59fd6b01efa869284
+  metadata.gz: 23fb8d00f8124e0bf2b40c92e825473c3382f0bb
+  data.tar.gz: 77d0f01adadb44f35b3d6754135d21a586afc492
 SHA512:
-  metadata.gz: e6145b556fde747538ae62b5491884790e22706a11149fb8812bb3bbcda4ad6f72d4c7fb1a2d743c351cba67c4188bb36026c5042ab7540d4bda2b4341deab7f
-  data.tar.gz: 8ffc989495d607f3c6e0f2fb0ed7bde73181822d50486c658d2d24ea322e9c108a9f9f999b471c9ce50f580f95055f78ace9f2358264970f3bf2a9066b4ca5e3
+  metadata.gz: a2b95bf891d1d1dbd989d64fdf74f064b886edb47f5a9b99f995d6da912fd3d68bb9b410ace57205e0a05e1484dd820e636675073cec07178833a54e234910a2
+  data.tar.gz: 3d86fd55e764cbcc4e471ebec1d0c2e06b461c8803c63953471587ee482d0abeda9ee0574820c24e0a18f54dc5e1954812d0d6a2593c1b70c0c925ed09e03c26

data/.idea/dictionaries/pat.xml

@@ -0,0 +1,19 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="pat">
+    <words>
+      <w>adsdsadasdsa</w>
+      <w>badorigin</w>
+      <w>bdssdsoo</w>
+      <w>dsaadk</w>
+      <w>gitit</w>
+      <w>mybranch</w>
+      <w>mytestkey</w>
+      <w>uncommit</w>
+      <w>uncommited</w>
+      <w>unstage</w>
+      <w>unstaged</w>
+      <w>untracked</w>
+      <w>withsub</w>
+    </words>
+  </dictionary>
+</component>

data/VERSION

@@ -1 +1 @@
-0.7.0
+1.0.0

data/lib/gitit/command_branch.rb

@@ -1,4 +1,4 @@
-require "gitit/command_executor"
+require 'gitit/command_executor'
 
 module Gitit
 
@@ -19,9 +19,8 @@ module Gitit
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
     def valid?
-      executeCommand("diff --cached --no-ext-diff --ignore-submodules --quiet --exit-code")
-      return true if $?.exitstatus == 1
-      return false
+      execute_command('diff --cached --no-ext-diff --ignore-submodules --quiet --exit-code')
+      $?.exitstatus == 1
     end
     
   end

data/lib/gitit/command_branches.rb

@@ -1,4 +1,4 @@
-require "gitit/command_executor"
+require 'gitit/command_executor'
 
 module Gitit
 
@@ -15,42 +15,46 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def existsLocally?(name)
-      executeCommand("branch --no-color | sed 's/^[* ] //' | grep #{name}")
-      return true if $?.exitstatus == 0
-      return false
+    def get_current_branch
+      branches = execute_command('branch --no-color')
+      branch_match = branches.each_line.select { |b| b.start_with? '* ' }
+      branch_match[0].strip.gsub(/\* /, '')
+    end
+
+    # -------------------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    def exists_locally?(name)
+      execute_command("branch --no-color | sed 's/^[* ] //' | grep #{name}")
+      $?.exitstatus == 0
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def existsRemotely?(name, remote)
-      executeCommand("branch -r --no-color | sed 's/^[* ] //' | grep #{remote}/#{name}")
-      return true if $?.exitstatus == 0
-      return false
+    def exists_remotely?(name, remote)
+      execute_command("branch -r --no-color | sed 's/^[* ] //' | grep #{remote}/#{name}")
+      $?.exitstatus == 0
     end
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def createLocalBranch(name)
-      executeCommand("branch --quiet #{name}")
-      return true if $?.exitstatus == 0
-      return false
+    def create_local_branch(name)
+      execute_command("branch --quiet #{name}")
+      $?.exitstatus == 0
     end
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def pushLocalBranchToRemote(name, remote, force)
-      executeCommand("push --quiet -f #{remote} #{name}") if force
-      executeCommand("push --quiet #{remote} #{name}") unless force
-      return true if $?.exitstatus == 0
-      return false
+    def push_local_branch_to_remote(name, remote, force)
+      execute_command("push --quiet -f #{remote} #{name}") if force
+      execute_command("push --quiet #{remote} #{name}") unless force
+      $?.exitstatus == 0
     end
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def updateFromRemote(branchName, remote)
+    #def update_from_remote(branch_name, remote)
 
-    end
+    #end
     
   end
 

data/lib/gitit/command_config.rb

@@ -1,4 +1,4 @@
-require "gitit/command_executor"
+require 'gitit/command_executor'
 
 module Gitit
 
@@ -9,45 +9,47 @@ module Gitit
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def initialize(repo)
+    def initialize(repo, location='')
       @repo = repo
+      @location = location
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def getValue(key)
-      value = executeCommand("config --null --get #{key}")
-      raise "failure running command" if $?.exitstatus != 0
-      value = value.slice!(0, value.length-1)
-      return value
+    def get_value(key)
+      value = execute_command("config #{@location} --null --get #{key}")
+      raise 'failure running command' if $?.exitstatus != 0
+      value.slice!(0, value.length-1)
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def setValue(key, value)
+    def set_value(key, value)
       val = value
-      executeCommand("config \"#{key}\" \"#{val}\"")
-      raise "failure running command" if $?.exitstatus != 0
+      execute_command("config #{@location} \"#{key}\" \"#{val}\"")
+      raise 'failure running command' if $?.exitstatus != 0
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def getGlobalValue(key)
-      value = executeCommand("config --global --null --get #{key}")
-      raise "failure running command" if $?.exitstatus != 0
-      value = value.slice!(0, value.length-1)
-      return value
+    def unset_value(key)
+      execute_command("config #{@location} --null --unset #{key}")
+      raise 'failure running command' if $?.exitstatus != 0
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def setGlobalValue(key, value)
-      val = value
-      executeCommand("config --global \"#{key}\" \"#{val}\"")
-      raise "failure running command" if $?.exitstatus != 0
+    def remove_section(section)
+      execute_command("config #{@location} --remove-section #{section}")
+      raise 'failure running command' if $?.exitstatus != 0
     end
     
   end
 
+  class LocalConfig
+  end
+
+  class GlobalConfig
+  end
 
 end

data/lib/gitit/command_executor.rb

@@ -5,10 +5,9 @@ module Gitit
 
     attr_reader :repo
 
-    def executeCommand(command)
-      gitCommand = ["git", command].join(" ")
-      result = `(cd #{@repo.location} && #{gitCommand})`
-      return result
+    def execute_command(command)
+      gitCommand = ['git', command].join(' ')
+      `(cd #{@repo.location} && #{gitCommand} 2>&1)`
     end
 
   end

data/lib/gitit/command_status.rb

@@ -1,4 +1,4 @@
-require "gitit/command_executor"
+require 'gitit/command_executor'
 
 module Gitit
 
@@ -16,35 +16,32 @@ module Gitit
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
     def clean?
-      return !unstagedFiles? && !uncommitedFiles? && !untrackedFiles?
+      !unstaged_files? && !uncommited_files? && !untracked_files?
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def unstagedFiles?
-      executeCommand("diff-files --name-status --diff-filter=M --exit-code")
-      return true if $?.exitstatus == 1
-      return false
+    def unstaged_files?
+      execute_command('diff-files --name-status --diff-filter=M --exit-code')
+      $?.exitstatus == 1
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def uncommitedFiles?
-      executeCommand("diff --cached --no-ext-diff --ignore-submodules --quiet --exit-code")
-      return true if $?.exitstatus == 1
-      return false
+    def uncommited_files?
+      execute_command('diff --cached --no-ext-diff --ignore-submodules --quiet --exit-code')
+      $?.exitstatus == 1
     end
     
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    def untrackedFiles?
-      gitRes = executeCommand("status --porcelain | grep ??")
-      return true if $?.exitstatus == 0
-      return false
+    def untracked_files?
+      execute_command('status --porcelain | grep ??')
+      $?.exitstatus == 0
     end
     
   end
 
-
 end
 
+

data/lib/gitit/git.rb

@@ -1,7 +1,7 @@
-require "gitit"
-require "gitit/repo"
+require 'gitit'
+require 'gitit/repo'
 
-Dir[File.dirname(__FILE__) + "/command_*.rb"].each do |file|
+Dir[File.dirname(__FILE__) + '/command_*.rb'].each do |file|
   require file
 end
 
@@ -10,10 +10,10 @@ module Gitit
   # ---------------------------------------------------------------------------
   # ---------------------------------------------------------------------------
   class Git
-    attr_reader :repo;
-    attr_reader :config;
-    attr_reader :status;
-    attr_reader :branches;
+    attr_reader :repo
+    attr_reader :config
+    attr_reader :status
+    attr_reader :branches
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------

data/lib/gitit/repo.rb

@@ -1,4 +1,4 @@
-require "gitit"
+require 'gitit'
 
 module Gitit
     
@@ -10,23 +10,22 @@ module Gitit
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
     def initialize(location)
-      raise "Invalid path specified" unless File.directory? location
+      raise 'Invalid path specified' unless File.directory? location
       @location = location
     end
   
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
     def valid?
-      commandres = `(cd #{@location} && git rev-parse --git-dir >/dev/null 2>&1)`
-      return true unless $?.exitstatus != 0 
-      return false
+      `(cd #{@location} && git rev-parse --git-dir >/dev/null 2>&1)`
+      $?.exitstatus == 0
     end
   
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
     def init
-      raise "already a git repo" if valid?
-      commandres = `(cd #{@location} && git init)`
+      raise 'already a git repo' if valid?
+      `(cd #{@location} && git init)`
     end
   end
     

data/lib/gitit/version.rb

@@ -1,3 +1,3 @@
 module Gitit
-  VERSION = "0.1.1"
+  VERSION = '0.1.1'
 end

data/lib/gitit.rb

@@ -1,5 +1,5 @@
-require "gitit/version"
-require "gitit/git"
+require 'gitit/version'
+require 'gitit/git'
 
 module Gitit
 end

data/spec/gitit_branch_spec.rb

@@ -6,17 +6,17 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    describe "#testRepoBranch" do
+    describe '#test_repo_branch' do
 
       before(:each) do
         FileUtils.mkpath TEST_REPO_PATH
         git = Git.new(TEST_REPO_PATH)
-        @myRepo = git.repo
-        @myRepo.init
-        @repoBranch = Gitit::Branch.new(@myRepo, "master")
+        @my_repo = git.repo
+        @my_repo.init
+        @repoBranch = Gitit::Branch.new(@my_repo, 'master')
       end
 
-      it "will tell us if the branch is a valid branch" do
+      it 'will tell us if the branch is a valid branch' do
       end
 
       after(:each) do

data/spec/gitit_branches_spec.rb

@@ -6,13 +6,13 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    describe "#testBranchesExistance" do
+    describe '#test_branches_existance' do
 
       before(:each) do
         FileUtils.mkpath TEST_REPO_PATH
         git = Git.new(TEST_REPO_PATH)
-        @myRepo = git.repo
-        @myRepo.init
+        @my_repo = git.repo
+        @my_repo.init
         @repoBranches = git.branches
 
         `(cd #{TEST_REPO_PATH} && git config user.email "you@example.com")`
@@ -27,20 +27,25 @@ module Gitit
 
       end
 
-      it "will successfully find a valid local branch" do
-        @repoBranches.existsLocally?("master").should eq true
+      it 'will successfully find a valid local branch' do
+        @repoBranches.exists_locally?('master').should eq true
       end
 
-      it "will fail to find an invalid local branch" do
-        @repoBranches.existsLocally?("asdasdsad").should eq false
+      it 'will fail to find an invalid local branch' do
+        @repoBranches.exists_locally?('some_random_name').should eq false
       end
 
-      it "will successfully find a valid remote branch" do
-        @repoBranches.existsRemotely?("master", "origin").should eq true
+      it 'will successfully find a valid remote branch' do
+        @repoBranches.exists_remotely?('master', 'origin').should eq true
       end
 
-      it "will fail to find an invalid remote branch" do
-        @repoBranches.existsRemotely?("asdasdsad", "origin").should eq false
+      it 'will fail to find an invalid remote branch' do
+        @repoBranches.exists_remotely?('some_random_name', 'origin').should eq false
+      end
+
+      it 'will successfully return the right branch name' do
+        `(cd #{TEST_REPO_PATH} && git checkout master --quiet)`
+        @repoBranches.get_current_branch.should eq 'master'
       end
 
       after(:each) do
@@ -52,13 +57,13 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    describe "#testBranchCreationLocally" do
+    describe '#testBranchCreationLocally' do
 
       before(:each) do
         FileUtils.mkpath TEST_REPO_PATH
         git = Git.new(TEST_REPO_PATH)
-        @myRepo = git.repo
-        @myRepo.init
+        @my_repo = git.repo
+        @my_repo.init
         @repoBranches = git.branches
 
         File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
@@ -70,36 +75,36 @@ module Gitit
 
       end
     
-      it "will fail to create a local branch" do
-        @repoBranches.createLocalBranch("mybranch").should eq true
-        @repoBranches.createLocalBranch("mybranch").should eq false
+      it 'will fail to create a local branch' do
+        @repoBranches.create_local_branch('mybranch').should eq true
+        @repoBranches.create_local_branch('mybranch').should eq false
       end
 
-      it "will create a local branch successfully" do
-        @repoBranches.createLocalBranch("mybranch").should eq true
-        @repoBranches.existsLocally?("mybranch").should eq true
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq false
+      it 'will create a local branch successfully' do
+        @repoBranches.create_local_branch('mybranch').should eq true
+        @repoBranches.exists_locally?('mybranch').should eq true
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq false
       end
 
-      it "will fail to push a local branch to an invalid remote" do
-        @repoBranches.createLocalBranch("mybranch").should eq true
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq false
-        @repoBranches.pushLocalBranchToRemote("mybranch", "badorigin", false).should eq false        
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq false
+      it 'will fail to push a local branch to an invalid remote' do
+        @repoBranches.create_local_branch('mybranch').should eq true
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq false
+        @repoBranches.push_local_branch_to_remote('mybranch', 'badorigin', false).should eq false
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq false
       end
 
-      it "will push a local branch to the remote not forcing it" do
-        @repoBranches.createLocalBranch("mybranch").should eq true
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq false
-        @repoBranches.pushLocalBranchToRemote("mybranch", "origin", false).should eq true        
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq true
+      it 'will push a local branch to the remote not forcing it' do
+        @repoBranches.create_local_branch('mybranch').should eq true
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq false
+        @repoBranches.push_local_branch_to_remote('mybranch', 'origin', false).should eq true
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq true
       end
 
-      it "will push a local branch to the remote forcing it" do
-        @repoBranches.createLocalBranch("mybranch").should eq true
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq false
-        @repoBranches.pushLocalBranchToRemote("mybranch", "origin", true).should eq true        
-        @repoBranches.existsRemotely?("mybranch", "origin").should eq true
+      it 'will push a local branch to the remote forcing it' do
+        @repoBranches.create_local_branch('mybranch').should eq true
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq false
+        @repoBranches.push_local_branch_to_remote('mybranch', 'origin', true).should eq true
+        @repoBranches.exists_remotely?('mybranch', 'origin').should eq true
       end
 
       after(:each) do

data/spec/gitit_config_spec.rb

@@ -1,50 +1,73 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-#require "gitit"
 
 module Gitit
 
   describe Config do
 
-    # -------------------------------------------------------------------------
-    # -------------------------------------------------------------------------
-    describe "#Config" do
-
-      KEY_NAME = "mytest.bla"
-      KEY_VALUE = "osd aas as dsaadk".force_encoding("UTF-8")
-
-      before(:each) do
-        FileUtils.mkpath TEST_REPO_PATH
-        @git = Git.new(TEST_REPO_PATH)
-        @git.repo.init
-        @config = @git.config
-      end
-    
-      it "will set the specified local value successfully" do
-        lambda{@config.setValue(KEY_NAME, KEY_VALUE)}.should_not raise_error
-      end
-      
-      it "will retrieve the specified local value successfully" do
-        value = ""
-        lambda{@config.setValue(KEY_NAME, KEY_VALUE)}.should_not raise_error
-        lambda{value = @config.getValue(KEY_NAME)}.should_not raise_error
-        value.should eq KEY_VALUE
-      end
-
-      it "will set the specified global value successfully" do
-        lambda{@config.setGlobalValue(KEY_NAME, KEY_VALUE)}.should_not raise_error
-      end
+    # -----------------------------------------------------------------------------
+    # -----------------------------------------------------------------------------
+    ['--local', '--global', '--file /tmp/foo'].each { |mode|
+
+      # ---------------------------------------------------------------------------
+      # ---------------------------------------------------------------------------
+      %w(mytestkey mytestkey.withsub).each {|key_section|
       
-      it "will retrieve the specified global value successfully" do
-        value = ""
-        lambda{@config.setGlobalValue(KEY_NAME, KEY_VALUE)}.should_not raise_error
-        lambda{value = @config.getGlobalValue(KEY_NAME)}.should_not raise_error
-        value.should eq KEY_VALUE
-      end
-
-      after(:each) do
-        FileUtils.rm_rf TEST_REPO_PATH
-      end
-
-    end
+        # -------------------------------------------------------------------------
+        # -------------------------------------------------------------------------
+        describe "#TestConfig #{mode} with key_section #{key_section}" do
+
+          before(:each) do
+            FileUtils.mkpath TEST_REPO_PATH
+            @git = Git.new(TEST_REPO_PATH)
+            @git.repo.init
+            @config = Config.new(@git.repo, mode)
+
+            @key_name = 'bla'
+            @key = key_section + '.' + @key_name
+            @key_value = 'osd aas as dsaadk'.force_encoding('UTF-8')
+
+          end
+        
+          it 'will set the specified key to the specified value successfully' do
+            lambda{@config.set_value(@key, @key_value)}.should_not raise_error
+
+            `(git config #{mode} --unset #{@key})`
+            `(cd #{TEST_REPO_PATH} && git config #{mode} --remove-section #{key_section})`
+          end
+          
+          it 'will retrieve the specified value successfully' do
+            value = ''
+            lambda{@config.set_value(@key, @key_value)}.should_not raise_error
+            lambda{value = @config.get_value(@key)}.should_not raise_error
+            value.should eq @key_value
+
+            `(git config #{mode} --unset #{@key})`
+            `(cd #{TEST_REPO_PATH} && git config #{mode} --remove-section #{key_section})`
+          end
+
+          it 'will unset the specified key successfully' do
+            lambda{@config.set_value(@key, @key_value)}.should_not raise_error
+            lambda{@config.unset_value(@key)}.should_not raise_error
+            lambda{@config.get_value(@key)}.should raise_error
+
+            `(cd #{TEST_REPO_PATH} && git config #{mode} --remove-section #{key_section})`
+          end
+          
+          it 'will remove the specified section successfully' do
+            lambda{@config.set_value(@key, @key_value)}.should_not raise_error
+            lambda{@config.unset_value(@key)}.should_not raise_error
+            lambda{@config.remove_section(key_section)}.should_not raise_error
+            lambda{@config.get_value(@key)}.should raise_error
+          end
+          
+          after(:each) do
+            FileUtils.rm_rf TEST_REPO_PATH
+          end
+
+        end
+
+      }
+    }
+
   end
 end

data/spec/gitit_spec.rb

@@ -6,30 +6,30 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    describe "#initialize" do
+    describe '#initialize' do
 
-      TMP_PATH = "/tmp/"
-      BAD_PATH = "/adsdsadasdsa"
-      TEST_REPO_PATH = "/tmp/test_git"
-      TEST_REPO_PATH_BARE = "/tmp/test_git_bare"
+      TMP_PATH = '/tmp/'
+      BAD_PATH = '/adsdsadasdsa'
+      TEST_REPO_PATH = '/tmp/test_git'
+      TEST_REPO_PATH_BARE = '/tmp/test_git_bare'
     
       before(:each) do
       end
 
-      it "will open fine given a valid repo" do
+      it 'will open fine given a valid repo' do
         lambda{Git.new(Dir.pwd)}.should_not raise_error
       end
 
-      it "will throw an error given an invalid repo" do
+      it 'will throw an error given an invalid repo' do
         lambda{Git.new(BAD_PATH)}.should raise_error
       end
 
-      it "will return true on valid repo" do
+      it 'will return true on valid repo' do
         myRepo = Git.new(Dir.pwd).repo
         myRepo.valid?.should eq true 
       end
 
-      it "will return false on invalid repo" do
+      it 'will return false on invalid repo' do
         myRepo = Git.new(TMP_PATH).repo
         myRepo.valid?.should eq false
       end
@@ -38,24 +38,24 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    describe "#initNewRepo" do
+    describe '#initNewRepo' do
 
       before(:each) do
         FileUtils.mkpath TEST_REPO_PATH
         git = Git.new(TEST_REPO_PATH)
-        @myRepo = git.repo
+        @my_repo = git.repo
       end
     
-      it "will initialize a new repo on an existing folder" do
-        @myRepo.valid?.should eq false
-        lambda{@myRepo.init}.should_not raise_error
+      it 'will initialize a new repo on an existing folder' do
+        @my_repo.valid?.should eq false
+        lambda{@my_repo.init}.should_not raise_error
       end
 
-      it "will fail to initialize a new repo on an existing folder already initialized" do
-        @myRepo.valid?.should eq false
-        lambda{@myRepo.init}.should_not raise_error
-        @myRepo.valid?.should eq true
-        lambda{@myRepo.init}.should raise_error
+      it 'will fail to initialize a new repo on an existing folder already initialized' do
+        @my_repo.valid?.should eq false
+        lambda{@my_repo.init}.should_not raise_error
+        @my_repo.valid?.should eq true
+        lambda{@my_repo.init}.should raise_error
       end
 
       after(:each) do

data/spec/gitit_status_spec.rb

@@ -7,75 +7,75 @@ module Gitit
 
     # -------------------------------------------------------------------------
     # -------------------------------------------------------------------------
-    describe "#testRepoStatus" do
+    describe '#testRepoStatus' do
 
       before(:each) do
         FileUtils.mkpath TEST_REPO_PATH
         git = Git.new(TEST_REPO_PATH)
-        @myRepo = git.repo
-        @myRepo.init
-        @repoStatus = git.status
+        @my_repo = git.repo
+        @my_repo.init
+        @repo_status = git.status
 
         `(cd #{TEST_REPO_PATH} && git config user.email "you@example.com")`
         `(cd #{TEST_REPO_PATH} && git config user.name "example")`
 
       end
     
-      it "will tell us that the current branch is clean when nothing has been changed" do
-        @repoStatus.clean?.should eq true
+      it 'will tell us that the current branch is clean when nothing has been changed' do
+        @repo_status.clean?.should eq true
       end
 
-      it "will tell us that the current branch is not clean when there are untracked file" do
-        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
-        @repoStatus.untrackedFiles?.should eq true
-        @repoStatus.unstagedFiles?.should eq false
-        @repoStatus.uncommitedFiles?.should eq false
-        @repoStatus.clean?.should eq false
+      it 'will tell us that the current branch is not clean when there are untracked file' do
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w+') { |file| file.write('boo!') }
+        @repo_status.untracked_files?.should eq true
+        @repo_status.unstaged_files?.should eq false
+        @repo_status.uncommited_files?.should eq false
+        @repo_status.clean?.should eq false
       end
 
-      it "will tell us that the current branch is not clean when there are unstaged file" do
-        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
+      it 'will tell us that the current branch is not clean when there are unstaged file' do
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w+') { |file| file.write('boo!') }
         `(cd #{TEST_REPO_PATH} && git add #{TEST_REPO_PATH}/out.txt)`
         `(cd #{TEST_REPO_PATH} && git commit -am "wip")`
-        File.open("#{TEST_REPO_PATH}/out.txt", "w") { |file| file.write("bdssdsoo!") }
-        @repoStatus.untrackedFiles?.should eq false
-        @repoStatus.unstagedFiles?.should eq true
-        @repoStatus.uncommitedFiles?.should eq false
-        @repoStatus.clean?.should eq false
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w') { |file| file.write('bdssdsoo!') }
+        @repo_status.untracked_files?.should eq false
+        @repo_status.unstaged_files?.should eq true
+        @repo_status.uncommited_files?.should eq false
+        @repo_status.clean?.should eq false
       end
 
-      it "will tell us that the current branch is not clean when there are uncommited file" do
-        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
+      it 'will tell us that the current branch is not clean when there are uncommited file' do
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w+') { |file| file.write('boo!') }
         `(cd #{TEST_REPO_PATH} && git add #{TEST_REPO_PATH}/out.txt)`
         `(cd #{TEST_REPO_PATH} && git commit -am "wip")`
-        File.open("#{TEST_REPO_PATH}/out.txt", "w") { |file| file.write("bdssdsoo!") }
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w') { |file| file.write('bdssdsoo!') }
         `(cd #{TEST_REPO_PATH} && git add #{TEST_REPO_PATH}/out.txt)`
-        @repoStatus.untrackedFiles?.should eq false
-        @repoStatus.unstagedFiles?.should eq false
-        @repoStatus.uncommitedFiles?.should eq true
-        @repoStatus.clean?.should eq false
+        @repo_status.untracked_files?.should eq false
+        @repo_status.unstaged_files?.should eq false
+        @repo_status.uncommited_files?.should eq true
+        @repo_status.clean?.should eq false
       end
 
-      it "will tell us that there are untracked files after adding a new file" do
-        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
-        @repoStatus.untrackedFiles?.should eq true
+      it 'will tell us that there are untracked files after adding a new file' do
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w+') { |file| file.write('boo!') }
+        @repo_status.untracked_files?.should eq true
       end
 
-      it "will tell us that there are unstage files after modifying a file" do
-        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
+      it 'will tell us that there are unstage files after modifying a file' do
+        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write('boo!') }
         `(cd #{TEST_REPO_PATH} && git add #{TEST_REPO_PATH}/out.txt)`
         `(cd #{TEST_REPO_PATH} && git commit -am "wip")`
-        File.open("#{TEST_REPO_PATH}/out.txt", "w") { |file| file.write("bdssdsoo!") }
-        @repoStatus.unstagedFiles?.should eq true
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w') { |file| file.write('bdssdsoo!') }
+        @repo_status.unstaged_files?.should eq true
       end
 
-      it "will tell us if there are uncommit files after adding a modifiled file to staging" do
-        File.open("#{TEST_REPO_PATH}/out.txt", "w+") { |file| file.write("boo!") }
+      it 'will tell us if there are uncommit files after adding a modified file to staging' do
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w+') { |file| file.write('boo!') }
         `(cd #{TEST_REPO_PATH} && git add #{TEST_REPO_PATH}/out.txt)`
         `(cd #{TEST_REPO_PATH} && git commit -am "wip")`
-        File.open("#{TEST_REPO_PATH}/out.txt", "w") { |file| file.write("bdssdsoo!") }
+        File.open("#{TEST_REPO_PATH}/out.txt", 'w') { |file| file.write('bdssdsoo!') }
         `(cd #{TEST_REPO_PATH} && git add #{TEST_REPO_PATH}/out.txt)`
-        @repoStatus.uncommitedFiles?.should eq true
+        @repo_status.uncommited_files?.should eq true
       end
 
       after(:each) do

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-if ENV["COVERAGE"] == 'yes'
+if ENV['COVERAGE'] == 'yes'
   require 'simplecov'
   SimpleCov.start
 end
@@ -13,5 +13,18 @@ require 'gitit'
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  
+  original_stderr = $stderr
+  original_stdout = $stdout
+  config.before(:all) do 
+    # Redirect stderr and stdout
+    $stderr = File.new(File.join(File.dirname(__FILE__), 'null.txt'), 'w')
+    $stdout = File.new(File.join(File.dirname(__FILE__), 'null.txt'), 'w')
+    `git config --global user.email "you@example.com"`
+    `git config --global user.name "Your Name"`
+  end
+  config.after(:all) do 
+    $stderr = original_stderr
+    $stdout = original_stdout
+  end
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitit
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Pat Laplante
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-11 00:00:00.000000000 Z
+date: 2014-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -131,6 +131,7 @@ extra_rdoc_files: []
 files:
 - .document
 - .gitignore
+- .idea/dictionaries/pat.xml
 - .rspec
 - .travis.yml
 - Gemfile