zenflow 0.8.11 → 0.8.12

data/spec/zenflow/{helpers/cli_spec.rb → cli_spec.rb}

@@ -19,88 +19,6 @@ describe Zenflow::CLI do
     end
   end
 
-  describe "#set_up_github" do
-    context "when a github user is already saved" do
-      before do
-        Zenflow::Github.should_receive(:user).and_return('user')
-      end
-
-      context "and the user decides to set a new one" do
-        before do
-          Zenflow.should_receive(:Ask).and_return('n')
-        end
-
-        it "authorizes with Github" do
-          Zenflow::Github.should_receive(:set_user)
-          subject.set_up_github
-        end
-      end
-
-      context "and the user decides not to set a new one" do
-        before do
-          Zenflow.should_receive(:Ask).and_return('y')
-        end
-
-        it "does not authorize with Github" do
-          Zenflow::Github.should_not_receive(:set_user)
-          subject.set_up_github
-        end
-      end
-    end
-
-    context "when a zenflow_token is not already saved" do
-      before do
-        Zenflow::Github.should_receive(:user).and_return(nil)
-      end
-
-      it "authorizes with Github" do
-        Zenflow::Github.should_receive(:set_user)
-        subject.set_up_github
-      end
-    end
-  end
-
-  describe "#authorize_github" do
-    context "when a zenflow_token is already saved" do
-      before do
-        Zenflow::Github.should_receive(:zenflow_token).and_return('super secret token')
-      end
-
-      context "and the user decides to set a new one" do
-        before do
-          Zenflow.should_receive(:Ask).and_return('y')
-        end
-
-        it "authorizes with Github" do
-          Zenflow::Github.should_receive(:authorize)
-          subject.authorize_github
-        end
-      end
-
-      context "and the user decides not to set a new one" do
-        before do
-          Zenflow.should_receive(:Ask).and_return('n')
-        end
-
-        it "does not authorize with Github" do
-          Zenflow::Github.should_not_receive(:authorize)
-          subject.authorize_github
-        end
-      end
-    end
-
-    context "when a zenflow_token is not already saved" do
-      before do
-        Zenflow::Github.should_receive(:zenflow_token).and_return(nil)
-      end
-
-      it "authorizes with Github" do
-        Zenflow::Github.should_receive(:authorize)
-        subject.authorize_github
-      end
-    end
-  end
-
   describe "#already_configured" do
     let(:question) {['There is an existing config file. Overwrite it?', {:options => ["y", "N"], :default => "n"}]}
     before do
@@ -272,17 +190,26 @@ describe Zenflow::CLI do
   end
 
   describe "#init" do
+    let(:current){Zenflow::Github.new('current')}
+
+    before do
+      stub_const("Zenflow::Github::CURRENT", current)
+    end
+
     context "when in a project that doesn't belong to the default hub" do
+      before do
+        current.should_receive(:is_default_hub?).and_return(false)
+      end
+
       context "when zenflow has not been configured" do
         before do
           Zenflow::Config.should_receive(:configured?).and_return(false)
-          Zenflow::Repo.should_receive(:is_default_hub?).and_return(false)
         end
 
         it 'configures zenflow' do
           subject.should_not_receive(:already_configured)
-          Zenflow::Hubs.should_receive(:config)
-          Zenflow::Hubs.should_receive(:authorize)
+          current.should_receive(:config)
+          current.should_receive(:authorize)
           subject.should_receive(:configure_project)
           subject.should_receive(:configure_branches)
           subject.should_receive(:configure_merge_strategy)
@@ -298,13 +225,13 @@ describe Zenflow::CLI do
     context "when zenflow has not been configured" do
       before do
         Zenflow::Config.should_receive(:configured?).and_return(false)
-        Zenflow::Repo.should_receive(:is_default_hub?).and_return(true)
+        current.should_receive(:is_default_hub?).and_return(true)
       end
 
       it 'configures zenflow' do
         subject.should_not_receive(:already_configured)
-        subject.should_receive(:set_up_github)
-        subject.should_receive(:authorize_github)
+        current.should_receive(:set_user)
+        current.should_receive(:authorize)
         subject.should_receive(:configure_project)
         subject.should_receive(:configure_branches)
         subject.should_receive(:configure_merge_strategy)
@@ -323,13 +250,13 @@ describe Zenflow::CLI do
 
       context 'and it is forced to initialize' do
         before do
-          Zenflow::Repo.should_receive(:is_default_hub?).and_return(true)
+          current.should_receive(:is_default_hub?).and_return(true)
         end
 
         it 'configures zenflow' do
           subject.should_not_receive(:already_configured)
-          subject.should_receive(:set_up_github)
-          subject.should_receive(:authorize_github)
+          current.should_receive(:set_user)
+          current.should_receive(:authorize)
           subject.should_receive(:configure_project)
           subject.should_receive(:configure_branches)
           subject.should_receive(:configure_merge_strategy)
@@ -350,8 +277,8 @@ describe Zenflow::CLI do
 
         it 'calls already_configured' do
           subject.should_receive(:already_configured).and_call_original
-          subject.should_not_receive(:authorize_github)
-          subject.should_not_receive(:configure_project)
+          current.should_not_receive(:set_user)
+          current.should_not_receive(:authorize)
           subject.should_not_receive(:configure_branches)
           subject.should_not_receive(:configure_merge_strategy)
           subject.should_not_receive(:configure_remotes)

data/spec/zenflow/commands/admin_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe Zenflow::Admin do
+  let(:admin) { Zenflow::Admin.new }
+
+  describe '.list' do
+    it 'lists recognized hubs in git config' do
+      Zenflow::Shell.should_receive(:run).with("git config --get-regexp zenflow\.hub\..*", silent: true).and_return(
+<<EOS
+zenflow.hub.hub.1.api.base.url api_base_url
+zenflow.hub.yet.another.hub.github.user github_user
+zenflow.hub.hub.1.token token
+zenflow.hub.my-hub.token token
+zenflow.hub.one.more.hub.user.agent.base user_agent_base
+zenflow.hub.bad.token.hub.goobers user_agent_base
+EOS
+      )
+      Zenflow.should_receive(:Log).with("Recogized hubs")
+      Terminal::Table.should_receive(:new).with(
+        headings: ["Hub"],
+        rows: [
+          ["github.com [default] [current]"],
+          ["hub.1"],
+          ["my-hub"],
+          ["one.more.hub"],
+          ["yet.another.hub"]
+        ]
+      ).and_return("log-data")
+      Zenflow.should_receive(:Log).with("log-data", indent: false, arrows: false, color: false)
+      admin.list
+    end
+  end
+
+  describe '.current' do
+    it 'logs the hubs of the current project' do
+      Zenflow.should_receive(:Log).with("This project's hub is github.com [default] [current]")
+      admin.current
+    end
+  end
+
+  describe '.describe' do
+    it 'displays config parameters for the hub' do
+      hub = Zenflow::Github.new('my-hub')
+      admin.should_receive(:resolve_hub).with('my-hub').and_return(hub)
+      admin.should_receive(:hub_label).with('my-hub').and_return('my-hub')
+      Zenflow.should_receive(:Log).with("Configuration details for hub my-hub")
+      hub.should_receive(:describe).and_return([
+        ["Parameter 1", "Github Config Key 1", "Github Conifg Value 1", "Value 1"],
+        ["Parameter 2", "Github Config Key 2", "Github Conifg Value 2", "Value 2"],
+        ["Parameter 3", "Github Config Key 3", "Github Conifg Value 3", "Value 3"]
+      ])
+      Terminal::Table.should_receive(:new).with(
+        headings: ["Parameter", "Github Config Key", "Github Config Value", "Value (with system defaults)"],
+        rows: [
+          ["Parameter 1", "Github Config Key 1", "Github Conifg Value 1", "Value 1"],
+          ["Parameter 2", "Github Config Key 2", "Github Conifg Value 2", "Value 2"],
+          ["Parameter 3", "Github Config Key 3", "Github Conifg Value 3", "Value 3"]
+        ]
+      ).and_return("log-data")
+      Zenflow.should_receive(:Log).with("log-data", {:indent=>false, :arrows=>false, :color=>false})
+      admin.describe('my-hub')
+    end
+  end
+
+  describe '.config' do
+    context 'when called with a hub parameter' do
+      it 'calls the individual parameter config methods' do
+        myhub = Zenflow::Github.new('my-hub')
+        Zenflow::Github.should_receive(:new).with('my-hub').and_return(myhub)
+        admin.should_receive(:hub_label).with('my-hub').and_return('my-hub')
+        Zenflow.should_receive(:Log).with("Configuring my-hub")
+        myhub.should_receive(:config)
+        admin.config('my-hub')
+      end
+    end
+
+    context 'when called with no hub parameter' do
+      it 'calls the individual parameter config methods' do
+        admin.should_receive(:hub_label).with('github.com').and_return('github.com')
+        Zenflow.should_receive(:Log).with("Configuring github.com")
+        Zenflow::Github::CURRENT.should_receive(:config)
+        admin.config
+      end
+    end
+  end
+
+  describe '.authorize' do
+    context 'when called with a hub parameter' do
+      it 'call the hubs authorize method' do
+        myhub = Zenflow::Github.new('my-hub')
+        Zenflow::Github.should_receive(:new).with('my-hub').and_return(myhub)
+        admin.should_receive(:hub_label).with('my-hub').and_return('my-hub')
+        Zenflow.should_receive(:Log).with("Authorizing my-hub")
+        myhub.should_receive(:authorize)
+        admin.authorize('my-hub')
+      end
+    end
+
+    context 'when called with no hub parameter' do
+      it 'call the current hubs authorize method' do
+        admin.should_receive(:hub_label).with('github.com').and_return('github.com')
+        Zenflow.should_receive(:Log).with("Authorizing github.com")
+        Zenflow::Github::CURRENT.should_receive(:authorize)
+        admin.authorize
+      end
+    end
+  end
+
+  describe '.resolve_hub' do
+    context 'hub is not nil' do
+      it 'resolves to the supplied hub' do
+        expect(admin.resolve_hub('my-hub').hub).to eq('my-hub')
+      end
+    end
+
+    context 'hub is nil' do
+      it 'resolves to the CURRENT hub' do
+        expect(admin.resolve_hub).to eq(Zenflow::Github::CURRENT)
+      end
+    end
+  end
+
+  describe '.hub_label' do
+    context 'hub is default hub' do
+      context 'hub is current hub' do
+        before(:each){
+          stub_const("Zenflow::Github::CURRENT", Zenflow::Github.new(Zenflow::Github::DEFAULT_HUB))
+        }
+
+        it 'returns the expected label' do
+          expect(admin.hub_label(Zenflow::Github::DEFAULT_HUB)).to eq("#{Zenflow::Github::DEFAULT_HUB} [default] [current]")
+        end
+      end
+
+      context 'hub is not current hub' do
+        before(:each){
+          stub_const("Zenflow::Github::CURRENT", Zenflow::Github.new('current-hub'))
+        }
+
+        it 'returns the expected label' do
+          expect(admin.hub_label(Zenflow::Github::DEFAULT_HUB)).to eq("#{Zenflow::Github::DEFAULT_HUB} [default]")
+        end
+      end
+    end
+
+    context 'hub is not default hub' do
+      before(:each){
+        stub_const("Zenflow::Github::CURRENT", Zenflow::Github.new('current-hub'))
+      }
+
+      context 'hub is current hub' do
+        it 'returns the expected label' do
+          expect(admin.hub_label('current-hub')).to eq('current-hub [current]')
+        end
+      end
+
+      context 'hub is not current hub' do
+        it 'returns the expected label' do
+          expect(admin.hub_label('not-current-hub')).to eq('not-current-hub')
+        end
+      end
+    end
+  end
+
+  describe '.default_hub_tag' do
+    context 'hub is default hub' do
+      it 'returns the expected tag' do
+        expect(admin.default_hub_tag(Zenflow::Github::DEFAULT_HUB)).to eq(' [default]')
+      end
+    end
+
+    context 'hub is not default hub' do
+      it 'returns the expected tag' do
+        expect(admin.default_hub_tag('not-default-hub')).to eq('')
+      end
+    end
+  end
+
+  describe '.current_hub_tag' do
+    before(:each){
+      stub_const("Zenflow::Github::CURRENT", Zenflow::Github.new('current-hub'))
+    }
+
+    context 'hub is current hub' do
+      it 'returns the expected tag' do
+        expect(admin.current_hub_tag('current-hub')).to eq(' [current]')
+      end
+    end
+
+    context 'hub is not current hub' do
+      it 'returns the expected tag' do
+        expect(admin.current_hub_tag('not-current-hub')).to eq('')
+      end
+    end
+  end
+
+  describe '.config_key_regex' do
+    it 'returns the expected regex' do
+      expect(admin.config_keys_regex).to eq('(?:api\\.base\\.url|github\\.user|token|user\\.agent\\.base)')
+    end
+  end
+end

data/spec/zenflow/helpers/github_spec.rb

@@ -3,260 +3,469 @@ require 'spec_helper'
 describe Zenflow::Github do
   describe '.api_base_url' do
     context 'when the value is present' do
+      let(:hub) { Zenflow::Github.new('test-hub') }
+
       before(:each){
-        Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'api.base.url').and_return("api-base-url")
+        hub.should_receive(:get_config).with('api.base.url').and_return("api-base-url")
       }
 
-      context 'and default is true' do
+      context 'and use_default_when_value_is_nil is not specified' do
+        it 'returns the expected value' do
+          expect(hub.api_base_url).to eq("api-base-url")
+        end
+      end
+
+      context 'and use_default_when_value_is_nil is true' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.api_base_url('test-hub', true)).to eq("api-base-url")
+          expect(hub.api_base_url(true)).to eq("api-base-url")
         end
       end
 
-      context 'and default is false' do
+      context 'and use_default_when_value_is_nil is false' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.api_base_url('test-hub', false)).to eq("api-base-url")
+          expect(hub.api_base_url(false)).to eq("api-base-url")
         end
       end
     end
 
     context 'when the value is absent' do
+      let(:hub) { Zenflow::Github.new('test-hub') }
+
       before(:each){
-        Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'api.base.url').and_return(nil)
+        hub.should_receive(:get_config).with('api.base.url').and_return(nil)
       }
 
-      context 'and default is true' do
+      context 'and use_default_when_value_is_nil is not specified' do
+        it 'returns the expected value' do
+          expect(hub.api_base_url).to eq("https://api.github.com")
+        end
+      end
+
+      context 'and use_default_when_value_is_nil is true' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.api_base_url('test-hub', true)).to eq("https://api.github.com")
+          expect(hub.api_base_url(true)).to eq("https://api.github.com")
         end
       end
 
-      context 'and default is false' do
+      context 'and use_default_when_value_is_nil is false' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.api_base_url('test-hub', false)).to eq(nil)
+          expect(hub.api_base_url(false)).to eq(nil)
         end
       end
     end
   end
 
   describe '.set_api_base_url' do
-    let(:api_base_url){'api-base-url'}
 
     it 'asks for the API base URL and sets it to zenflow.api.base.url' do
-      Zenflow.should_receive(:Ask).and_return(api_base_url)
-      Zenflow::Github.should_receive(:set_config_for_hub).with(nil, 'api.base.url', api_base_url)
-      Zenflow::Github.set_api_base_url
+    end
+  end
+
+  describe '.set_api_base_url' do
+    let(:hub){Zenflow::Github.new('test-hub')}
+    let(:api_base_url){'api-base-url'}
+
+    context 'when a github api base url is already saved' do
+      before do
+        hub.should_receive(:api_base_url).twice.and_return(api_base_url)
+      end
+
+      context 'and the user decides to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('n')
+        end
+
+        it 'asks for an api base url' do
+          Zenflow.should_receive(:Ask).and_return(api_base_url)
+          hub.should_receive(:set_config).with('api.base.url', api_base_url)
+          hub.set_api_base_url
+        end
+      end
+
+      context 'and the user decides not to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('y')
+        end
+
+        it 'does not ask for an api base url' do
+          Zenflow.should_not_receive(:Ask)
+          hub.should_not_receive(:set_config)
+          hub.set_api_base_url
+        end
+      end
+    end
+
+    context 'when an api base url is not already saved' do
+      before do
+        hub.should_receive(:api_base_url).and_return(nil)
+      end
+
+      it 'asks for an api base url' do
+        Zenflow.should_receive(:Ask).and_return(api_base_url)
+        hub.should_receive(:set_config).with('api.base.url', api_base_url)
+        hub.set_api_base_url
+      end
     end
   end
 
   describe '.user' do
+    let(:hub){Zenflow::Github.new('hub')}
     let(:user){'github-user'}
 
     before(:each){
-      Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'github.user').and_return(user)
+      hub.should_receive(:get_config).with('github.user').and_return(user)
     }
 
     it "returns the user" do
-      expect(Zenflow::Github.user('test-hub')).to eq(user)
+      expect(hub.user).to eq(user)
     end
   end
 
   describe '.set_user' do
+    let(:hub){Zenflow::Github.new('test-hub')}
     let(:user){'github-user'}
 
-    it 'asks for the user name and sets it to github.user' do
-      Zenflow.should_receive(:Ask).and_return(user)
-      Zenflow::Github.should_receive(:set_config_for_hub).with(nil, 'github.user', user)
-      Zenflow::Github.set_user
+    context 'when a github user is already saved' do
+      before do
+        hub.should_receive(:user).twice.and_return(user)
+      end
+
+      context 'and the user decides to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('n')
+        end
+
+        it 'asks for a user' do
+          Zenflow.should_receive(:Ask).and_return(user)
+          hub.should_receive(:set_config).with('github.user', user)
+          hub.set_user
+        end
+      end
+
+      context 'and the user decides not to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('y')
+        end
+
+        it 'does not ask for a user' do
+          Zenflow.should_not_receive(:Ask)
+          hub.should_not_receive(:set_config)
+          hub.set_user
+        end
+      end
+    end
+
+    context 'when a user is not already saved' do
+      before do
+        hub.should_receive(:user).and_return(nil)
+      end
+
+      it 'asks for a user' do
+        Zenflow.should_receive(:Ask).and_return(user)
+        hub.should_receive(:set_config).with('github.user', user)
+        hub.set_user
+      end
     end
   end
 
   describe '.authorize' do
-    context "when authorization fails" do
+    let(:hub){Zenflow::Github.new('my-hub')}
+
+    context 'when a zenflow_token is already saved' do
       before do
-        Zenflow.should_receive("Log").with("Authorizing with GitHub (adamkittelson@github.com)... Enter your GitHub password.")
-        Zenflow::Github.should_receive(:user).twice.and_return('adamkittelson')
-        Zenflow::Github.should_receive(:api_base_url).and_return('https://api.base.url')
-        Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.base.url/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"message": "failed to authorize, bummer"}')
+        hub.should_receive(:zenflow_token).and_return('super secret token')
+      end
+
+      context 'and the user decides to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).with("You already have a token from GitHub. Do you want to set a new one?", :options => ["y", "N"], :default => "n").and_return('y')
+        end
+
+        context 'and authorization succeeds' do
+          before do
+            Zenflow.should_receive("Log").with("Authorizing with GitHub (adamkittelson@my-hub)... Enter your GitHub password.")
+            hub.should_receive(:user).twice.and_return('adamkittelson')
+            hub.should_receive(:api_base_url).and_return('https://api.base.url')
+            Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.base.url/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"token": "super secure token"}')
+          end
+
+          it 'authorizes with Github' do
+            hub.should_receive(:set_config).with('token', "super secure token")
+            Zenflow.should_receive("Log").with("Authorized!")
+            hub.authorize
+          end
+        end
+
+        context 'and authorization fails' do
+          before do
+            Zenflow.should_receive("Log").with("Authorizing with GitHub (adamkittelson@my-hub)... Enter your GitHub password.")
+            hub.should_receive(:user).twice.and_return('adamkittelson')
+            hub.should_receive(:api_base_url).and_return('https://api.base.url')
+            Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.base.url/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"message": "failed to authorize, bummer"}')
+          end
+
+          it 'authorizes with Github' do
+            Zenflow.should_receive("Log").with("Something went wrong. Error from GitHub was: failed to authorize, bummer")
+            hub.authorize
+          end
+        end
       end
 
-      it "logs that something went wrong" do
-        Zenflow.should_receive("Log").with("Something went wrong. Error from GitHub was: failed to authorize, bummer")
-        Zenflow::Github.authorize
+      context 'and the user decides not to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('n')
+        end
+
+        it 'does not authorize with Github' do
+          hub.authorize
+        end
       end
     end
 
-    context "when authorization succeeds" do
+    context 'when a zenflow_token is not already saved' do
       before do
-        Zenflow.should_receive("Log").with("Authorizing with GitHub (adamkittelson@github.com)... Enter your GitHub password.")
-        Zenflow::Github.should_receive(:user).twice.and_return('adamkittelson')
-        Zenflow::Github.should_receive(:api_base_url).and_return('https://api.base.url')
-        Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.base.url/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"token": "super secure token"}')
+        hub.should_receive(:zenflow_token).and_return(nil)
       end
 
-      it "adds the token to git config and logs a happy message of success" do
-        Zenflow::Github.should_receive(:set_config_for_hub).with(nil, 'token', "super secure token")
-        Zenflow.should_receive("Log").with("Authorized!")
-        Zenflow::Github.authorize
+      context 'and authorization succeeds' do
+        before do
+          Zenflow.should_receive("Log").with("Authorizing with GitHub (adamkittelson@my-hub)... Enter your GitHub password.")
+          hub.should_receive(:user).twice.and_return('adamkittelson')
+          hub.should_receive(:api_base_url).and_return('https://api.base.url')
+          Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.base.url/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"token": "super secure token"}')
+        end
+
+        it 'authorizes with Github' do
+          hub.should_receive(:set_config).with('token', "super secure token")
+          Zenflow.should_receive("Log").with("Authorized!")
+          hub.authorize
+        end
       end
-    end
 
+      context 'and authorization fails' do
+        before do
+          Zenflow.should_receive("Log").with("Authorizing with GitHub (adamkittelson@my-hub)... Enter your GitHub password.")
+          hub.should_receive(:user).twice.and_return('adamkittelson')
+          hub.should_receive(:api_base_url).and_return('https://api.base.url')
+          Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.base.url/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"message": "failed to authorize, bummer"}')
+        end
+
+        it 'does not authorize with Github' do
+          Zenflow.should_receive("Log").with("Something went wrong. Error from GitHub was: failed to authorize, bummer")
+          hub.authorize
+        end
+      end
+    end
   end
 
   describe '.user_agent_base' do
+    let(:hub){Zenflow::Github.new('hub')}
+
     context 'when the value is present' do
       before(:each){
-        Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'user.agent.base').and_return("user-agent-base")
+        hub.should_receive(:get_config).with('user.agent.base').and_return("user-agent-base")
       }
 
-      context 'and default is true' do
+      context 'and use_default_when_value_is_nil is not specified' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.user_agent_base('test-hub', true)).to eq("user-agent-base")
+          expect(hub.user_agent_base).to eq("user-agent-base")
         end
       end
 
-      context 'and default is false' do
+      context 'and use_default_when_value_is_nil is true' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.user_agent_base('test-hub', false)).to eq("user-agent-base")
+          expect(hub.user_agent_base(true)).to eq("user-agent-base")
+        end
+      end
+
+      context 'and use_default_when_value_is_nil is false' do
+        it 'returns the expected value' do
+          expect(hub.user_agent_base(false)).to eq("user-agent-base")
         end
       end
     end
 
     context 'when the value is absent' do
       before(:each){
-        Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'user.agent.base').and_return(nil)
+        hub.should_receive(:get_config).with('user.agent.base').and_return(nil)
       }
 
-      context 'and default is true' do
+      context 'and use_default_when_value_is_nil is not specified' do
+        it 'returns the expected value' do
+          expect(hub.user_agent_base).to eq("Zencoder")
+        end
+      end
+
+      context 'and use_default_when_value_is_nil is true' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.user_agent_base('test-hub', true)).to eq("Zencoder")
+          expect(hub.user_agent_base(true)).to eq("Zencoder")
         end
       end
 
-      context 'and default is false' do
+      context 'and use_default_when_value_is_nil is false' do
         it 'returns the expected value' do
-          expect(Zenflow::Github.user_agent_base('test-hub', false)).to eq(nil)
+          expect(hub.user_agent_base(false)).to eq(nil)
         end
       end
     end
   end
 
   describe '.set_user_agent_base' do
+    let(:hub){Zenflow::Github.new('test-hub')}
     let(:user_agent_base){'user-agent-base'}
 
-    it 'asks for the User-Agent base string and sets it to zenflow.user.agent.base' do
-      Zenflow.should_receive(:Ask).and_return(user_agent_base)
-      Zenflow::Github.should_receive(:set_config_for_hub).with(nil, 'user.agent.base', user_agent_base)
-      Zenflow::Github.set_user_agent_base
-    end
-  end
+    context 'when a github user agent base is already saved' do
+      before do
+        hub.should_receive(:user_agent_base).twice.and_return(user_agent_base)
+      end
 
-  describe '.resolve_hub' do
-    context 'when supplied as argument' do
-      it 'returns the hub provided' do
-        expect(Zenflow::Github.resolve_hub('test-hub')).to eq 'test-hub'
-      end    
-    end
+      context 'and the user decides to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('n')
+        end
 
-    context 'when argument is nil' do
-      context 'and there is a repo hub' do
-        before(:each){
-          Zenflow::Repo.should_receive(:hub).and_return('repo-hub')
-        }
+        it 'asks for a user agent base' do
+          Zenflow.should_receive(:Ask).and_return(user_agent_base)
+          hub.should_receive(:set_config).with('user.agent.base', user_agent_base)
+          hub.set_user_agent_base
+        end
+      end
 
-        it 'returns the repo hub' do
-          expect(Zenflow::Github.resolve_hub(nil)).to eq 'repo-hub'
-        end    
+      context 'and the user decides not to set a new one' do
+        before do
+          Zenflow.should_receive(:Ask).and_return('y')
+        end
+
+        it 'does not ask for a user agent base' do
+          Zenflow.should_not_receive(:Ask)
+          hub.should_not_receive(:set_config)
+          hub.set_user_agent_base
+        end
       end
+    end
 
-      context 'and the repo hub is nil' do
-        before(:each){
-          Zenflow::Repo.should_receive(:hub).and_return(nil)
-        }
+    context 'when a user agent base is not already saved' do
+      before do
+        hub.should_receive(:user_agent_base).and_return(nil)
+      end
 
-        it 'returns the default hub' do
-          expect(Zenflow::Github.resolve_hub(nil)).to eq Zenflow::Github::DEFAULT_HUB
-        end    
+      it 'asks for a user agent base' do
+        Zenflow.should_receive(:Ask).and_return(user_agent_base)
+        hub.should_receive(:set_config).with('user.agent.base', user_agent_base)
+        hub.set_user_agent_base
       end
     end
   end
 
-  describe '.construct_key_for_hub' do
+  describe '.current' do
+    context 'when the current repo is nil' do
+      before(:each){
+        Zenflow::Repo.should_receive(:hub).and_return(nil)
+      }
+
+      it 'returns the default hub' do
+        expect(Zenflow::Github.current.hub).to eq 'github.com'
+      end    
+    end
+
+    context 'when the current repo is not nil' do
+      before(:each){
+        Zenflow::Repo.should_receive(:hub).and_return('current.repo.hub')
+      }
+
+      it 'returns the current repo\'s hub' do
+        expect(Zenflow::Github.current.hub).to eq 'current.repo.hub'
+      end    
+    end
+  end
+
+  describe '.parameter_key_for_hub' do
+
     context 'when hub is the default hub' do
+      let(:hub){Zenflow::Github.new('github.com')}
+
       context 'and key is the api url base key' do
         it 'prepends \'zenflow\' as a prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('github.com', 'api.base.url')).to eq("zenflow.api.base.url")
+          expect(hub.parameter_key_for_hub('api.base.url')).to eq("zenflow.api.base.url")
         end
       end
 
       context 'and key is the user key' do
         it 'does not prepend a prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('github.com', 'github.user')).to eq('github.user')
+          expect(hub.parameter_key_for_hub('github.user')).to eq('github.user')
         end
       end
 
       context 'and key is the zenflow token key' do
         it 'prepends \'zenflow\' as a prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('github.com', 'token')).to eq("zenflow.token")
+          expect(hub.parameter_key_for_hub('token')).to eq("zenflow.token")
         end
       end
 
       context 'and key is the user agent base key' do
         it 'prepends \'zenflow\' as a prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('github.com', 'user.agent.base')).to eq("zenflow.user.agent.base")
+          expect(hub.parameter_key_for_hub('user.agent.base')).to eq("zenflow.user.agent.base")
         end
       end
     end
 
     context 'hub is not the default hub' do
+      let(:hub){Zenflow::Github.new('my-hub')}
+
       context 'and key is the api url base key' do
         it 'prepends a hub-specific prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('my-hub', 'api.base.url')).to eq("zenflow.hub.my-hub.api.base.url")
+          expect(hub.parameter_key_for_hub('api.base.url')).to eq("zenflow.hub.my-hub.api.base.url")
         end
       end
 
       context 'and key is the user key' do
         it 'prepends a hub-specific prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('my-hub', 'github.user')).to eq("zenflow.hub.my-hub.github.user")
+          expect(hub.parameter_key_for_hub('github.user')).to eq("zenflow.hub.my-hub.github.user")
         end
       end
 
       context 'and key is the zenflow token key' do
         it 'prepends a hub-specific prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('my-hub', 'token')).to eq("zenflow.hub.my-hub.token")
+          expect(hub.parameter_key_for_hub('token')).to eq("zenflow.hub.my-hub.token")
         end
       end
 
       context 'and key is the user agent base key' do
         it 'prepends a hub-specific prefix' do
-          expect(Zenflow::Github.construct_key_for_hub('my-hub', 'user.agent.base')).to eq("zenflow.hub.my-hub.user.agent.base")
+          expect(hub.parameter_key_for_hub('user.agent.base')).to eq("zenflow.hub.my-hub.user.agent.base")
         end
       end
     end
   end
 
-  describe '.get_config_for_hub' do
+  describe '.get_config' do
+    let(:hub){Zenflow::Github.new('test-hub')}
+
     it 'gets the correct global config parameter' do
-      Zenflow::Github.should_receive(:get_global_config).with("zenflow.hub.test-hub.test-key")
-      Zenflow::Github.get_config_for_hub('test-hub', 'test-key')
+      hub.should_receive(:get_global_config).with("zenflow.hub.test-hub.test-key")
+      hub.get_config('test-key')
     end
   end
 
-  describe '.set_config_for_hub' do
+  describe '.set_config' do
+    let(:hub){Zenflow::Github.new('test-hub')}
+
     it 'sets the correct global config parameter' do
-      Zenflow::Github.should_receive(:set_global_config).with("zenflow.hub.test-hub.test-key", "test-value")
-      Zenflow::Github.set_config_for_hub('test-hub', 'test-key', 'test-value')
+      hub.should_receive(:set_global_config).with("zenflow.hub.test-hub.test-key", "test-value")
+      hub.set_config('test-key', 'test-value')
     end
   end
 
   describe '.get_global_config' do
+    let(:hub){Zenflow::Github.new('test-hub')}
+
     context 'when value is present' do
       before(:each){
         Zenflow::Shell.should_receive(:run).with('git config --get key', silent: true).and_return('value')
       }
 
       it 'returns the value' do
-        expect(Zenflow::Github.get_global_config('key')).to eq('value')
+        expect(hub.get_global_config('key')).to eq('value')
       end
     end
 
@@ -266,18 +475,20 @@ describe Zenflow::Github do
       }
 
       it 'returns nil' do
-        expect(Zenflow::Github.get_global_config('key')).to eq(nil)
+        expect(hub.get_global_config('key')).to eq(nil)
       end
     end
   end
 
   describe '.set_global_config' do
+    let(:hub){Zenflow::Github.new('test-hub')}
+
     before(:each){
       Zenflow::Shell.should_receive(:run).with('git config --global key value', silent: true)
     }
 
     it 'sets the value' do
-      Zenflow::Github.set_global_config('key', 'value')
+      hub.set_global_config('key', 'value')
     end
   end
 
@@ -292,24 +503,29 @@ describe Zenflow::Github do
     end
   end
 
-  describe '.describe_hub_parameter' do
+  describe '.describe_parameter' do
+    let(:hub){Zenflow::Github.new('my-hub')}
+
     it 'returns the expected array' do
-      Zenflow::Github.should_receive(:get_config_for_hub).with('my-hub', 'key').and_return('config-value')
-      expect(Zenflow::Github.describe_hub_parameter('name', 'my-hub', 'key', 'value')).to eq(
+      hub.should_receive(:get_config).with('key').and_return('config-value')
+
+      expect(hub.describe_parameter('name', 'key', 'value')).to eq(
         ['name', 'zenflow.hub.my-hub.key', 'config-value', 'value']
       )
     end
   end
 
-  describe '.describe_hub' do
+  describe '.describe' do
     context 'all parameters configured' do
+      let(:hub){Zenflow::Github.new('my-hub')}
+
       it 'returns the expected data' do
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'api.base.url').and_return('api-base-url-config-value')
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'github.user').and_return('github-user-config-value')
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'token').and_return('token-config-value')
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'user.agent.base').and_return('user-agent-base-config-value')
+        hub.should_receive(:get_config).twice.with('api.base.url').and_return('api-base-url-config-value')
+        hub.should_receive(:get_config).twice.with('github.user').and_return('github-user-config-value')
+        hub.should_receive(:get_config).twice.with('token').and_return('token-config-value')
+        hub.should_receive(:get_config).twice.with('user.agent.base').and_return('user-agent-base-config-value')
 
-        expect(Zenflow::Github.describe_hub('my-hub')).to eq([
+        expect(hub.describe).to eq([
           ['API Base URL',    'zenflow.hub.my-hub.api.base.url',    'api-base-url-config-value',    'api-base-url-config-value'],
           ['User',            'zenflow.hub.my-hub.github.user',     'github-user-config-value',     'github-user-config-value'],
           ['Token',           'zenflow.hub.my-hub.token',           'token-config-value',           'token-config-value'],
@@ -319,13 +535,15 @@ describe Zenflow::Github do
     end
 
     context 'no parameters configured' do
+      let(:hub){Zenflow::Github.new('my-hub')}
+
       it 'returns the expected data' do
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'api.base.url').and_return(nil)
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'github.user').and_return(nil)
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'token').and_return(nil)
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('my-hub', 'user.agent.base').and_return(nil)
+        hub.should_receive(:get_config).twice.with('api.base.url').and_return(nil)
+        hub.should_receive(:get_config).twice.with('github.user').and_return(nil)
+        hub.should_receive(:get_config).twice.with('token').and_return(nil)
+        hub.should_receive(:get_config).twice.with('user.agent.base').and_return(nil)
 
-        expect(Zenflow::Github.describe_hub('my-hub')).to eq([
+        expect(hub.describe).to eq([
           ['API Base URL',    'zenflow.hub.my-hub.api.base.url',    nil, 'https://api.github.com'],
           ['User',            'zenflow.hub.my-hub.github.user',     nil, nil],
           ['Token',           'zenflow.hub.my-hub.token',           nil, nil],
@@ -335,13 +553,15 @@ describe Zenflow::Github do
     end
 
     context 'hub is default' do
+      let(:hub){Zenflow::Github.new(Zenflow::Github::DEFAULT_HUB)}
+
       it 'returns the expected data' do
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('github.com', 'api.base.url').and_return(nil)
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('github.com', 'github.user').and_return(nil)
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('github.com', 'token').and_return(nil)
-        Zenflow::Github.should_receive(:get_config_for_hub).twice.with('github.com', 'user.agent.base').and_return(nil)
+        hub.should_receive(:get_config).twice.with('api.base.url').and_return(nil)
+        hub.should_receive(:get_config).twice.with('github.user').and_return(nil)
+        hub.should_receive(:get_config).twice.with('token').and_return(nil)
+        hub.should_receive(:get_config).twice.with('user.agent.base').and_return(nil)
 
-        expect(Zenflow::Github.describe_hub('github.com')).to eq([
+        expect(hub.describe).to eq([
           ['API Base URL',    'zenflow.api.base.url',    nil, 'https://api.github.com'],
           ['User',            'github.user',             nil, nil],
           ['Token',           'zenflow.token',           nil, nil],