zenflow 0.8.0

data/spec/zenflow/helpers/branch_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe Zenflow::Branch do
+  describe 'self.list' do
+    context "when the prefix has no branches" do
+      before do
+        Zenflow::Shell.should_receive(:run).with("git branch | grep features", :silent => true).and_return("")
+      end
+
+      it "indicates there are no branches" do
+        expect(Zenflow::Branch.list('features')).to eq(['!! NONE !!'])
+      end
+    end
+
+    context "when the prefix has branches" do
+      before do
+        Zenflow::Shell.should_receive(:run).with("git branch | grep features", :silent => true).and_return("  feature/test_zenflow\n* feature/refactor_zenflow\n")
+      end
+
+      it "indicates there are no branches" do
+        expect(Zenflow::Branch.list('features')).to eq(["  feature/test_zenflow", "* feature/refactor_zenflow"])
+      end
+    end
+  end
+
+  describe "self.current" do
+    context "when the current branch doesn't match the prefix" do
+      before do
+        Zenflow::Shell.should_receive(:run).with("git branch | grep '* feature'", :silent => true).and_return("")
+      end
+
+      it "returns nil" do
+        expect(Zenflow::Branch.current('feature')).to be_nil
+      end
+    end
+
+    context "when the current branch matches the prefix" do
+      before do
+        Zenflow::Shell.should_receive(:run).with("git branch | grep '* feature'", :silent => true).and_return("* feature/test-current-branch\n")
+      end
+
+      it "returns returns the branch name" do
+        expect(Zenflow::Branch.current('feature')).to eq('test-current-branch')
+      end
+    end
+  end
+
+  describe "self.update" do
+    it "updates the branch" do
+      Zenflow.should_receive(:Log).with("Updating the master branch")
+      Zenflow::Shell.should_receive(:run).with("git checkout master && git pull")
+      Zenflow::Branch.update('master')
+    end
+  end
+
+  describe "self.create" do
+    it "updates the branch" do
+      Zenflow.should_receive(:Log).with("Creating the feature/test-branch-creation branch based on master")
+      Zenflow::Shell.should_receive(:run).with("git checkout -b feature/test-branch-creation master")
+      Zenflow::Branch.create('feature/test-branch-creation', 'master')
+    end
+  end
+
+  describe "self.push" do
+    after(:each) do
+      Zenflow::Config[:remote] = 'origin'
+      Zenflow::Config[:backup_remote] = false
+    end
+
+    context "when a remote is configured" do
+      before do
+        Zenflow::Config[:remote] = 'some-remote'
+      end
+
+      it 'pushes to the configured remote' do
+        Zenflow.should_receive(:Log).with("Pushing the feature/test-pushing branch to some-remote")
+        Zenflow::Shell.should_receive(:run).with("git push some-remote feature/test-pushing")
+        Zenflow::Branch.push('feature/test-pushing')
+      end
+    end
+
+    context "when a remote is not configured" do
+      it 'pushes to the origin' do
+        Zenflow.should_receive(:Log).with("Pushing the feature/test-pushing branch to origin")
+        Zenflow::Shell.should_receive(:run).with("git push origin feature/test-pushing")
+        Zenflow::Branch.push('feature/test-pushing')
+      end
+    end
+
+    context "when a backup remote is not configured" do
+      it "pushes to the primary remote and then pushes to the backup remote" do
+        Zenflow.should_receive(:Log).with("Pushing the feature/test-pushing branch to origin")
+        Zenflow::Shell.should_receive(:run).with("git push origin feature/test-pushing")
+        Zenflow.should_not_receive(:Log).with("Pushing the feature/test-pushing branch to backup-remote")
+        Zenflow::Shell.should_not_receive(:run).with("git push backup-remote feature/test-pushing")
+        Zenflow::Branch.push('feature/test-pushing')
+      end
+    end
+
+    context "when a backup remote is configured" do
+      before do
+        Zenflow::Config[:backup_remote] = 'backup-remote'
+      end
+
+      it "pushes to the primary remote and then pushes to the backup remote" do
+        Zenflow.should_receive(:Log).with("Pushing the feature/test-pushing branch to origin")
+        Zenflow::Shell.should_receive(:run).with("git push origin feature/test-pushing")
+        Zenflow.should_receive(:Log).with("Pushing the feature/test-pushing branch to backup-remote")
+        Zenflow::Shell.should_receive(:run).with("git push backup-remote feature/test-pushing")
+        Zenflow::Branch.push('feature/test-pushing')
+      end
+    end
+  end
+
+  describe "self.push_tags" do
+    after(:each) do
+      Zenflow::Config[:remote] = 'origin'
+      Zenflow::Config[:backup_remote] = false
+    end
+
+    context "when a remote is configured" do
+      before do
+        Zenflow::Config[:remote] = 'some-remote'
+      end
+
+      it 'pushes to the configured remote' do
+        Zenflow.should_receive(:Log).with("Pushing tags to some-remote")
+        Zenflow::Shell.should_receive(:run).with("git push some-remote --tags")
+        Zenflow::Branch.push_tags
+      end
+    end
+
+    context "when a remote is not configured" do
+      it 'pushes to the origin' do
+        Zenflow.should_receive(:Log).with("Pushing tags to origin")
+        Zenflow::Shell.should_receive(:run).with("git push origin --tags")
+        Zenflow::Branch.push_tags
+      end
+    end
+
+    context "when a backup remote is not configured" do
+      it "pushes to the primary remote and then pushes to the backup remote" do
+        Zenflow.should_receive(:Log).with("Pushing tags to origin")
+        Zenflow::Shell.should_receive(:run).with("git push origin --tags")
+        Zenflow.should_not_receive(:Log).with("Pushing tags to backup-remote")
+        Zenflow::Shell.should_not_receive(:run).with("git push backup-remote --tags")
+        Zenflow::Branch.push_tags
+      end
+    end
+
+    context "when a backup remote is configured" do
+      before do
+        Zenflow::Config[:backup_remote] = 'backup-remote'
+      end
+
+      it "pushes to the primary remote and then pushes to the backup remote" do
+        Zenflow.should_receive(:Log).with("Pushing tags to origin")
+        Zenflow::Shell.should_receive(:run).with("git push origin --tags")
+        Zenflow.should_receive(:Log).with("Pushing tags to backup-remote")
+        Zenflow::Shell.should_receive(:run).with("git push backup-remote --tags")
+        Zenflow::Branch.push_tags
+      end
+    end
+  end
+
+  describe "self.track" do
+    after(:each) do
+      Zenflow::Config[:remote] = 'origin'
+    end
+
+    context "when a remote is configured" do
+      before do
+        Zenflow::Config[:remote] = 'some-remote'
+      end
+
+      it "tracks the branch in that remote" do
+        Zenflow.should_receive(:Log).with("Tracking the feature/test-tracking branch against some-remote/feature/test-tracking")
+        Zenflow::Shell.should_receive(:run).with("git branch --set-upstream-to=some-remote/feature/test-tracking feature/test-tracking")
+        Zenflow::Branch.track('feature/test-tracking')
+      end
+    end
+
+    context "when a remote is not configured" do
+      before do
+        Zenflow::Config[:remote] = nil
+      end
+
+      it "tracks the branch in origin" do
+        Zenflow.should_receive(:Log).with("Tracking the feature/test-tracking branch against origin/feature/test-tracking")
+        Zenflow::Shell.should_receive(:run).with("git branch --set-upstream-to=origin/feature/test-tracking feature/test-tracking")
+        Zenflow::Branch.track('feature/test-tracking')
+      end
+    end
+  end
+
+  describe "self.checkout" do
+    it "checks out the branch" do
+      Zenflow.should_receive(:Log).with("Switching to the feature/test-checkout branch")
+      Zenflow::Shell.should_receive(:run).with("git checkout feature/test-checkout")
+      Zenflow::Branch.checkout('feature/test-checkout')
+    end
+  end
+
+  describe "self.merge" do
+    it "merges in the specified branch" do
+      Zenflow.should_receive(:Log).with("Merging in the feature/test-merging branch")
+      Zenflow::Shell.should_receive(:run).with("git merge --no-ff feature/test-merging")
+      Zenflow::Branch.merge('feature/test-merging')
+    end
+  end
+
+  describe "self.tag" do
+    context "when name and description are specified" do
+      it "creates a tag with the name and description" do
+        Zenflow.should_receive(:Log).with("Tagging the release")
+        Zenflow::Shell.should_receive(:run).with("git tag -a 'v0.1.2' -m 'this tag is amazing'")
+        Zenflow::Branch.tag('v0.1.2', 'this tag is amazing')
+      end
+    end
+
+    context "when name and description are not specified" do
+      it "asks for name and description and then creates a tag" do
+        Zenflow.should_receive(:Log).with("Tagging the release")
+        Zenflow.should_receive(:Ask).with('Name of the tag:', :required => true).and_return('v0.1.3')
+        Zenflow.should_receive(:Ask).with('Tag message:', :required => true).and_return('this tag is even more amazing')
+        Zenflow::Shell.should_receive(:run).with("git tag -a 'v0.1.3' -m 'this tag is even more amazing'")
+        Zenflow::Branch.tag
+      end
+    end
+  end
+
+  describe "self.delete_remote" do
+    after(:each) do
+      Zenflow::Config[:remote] = 'origin'
+      Zenflow::Config[:backup_remote] = false
+    end
+
+    context "when a remote is configured" do
+      before do
+        Zenflow::Config[:remote] = 'some-remote'
+      end
+
+      it 'pushes to the configured remote' do
+        Zenflow.should_receive(:Log).with("Removing the remote branch from some-remote")
+        Zenflow::Shell.should_receive(:run).with("git branch -r | grep some-remote/feature/test-remote-removal && git push some-remote :feature/test-remote-removal || echo ''")
+        Zenflow::Branch.delete_remote('feature/test-remote-removal')
+      end
+    end
+
+    context "when a remote is not configured" do
+      it 'pushes to the origin' do
+        Zenflow.should_receive(:Log).with("Removing the remote branch from origin")
+        Zenflow::Shell.should_receive(:run).with("git branch -r | grep origin/feature/test-remote-removal && git push origin :feature/test-remote-removal || echo ''")
+        Zenflow::Branch.delete_remote('feature/test-remote-removal')
+      end
+    end
+
+    context "when a backup remote is not configured" do
+      it "pushes to the primary remote and then pushes to the backup remote" do
+        Zenflow.should_receive(:Log).with("Removing the remote branch from origin")
+        Zenflow::Shell.should_receive(:run).with("git branch -r | grep origin/feature/test-remote-removal && git push origin :feature/test-remote-removal || echo ''")
+        Zenflow.should_not_receive(:Log).with(/Removing the remote branch/)
+        Zenflow::Shell.should_not_receive(:run).with(/git push/)
+        Zenflow::Branch.delete_remote('feature/test-remote-removal')
+      end
+    end
+
+    context "when a backup remote is configured" do
+      before do
+        Zenflow::Config[:backup_remote] = 'backup-remote'
+      end
+
+      it "pushes to the primary remote and then pushes to the backup remote" do
+        Zenflow.should_receive(:Log).with("Removing the remote branch from origin")
+        Zenflow::Shell.should_receive(:run).with("git branch -r | grep origin/feature/test-remote-removal && git push origin :feature/test-remote-removal || echo ''")
+        Zenflow.should_receive(:Log).with("Removing the remote branch from backup-remote")
+        Zenflow::Shell.should_receive(:run).with("git branch -r | grep backup-remote/feature/test-remote-removal && git push backup-remote :feature/test-remote-removal || echo ''")
+        Zenflow::Branch.delete_remote('feature/test-remote-removal')
+      end
+    end
+  end
+
+  describe "self.delete_local" do
+    context "with the force option" do
+      it "force deletes the local branch" do
+        Zenflow.should_receive(:Log).with("Removing the local branch")
+        Zenflow::Shell.should_receive(:run).with("git branch -D feature/test-local-deletion")
+        Zenflow::Branch.delete_local('feature/test-local-deletion', :force => true)
+      end
+    end
+
+    context "without the force option" do
+      it "deletes the local branch" do
+        Zenflow.should_receive(:Log).with("Removing the local branch")
+        Zenflow::Shell.should_receive(:run).with("git branch -d feature/test-local-deletion")
+        Zenflow::Branch.delete_local('feature/test-local-deletion')
+      end
+    end
+  end
+end

data/spec/zenflow/helpers/changelog_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Zenflow::Changelog do
+
+  describe '.update' do
+    context "when no changelog exists" do
+      before { File.should_receive(:exist?).with("CHANGELOG.md").and_return(false) }
+      it "does nothing" do
+        Zenflow::Changelog.should_not_receive(:prompt_for_change)
+        expect(Zenflow::Changelog.update).to be_nil
+      end
+    end
+
+    context "when the changelog exists" do
+      before { File.should_receive(:exist?).with("CHANGELOG.md").and_return(true) }
+
+      context "when a change is received" do
+        before { Zenflow::Changelog.should_receive(:prompt_for_change).and_return('wrote tests for updating the changelog') }
+
+        it "prepends the change to the changelog and returns the change" do
+          Zenflow::Changelog.should_receive(:prepend_change_to_changelog).with('wrote tests for updating the changelog', {})
+          expect(Zenflow::Changelog.update).to eq('wrote tests for updating the changelog')
+        end
+      end
+
+      context "when no change is received" do
+        before { Zenflow::Changelog.should_receive(:prompt_for_change).and_return(nil) }
+
+        context "and the rotate option is invoked" do
+          it "rotates the changelog and returns nil" do
+            Zenflow::Changelog.should_receive(:rotate).with(:commit => true)
+            expect(Zenflow::Changelog.update(:rotate => true)).to be_nil
+          end
+        end
+
+        context "and the rotate option is absent" do
+          it "rotates the changelog and returns nil" do
+            Zenflow::Changelog.should_not_receive(:rotate)
+            expect(Zenflow::Changelog.update).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe '.prompt_for_change' do
+    context "when the required option is false" do
+      it "asks for a change and indicates it is optional" do
+        Zenflow.should_receive(:Ask).with("Add one line to the changelog (optional):", :required => false)
+        Zenflow::Changelog.prompt_for_change(:required => false)
+      end
+    end
+
+    context "when the required option is anything else" do
+      it "asks for a change and does not indicate is optional" do
+        Zenflow.should_receive(:Ask).with("Add one line to the changelog:", :required => true)
+        Zenflow::Changelog.prompt_for_change
+      end
+    end
+  end
+
+  describe '.prepend_change_to_changelog' do
+    context "when the rotate option is not invoked" do
+      it "prepends changes to the changelog" do
+        Zenflow::Changelog.should_receive(:prepended_changelog).with('changed the world').and_return('some other text I suppose')
+        file_handler = double()
+        file_handler.should_receive(:write).with('some other text I suppose')
+        File.should_receive(:open).with("CHANGELOG.md", "w").and_yield(file_handler)
+        Zenflow::Changelog.should_not_receive(:rotate)
+        Zenflow::Shell.should_receive(:run).with("git add . && git commit -a -m 'Adding line to CHANGELOG: changed the world'")
+        Zenflow::Changelog.prepend_change_to_changelog('changed the world')
+      end
+    end
+
+    context "when the rotate option is present" do
+      it "prepends changes to the changelog" do
+        File.should_receive(:open).with("CHANGELOG.md", "w")
+        Zenflow::Changelog.should_receive(:rotate)
+        Zenflow::Shell.should_receive(:run).with("git add . && git commit -a -m 'Adding line to CHANGELOG: changed the world'")
+        Zenflow::Changelog.prepend_change_to_changelog('changed the world', :rotate => true)
+      end
+    end
+  end
+
+  describe '.prepended_changelog' do
+    it "returns the new changes prepended to the existing changelog" do
+      Zenflow::Changelog.should_receive(:get_changes).and_return(['test branching', 'amongst other things'])
+      expect(Zenflow::Changelog.prepended_changelog('test prepended changelog')).to eq("test prepended changelog\ntest branching\n--------------------------------------------------------------------------------\namongst other things\n")
+    end
+  end
+
+  describe '.rotate' do
+    context "when there are no changes to rotate" do
+      before { Zenflow::Changelog.should_receive(:rotated_changelog).and_return(nil) }
+
+      it "does nothing" do
+        File.should_not_receive(:open)
+        Zenflow::Changelog.rotate
+      end
+    end
+
+    context "when there are no changes to rotate" do
+      before { Zenflow::Changelog.should_receive(:rotated_changelog).and_return('amazing new changelog') }
+
+      context "when the commit option is not invoked" do
+        it "rotates the changelog but does not create a commit" do
+          Zenflow::Version.should_receive(:current)
+          Zenflow.should_receive(:Log)
+          file_handler = double()
+          file_handler.should_receive(:write).with('amazing new changelog')
+          File.should_receive(:open).with("CHANGELOG.md", "w").and_yield(file_handler)
+          Zenflow::Shell.should_not_receive(:run)
+          Zenflow::Changelog.rotate
+        end
+      end
+
+      context "when the commit option is present" do
+        it "rotates the changelog and creates a commit" do
+          Zenflow::Version.should_receive(:current)
+          Zenflow.should_receive(:Log)
+          file_handler = double()
+          file_handler.should_receive(:write).with('amazing new changelog')
+          File.should_receive(:open).with("CHANGELOG.md", "w").and_yield(file_handler)
+          Zenflow::Shell.should_receive(:run).with("git add CHANGELOG.md && git commit -a -m 'Rotating CHANGELOG.'")
+          Zenflow::Changelog.rotate(:commit => true)
+        end
+      end
+    end
+  end
+
+  describe '.rotated_changelog' do
+    it "returns the changelog with changes rotated to the bottom" do
+      Zenflow::Changelog.should_receive(:get_changes).and_return(['test branching', 'amongst other things'])
+      expect(Zenflow::Changelog.rotated_changelog).to eq("amongst other things\n\n---- #{Zenflow::Version.current.to_s} / #{Time.now.strftime('%Y-%m-%d')} --------------------------------------------------------\ntest branching\n")
+    end
+  end
+
+  describe '.get_changes' do
+    context "when the changelog file doesn't exist" do
+      before do
+        Zenflow::Changelog.should_receive(:exist?).and_return(false)
+      end
+
+      it 'does nothing' do
+        File.should_not_receive(:read)
+        expect(Zenflow::Changelog.get_changes).to be_nil
+      end
+    end
+
+    context "when the changelog exists" do
+      before do
+        Zenflow::Changelog.should_receive(:exist?).and_return(true)
+      end
+
+      context "but there are no changes" do
+        before do
+          file = "\n--------------------------------------------------------------------------------\nold changes"
+          File.should_receive(:read).with('CHANGELOG.md').and_return(file)
+        end
+
+        it 'returns nil' do
+          expect(Zenflow::Changelog.get_changes).to be_nil
+        end
+      end
+
+      context "and there are changes" do
+        before do
+          file = "new changes\n--------------------------------------------------------------------------------\nold changes"
+          File.should_receive(:read).with('CHANGELOG.md').and_return(file)
+        end
+
+        it "returns the new changes and the rest of the changelog" do
+          expect(Zenflow::Changelog.get_changes).to eq(["new changes", "--------------------------------------------------------------------------------\nold changes"])
+        end
+      end
+    end
+  end
+
+  describe '.create' do
+    it "writes the changelog template to the changelog" do
+      file = double()
+      file.should_receive(:write).with(Zenflow::Changelog.changelog_template)
+      File.should_receive(:open).with('CHANGELOG.md', 'w').and_yield(file)
+      Zenflow::Changelog.create
+    end
+  end
+
+end