zenflow 0.8.5 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae2ed97af6262779e9958e11f9b2e6423e27c9e4
-  data.tar.gz: 3f3b3631d60598dfcfd2496e9611b40d556b3c5a
+  metadata.gz: 08056c15bf04111493669ac5810d2bee09e1809b
+  data.tar.gz: de40476d5eb7b2bbed54f67f8b9e451ef3a48b07
 SHA512:
-  metadata.gz: 841b104df941cb9238b1ed83882a8b19e2ad3fab8f6c56dc4499f5d2af4ae002567c20640b83f570838814d94a0ae43ff0bf274f5d6c32e32f1973aad6c05c5e
-  data.tar.gz: f6636f589dcf351a561502173347e67155d5ba4412fa11c556fb695ce5a7070441fb7510e597df657af184a432a1cc56a7ac69c1c9be3ca147ffd69951165d1f
+  metadata.gz: 3c14ab625a909bb5afbaf2cb20a61a909ef081f3230e2dbc9fd49db22d02b3a56d702b6a84fe0c20e073a9b60fe9d93ffb87ccb5839e3fd23d30bc963bc2a8ec
+  data.tar.gz: c13bd23582fd6e0c5eee98eaddc4fd67efcc7749d40a036a5da6b36bf9864b6dd5d05322ffb7f6554a9cb231198f7bae7f107fb83c9a7a4acf05a77774d97c27

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    zenflow (0.8.4)
+    zenflow (0.8.5)
       colored (~> 1.2)
       httparty (~> 0.12.0)
       terminal-table (~> 1.4.5)

data/README.markdown

@@ -3,8 +3,8 @@
 [![Gem Version](https://badge.fury.io/rb/zenflow.png)](http://badge.fury.io/rb/zenflow)
 [![Code Climate](https://codeclimate.com/repos/51bf6e3b7e00a411ad00f6c3/badges/111fbe3664cebffa8e23/gpa.png)](https://codeclimate.com/repos/51bf6e3b7e00a411ad00f6c3/feed)
 [![Coverage Status](https://coveralls.io/repos/zencoder/zenflow/badge.png)](https://coveralls.io/r/zencoder/zenflow)
-[![Dependency Status](https://gemnasium.com/a1d29c5ea446d54bead93a6878bc204b.png)](https://gemnasium.com/zencoder/zenflow)
-![CircleCI](https://circleci.com/gh/zencoder/zenflow.png?circle-token=992f1e59d778a8f6eef0fb9f2888e80cf60d7226)
+[![Dependency Status](https://gemnasium.com/zencoder/zenflow.png)](https://gemnasium.com/zencoder/zenflow)
+![CircleCI Tests](https://circleci.com/gh/zencoder/zenflow.png?circle-token=13273409fe8b7c62faddf26980040cf502b0348a)
 
 -------
 

data/VERSION.yml

@@ -1,5 +1,5 @@
 ---
 major: 0
 minor: 8
-patch: 5
+patch: 6
 pre:

data/lib/zenflow.rb

@@ -26,9 +26,10 @@ require 'zenflow/helpers/branch_commands/review'
 require 'zenflow/helpers/branch_commands/start'
 require 'zenflow/helpers/branch_commands/update'
 require 'zenflow/helpers/branch_command'
+require 'zenflow/commands/deploy'
 require 'zenflow/commands/feature'
 require 'zenflow/commands/hotfix'
+require 'zenflow/commands/hubs'
 require 'zenflow/commands/release'
-require 'zenflow/commands/deploy'
 require 'zenflow/commands/reviews'
 require 'zenflow/cli'

data/lib/zenflow/cli.rb

@@ -20,6 +20,9 @@ module Zenflow
       super
     end
 
+    desc "hubs SUBCOMMAND", "Manage Github server configurations."
+    subcommand "hubs", Zenflow::Hubs
+
     desc "feature SUBCOMMAND", "Manage feature branches."
     subcommand "feature", Zenflow::Feature
 
@@ -29,10 +32,10 @@ module Zenflow
     desc "release SUBCOMMAND", "Manage release branches."
     subcommand "release", Zenflow::Release
 
-    desc  "reviews SUBCOMMAND", "Works with code reviews."
+    desc "reviews SUBCOMMAND", "Works with code reviews."
     subcommand "reviews", Zenflow::Reviews
 
-    desc  "deploy ENV", "Deploy to an environment."
+    desc "deploy ENV", "Deploy to an environment."
     subcommand "deploy", Zenflow::Deploy
 
     desc "init", "Write the zenflow config file."
@@ -40,8 +43,7 @@ module Zenflow
       if Zenflow::Config.configured? && !force
         already_configured
       else
-        set_up_github
-        authorize_github
+        configure_github
         configure_project
         configure_branches
         configure_merge_strategy
@@ -54,24 +56,24 @@ module Zenflow
 
     desc "set_up_github", "Set up GitHub user information"
     def set_up_github
-      user = Zenflow::Github.user
+      user = Zenflow::Github.user(Zenflow::Github::DEFAULT_HUB)
       if user.to_s != ''
         if Zenflow::Ask("Your GitHub user is currently #{user}. Do you want to use that?", :options => ["Y", "n"], :default => "y") == "n"
-          Zenflow::Github.set_user
+          Zenflow::Github.set_user(Zenflow::Github::DEFAULT_HUB)
         end
       else
-        Zenflow::Github.set_user
+        Zenflow::Github.set_user(Zenflow::Github::DEFAULT_HUB)
       end
     end
 
     desc "authorize_github", "Get an auth token from GitHub"
     def authorize_github
-      if Zenflow::Github.zenflow_token
+      if Zenflow::Github.zenflow_token(Zenflow::Github::DEFAULT_HUB)
         if Zenflow::Ask("You already have a token from GitHub. Do you want to set a new one?", :options => ["y", "N"], :default => "n") == "y"
-          Zenflow::Github.authorize
+          Zenflow::Github.authorize(Zenflow::Github::DEFAULT_HUB)
         end
       else
-        Zenflow::Github.authorize
+        Zenflow::Github.authorize(Zenflow::Github::DEFAULT_HUB)
       end
     end
 
@@ -87,6 +89,17 @@ module Zenflow
         end
       end
 
+      def configure_github
+        #TODO: consolidate these two paths
+        if Zenflow::Repo.is_default_hub?
+          set_up_github
+          authorize_github
+        else
+          Zenflow::Hubs.config
+          Zenflow::Hubs.authorize
+        end
+      end
+
       def configure_project
         Zenflow::Log("Project")
         Zenflow::Config[:project] = Zenflow::Ask("What is the name of this project?", :required => true)

data/lib/zenflow/commands/hubs.rb

@@ -0,0 +1,124 @@
+module Zenflow
+  class Hubs < Thor
+
+    desc "list", "Show all configured hubs."
+    def list
+      Zenflow::Log("Recogized hubs")
+      Zenflow::Log(Terminal::Table.new(
+        headings: ['Hub'],
+        rows: get_list_of_hubs()
+      ).to_s, indent: false, arrows: false, color: false)
+    end
+
+    desc "current", "Show the current project's hub."
+    def current
+      Zenflow::Log("This project's hub is #{hub_label(Zenflow::Repo.hub)}")
+    end
+
+    desc "describe [HUB]", "Show configuration details for HUB (current project hub if none specified, or default hub if no current project)."
+    def describe(hub=nil)
+      hub = Zenflow::Github.resolve_hub(hub)
+
+      Zenflow::Log("Configuration details for hub #{hub_label(hub)}")
+
+      Zenflow::Log(Terminal::Table.new(
+        headings: ["Parameter", "Github Config Key", "Github Config Value", "Value (with system defaults)"],
+        rows: Zenflow::Github.describe_hub(hub)
+      ).to_s, indent: false, arrows: false, color: false)
+    end
+
+    desc "config [HUB]", "Configure the specified HUB (current project hub if none specified, or default hub if no current project)."
+    def config(hub=nil)
+      hub = Zenflow::Github.resolve_hub(hub)
+
+      Zenflow::Log("Configuring #{hub_label(hub)}")
+
+      config_api_base_url(hub)
+      config_user(hub)
+      config_user_agent_base(hub)
+    end
+
+    desc "authorize [HUB]", "Grab an auth token for HUB (current project hub if none specified, or default hub if no current project)."
+    def authorize(hub=nil)
+      hub = Zenflow::Github.resolve_hub(hub)
+
+      Zenflow::Log("Authorizing #{hub_label(hub)}")
+
+      if Zenflow::Github.zenflow_token(hub)
+        if Zenflow::Ask("You already have a token from GitHub. Do you want to set a new one?", :options => ["y", "N"], :default => "n") == "y"
+          Zenflow::Github.authorize(hub)
+        end
+      else
+        Zenflow::Github.authorize(hub)
+      end
+    end
+
+    no_commands {
+      def get_list_of_hubs
+        hub_config_parameters = Zenflow::Shell.run("git config --get-regexp zenflow\.hub\..*", silent: true).split("\n")
+
+        # unique, sorted, list of hubs with at least one valid config key
+        configured_hubs = hub_config_parameters.inject([]) { |hubs, parameter|
+          if parameter =~ /^zenflow\.hub\.(.*)\.#{config_keys_regex}\s.*$/
+            hubs << [hub_label($1)]
+          end
+
+          hubs
+        }.sort.uniq
+
+        [
+          ["#{hub_label(Zenflow::Github::DEFAULT_HUB)}"]
+        ] + configured_hubs
+      end
+
+      def hub_label(hub)
+        "#{hub}#{default_hub_tag(hub)}#{current_hub_tag(hub)}"
+      end
+
+      def default_hub_tag(hub)
+        Zenflow::Repo.is_default_hub?(hub) ? " [default]" : ""
+      end
+
+      def current_hub_tag(hub)
+        Zenflow::Repo.is_current_hub?(hub) ? " [current]" : ""
+      end
+
+      def config_keys_regex
+        "(?:#{Zenflow::Github::CONFIG_KEYS.map { |s| s.gsub('.','\\.') }.join('|')})"
+      end
+
+      def config_api_base_url(hub)
+        api_base_url = Zenflow::Github.api_base_url(hub,false)
+        if api_base_url.to_s != ''
+          if Zenflow::Ask("The GitHub API base URL for this hub is currently #{api_base_url}. Do you want to use that?", :options => ["Y", "n"], :default => "y") == "n"
+            Zenflow::Github.set_api_base_url(hub)
+          end
+        else
+          Zenflow::Github.set_api_base_url(hub)
+        end
+      end
+
+      def config_user(hub)
+        user = Zenflow::Github.user(hub)
+        if user.to_s != ''
+          if Zenflow::Ask("The GitHub user for this hub is currently #{user}. Do you want to use that?", :options => ["Y", "n"], :default => "y") == "n"
+            Zenflow::Github.set_user(hub)
+          end
+        else
+          Zenflow::Github.set_user(hub)
+        end
+      end
+
+      def config_user_agent_base(hub)
+        user_agent_base = Zenflow::Github.user_agent_base(hub,false)
+        if user_agent_base.to_s != ''
+          if Zenflow::Ask("The GitHub User Agent base for this hub is currently #{user_agent_base}. Do you want to use that?", :options => ["Y", "n"], :default => "y") == "n"
+            Zenflow::Github.set_user_agent_base(hub)
+          end
+        else
+          Zenflow::Github.set_user_agent_base(hub)
+        end
+      end
+    }
+  end
+end

data/lib/zenflow/helpers/github.rb

@@ -1,25 +1,52 @@
 module Zenflow
 
   module Github
-    def self.user
-      get_config('github.user')
+    DEFAULT_HUB = 'github.com'
+
+    DEFAULT_API_BASE_URL = 'https://api.github.com'
+    DEFAULT_USER_AGENT_BASE = 'Zencoder'
+
+    API_BASE_URL_KEY = 'api.base.url'
+    USER_KEY = 'github.user'
+    TOKEN_KEY = 'token'
+    USER_AGENT_BASE_KEY = 'user.agent.base'
+
+    CONFIG_KEYS = [
+      API_BASE_URL_KEY,
+      USER_KEY,
+      TOKEN_KEY,
+      USER_AGENT_BASE_KEY
+    ]
+
+    def self.api_base_url(hub=nil,useDefaultValue=true)
+      api_base_url = get_config_for_hub(hub, API_BASE_URL_KEY)
+      api_base_url ||= DEFAULT_API_BASE_URL if useDefaultValue
+      api_base_url
     end
 
-    def self.zenflow_token
-      get_config('zenflow.token')
+    def self.set_api_base_url(hub=nil)
+      api_base_url = Zenflow::Ask("What is the base URL of your Github API?", {:default => DEFAULT_API_BASE_URL})
+      set_config_for_hub(hub, API_BASE_URL_KEY, api_base_url)
     end
 
-    def self.get_config(key)
-      config = Zenflow::Shell.run("git config --get #{key.to_s}", silent: true)
-      config = config.chomp unless config.nil?
-      config
+    def self.user(hub=nil)
+      get_config_for_hub(hub, USER_KEY)
+    end
+
+    def self.set_user(hub=nil)
+      username = Zenflow::Ask("What is your Github username?")
+      set_config_for_hub(hub, USER_KEY, username)
+    end
+
+    def self.zenflow_token(hub=nil)
+      get_config_for_hub(hub, TOKEN_KEY)
     end
 
-    def self.authorize
-      Zenflow::Log("Authorizing with GitHub... Enter your GitHub password.")
-      oauth_response = JSON.parse(Zenflow::Shell.run(%{curl -u "#{Zenflow::Github.user}" https://api.github.com/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, silent: true))
+    def self.authorize(hub=nil)
+      Zenflow::Log("Authorizing with GitHub (#{user(hub)}@#{resolve_hub(hub)})... Enter your GitHub password.")
+      oauth_response = JSON.parse(Zenflow::Shell.run(%{curl -u "#{Zenflow::Github.user(hub)}" #{Zenflow::Github.api_base_url(hub)}/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, silent: true))
       if oauth_response['token']
-        Zenflow::Shell.run("git config --global zenflow.token #{oauth_response['token']}", silent: true)
+        set_config_for_hub(hub, TOKEN_KEY, oauth_response['token'])
         Zenflow::Log("Authorized!")
       else
         Zenflow::Log("Something went wrong. Error from GitHub was: #{oauth_response['message']}")
@@ -27,18 +54,69 @@ module Zenflow
       end
     end
 
-    def self.set_user
-      username = Zenflow::Ask("What is your Github username?")
-      Zenflow::Shell.run("git config --global github.user #{username}", silent: true)
+    def self.user_agent_base(hub=nil,useDefaultValue=true)
+      user_agent_base = get_config_for_hub(hub, USER_AGENT_BASE_KEY)
+      user_agent_base ||= DEFAULT_USER_AGENT_BASE if useDefaultValue
+      user_agent_base
+    end
+
+    def self.set_user_agent_base(hub=nil)
+      user_agent_base = Zenflow::Ask("What base string would you like to use for the User Agent header, 'User-Agent: [user-agent-base]/Zenflow-#{VERSION}?", {:default => DEFAULT_USER_AGENT_BASE})
+      set_config_for_hub(hub, USER_AGENT_BASE_KEY, user_agent_base)
+    end
+
+    def self.resolve_hub(hub)
+      hub || Zenflow::Repo.hub || DEFAULT_HUB
+    end
+
+    # If this repo is not hosted on the default github, construct a key prefix containing the hub information
+    def self.construct_key_for_hub(hub, key)
+      default_hub_key_prefix = key == USER_KEY ? "" : "zenflow."  # preserves backwards compatibility
+      Zenflow::Repo.is_default_hub?(hub) ? "#{default_hub_key_prefix}#{key}" : "zenflow.hub.#{hub}.#{key}"
+    end
+
+    def self.get_config_for_hub(hub, key)
+      resolved_hub = resolve_hub(hub)
+      key_for_hub = construct_key_for_hub(resolved_hub, key)
+      get_global_config(key_for_hub)
+    end
+
+    def self.set_config_for_hub(hub, key, value)
+      resolved_hub = resolve_hub(hub)
+      key_for_hub = construct_key_for_hub(resolved_hub, key)
+      set_global_config(key_for_hub, value)
+    end
+
+    def self.get_global_config(key)
+      config = Zenflow::Shell.run("git config --get #{key.to_s}", silent: true)
+      config = config.chomp unless config.nil?
+      config.to_s == '' ? nil : config
+    end
+
+    def self.set_global_config(key, value)
+      Zenflow::Shell.run("git config --global #{key} #{value}", silent: true)
+    end
+
+    def self.describe_hub_parameter(name, hub, key, value)
+      [name, construct_key_for_hub(hub, key), get_config_for_hub(hub, key), value]
+    end
+
+    def self.describe_hub(hub)
+      [
+        describe_hub_parameter("API Base URL",    hub, API_BASE_URL_KEY,    api_base_url(hub)),
+        describe_hub_parameter("User",            hub, USER_KEY,            user(hub)),
+        describe_hub_parameter("Token",           hub, TOKEN_KEY,           zenflow_token(hub)),
+        describe_hub_parameter("User Agent Base", hub, USER_AGENT_BASE_KEY, user_agent_base(hub))
+      ]
     end
   end
 
   class GithubRequest
     include HTTParty
-    base_uri "https://api.github.com/repos/#{Zenflow::Repo.slug}"
+    base_uri "#{Zenflow::Github.api_base_url}/repos/#{Zenflow::Repo.slug}"
     format :json
     headers "Authorization" => "token #{Zenflow::Github.zenflow_token}"
-    headers "User-Agent" => "Zencoder/Zenflow-#{VERSION}"
+    headers "User-Agent" => "#{Zenflow::Github.user_agent_base}/Zenflow-#{VERSION}"
   end
 
 end

data/lib/zenflow/helpers/repo.rb

@@ -5,9 +5,21 @@ module Zenflow
       `git remote -v`[/^#{Zenflow::Config[:remote] || 'origin'}\s+(.*?)\s/, 1]
     end
 
+    def self.hub
+      (url && url[/\w+@(.*?):.*?\.git/, 1]) || nil
+    end
+
     def self.slug
       (url && url[/:(.*?)\.git/, 1]) || nil
     end
 
+    def self.is_current_hub?(check)
+      hub == check
+    end
+
+    def self.is_default_hub?(check=nil)
+      (check ? check : hub) == Zenflow::Github::DEFAULT_HUB
+    end
+
   end
 end

data/spec/zenflow/commands/hubs_spec.rb

@@ -0,0 +1,372 @@
+require 'spec_helper'
+
+describe Zenflow::Hubs do
+  let(:hubs) { Zenflow::Hubs.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::Repo.should_receive(:is_default_hub?).at_least(:once).with(anything()).and_return(false)
+      Zenflow::Repo.should_receive(:is_current_hub?).at_least(:once).with(anything()).and_return(false)
+      Zenflow.should_receive(:Log).with("Recogized hubs")
+      Terminal::Table.should_receive(:new).with(
+        headings: ["Hub"],
+        rows: [
+          ["github.com"],
+          ["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)
+      hubs.list
+    end
+  end
+
+  describe '.current' do
+    it 'logs the hubs of the current project' do
+      Zenflow::Repo.should_receive(:hub).twice.and_return('my-hub')
+      Zenflow.should_receive(:Log).with("This project's hub is my-hub [current]")
+      hubs.current
+    end
+  end
+
+  describe '.describe' do
+    it 'displays config parameters for the hub' do
+      hubs.should_receive(:hub_label).with('my-hub').and_return('my-hub')
+      Zenflow.should_receive(:Log).with("Configuration details for hub my-hub")
+      Zenflow::Github.should_receive(:describe_hub).with('my-hub').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})
+      hubs.describe('my-hub')
+    end
+  end
+
+  describe '.config' do
+    it 'calls the individual parameter config methods' do
+      Zenflow::Github.should_receive(:resolve_hub).with('my-hub').and_return('my-hub')
+      hubs.should_receive(:hub_label).with('my-hub').and_return('my-hub')
+      Zenflow.should_receive(:Log).with("Configuring my-hub")
+      hubs.should_receive(:config_api_base_url).with('my-hub')
+      hubs.should_receive(:config_user).with('my-hub')
+      hubs.should_receive(:config_user_agent_base).with('my-hub')
+      hubs.config('my-hub')
+    end
+  end
+
+  describe '.config_user' 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 'asks for a user' do
+          Zenflow::Github.should_receive(:set_user)
+          hubs.config_user('my-hub')
+        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::Github.should_not_receive(:set_user)
+          hubs.config_user('my-hub')
+        end
+      end
+    end
+
+    context 'when a user is not already saved' do
+      before do
+        Zenflow::Github.should_receive(:user).and_return(nil)
+      end
+
+      it 'asks for a user' do
+        Zenflow::Github.should_receive(:set_user)
+        hubs.config_user('my-hub')
+      end
+    end
+  end
+
+  describe '.authorize' do
+    before do
+      Zenflow::Github.should_receive(:resolve_hub).with('my-hub').and_return('my-hub')
+      hubs.should_receive(:hub_label).with('my-hub').and_return('my-hub')
+      Zenflow.should_receive(:Log).with("Authorizing my-hub")
+    end
+
+    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).with('my-hub')
+          hubs.authorize('my-hub')
+        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)
+          hubs.authorize('my-hub')
+        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).with('my-hub')
+        hubs.authorize('my-hub')
+      end
+    end
+  end
+
+  describe '.hub_label' do
+    context 'hub is default hub' do
+      context 'hub is current hub' do
+        before(:each){
+          Zenflow::Repo.should_receive(:hub).and_return(Zenflow::Github::DEFAULT_HUB)
+        }
+
+        it 'returns the expected label' do
+          expect(hubs.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){
+          Zenflow::Repo.should_receive(:hub).and_return('current-hub')
+        }
+
+        it 'returns the expected label' do
+          expect(hubs.hub_label(Zenflow::Github::DEFAULT_HUB)).to eq("#{Zenflow::Github::DEFAULT_HUB} [default]")
+        end
+      end
+    end
+
+    context 'hub is not default hub' do
+      context 'hub is current hub' do
+        before(:each){
+          Zenflow::Repo.should_receive(:hub).and_return('current-hub')
+        }
+
+        it 'returns the expected label' do
+          expect(hubs.hub_label('current-hub')).to eq('current-hub [current]')
+        end
+      end
+
+      context 'hub is not current hub' do
+        before(:each){
+          Zenflow::Repo.should_receive(:hub).and_return('default-hub')
+        }
+
+        it 'returns the expected label' do
+          expect(hubs.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(hubs.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(hubs.default_hub_tag('not-default-hub')).to eq('')
+      end
+    end
+  end
+
+  describe '.current_hub_tag' do
+    before(:each){
+      Zenflow::Repo.should_receive(:hub).and_return('current-hub')
+    }
+
+    context 'hub is current hub' do
+      it 'returns the expected tag' do
+        expect(hubs.current_hub_tag('current-hub')).to eq(' [current]')
+      end
+    end
+
+    context 'hub is not current hub' do
+      it 'returns the expected tag' do
+        expect(hubs.current_hub_tag('not-current-hub')).to eq('')
+      end
+    end
+  end
+
+  describe '.config_key_regex' do
+    it 'returns the expected regex' do
+      expect(hubs.config_keys_regex).to eq('(?:api\\.base\\.url|github\\.user|token|user\\.agent\\.base)')
+    end
+  end
+
+  describe '.config_api_base_url' do
+    context 'when a github api base url is already saved' do
+      before do
+        Zenflow::Github.should_receive(:api_base_url).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::Github.should_receive(:set_api_base_url)
+          hubs.config_api_base_url('my-hub')
+        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::Github.should_not_receive(:set_api_base_url)
+          hubs.config_api_base_url('my-hub')
+        end
+      end
+    end
+
+    context 'when an api base url is not already saved' do
+      before do
+        Zenflow::Github.should_receive(:api_base_url).and_return(nil)
+      end
+
+      it 'asks for an api base url' do
+        Zenflow::Github.should_receive(:set_api_base_url)
+        hubs.config_api_base_url('my-hub')
+      end
+    end
+  end
+
+  describe '.config_user' 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 'asks for a user' do
+          Zenflow::Github.should_receive(:set_user)
+          hubs.config_user('my-hub')
+        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::Github.should_not_receive(:set_user)
+          hubs.config_user('my-hub')
+        end
+      end
+    end
+
+    context 'when a user is not already saved' do
+      before do
+        Zenflow::Github.should_receive(:user).and_return(nil)
+      end
+
+      it 'asks for a user' do
+        Zenflow::Github.should_receive(:set_user)
+        hubs.config_user('my-hub')
+      end
+    end
+  end
+
+  describe '.config_user_agent_base' do
+    context 'when a github user agent base is already saved' do
+      before do
+        Zenflow::Github.should_receive(:user_agent_base).and_return('user-agent-base')
+      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 agent base' do
+          Zenflow::Github.should_receive(:set_user_agent_base)
+          hubs.config_user_agent_base('my-hub')
+        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 agent base' do
+          Zenflow::Github.should_not_receive(:set_user_agent_base)
+          hubs.config_user_agent_base('my-hub')
+        end
+      end
+    end
+
+    context 'when a user agent base is not already saved' do
+      before do
+        Zenflow::Github.should_receive(:user_agent_base).and_return(nil)
+      end
+
+      it 'asks for a user agent base' do
+        Zenflow::Github.should_receive(:set_user_agent_base)
+        hubs.config_user_agent_base('my-hub')
+      end
+    end
+  end
+end

data/spec/zenflow/helpers/cli_spec.rb

@@ -272,9 +272,33 @@ describe Zenflow::CLI do
   end
 
   describe "#init" do
+    context "when in a project that doesn't belong to the default hub" 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(false)
+        end
+
+        it 'configures zenflow' do
+          subject.should_not_receive(:already_configured)
+          Zenflow::Hubs.should_receive(:config)
+          Zenflow::Hubs.should_receive(:authorize)
+          subject.should_receive(:configure_project)
+          subject.should_receive(:configure_branches)
+          subject.should_receive(:configure_merge_strategy)
+          subject.should_receive(:configure_remotes)
+          subject.should_receive(:confirm_some_stuff)
+          subject.should_receive(:set_up_changelog)
+          Zenflow::Config.should_receive(:save!)
+          subject.init
+        end
+      end
+    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(true)
       end
 
       it 'configures zenflow' do
@@ -298,6 +322,10 @@ describe Zenflow::CLI do
       end
 
       context 'and it is forced to initialize' do
+        before do
+          Zenflow::Repo.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)

data/spec/zenflow/helpers/github_spec.rb

@@ -1,15 +1,63 @@
 require 'spec_helper'
 
 describe Zenflow::Github do
+  describe '.api_base_url' do
+    context 'when the value is present' do
+      before(:each){
+        Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'api.base.url').and_return("api-base-url")
+      }
+
+      context 'and default is true' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.api_base_url('test-hub', true)).to eq("api-base-url")
+        end
+      end
+
+      context 'and default is false' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.api_base_url('test-hub', false)).to eq("api-base-url")
+        end
+      end
+    end
+
+    context 'when the value is absent' do
+      before(:each){
+        Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'api.base.url').and_return(nil)
+      }
+
+      context 'and default is true' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.api_base_url('test-hub', true)).to eq("https://api.github.com")
+        end
+      end
+
+      context 'and default is false' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.api_base_url('test-hub', 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 '.user' do
     let(:user){'github-user'}
 
     before(:each){
-      Zenflow::Shell.should_receive(:run).and_return(user)
+      Zenflow::Github.should_receive(:get_config_for_hub).with('test-hub', 'github.user').and_return(user)
     }
 
     it "returns the user" do
-      expect(Zenflow::Github.user).to eq(user)
+      expect(Zenflow::Github.user('test-hub')).to eq(user)
     end
   end
 
@@ -18,7 +66,7 @@ describe Zenflow::Github do
 
     it 'asks for the user name and sets it to github.user' do
       Zenflow.should_receive(:Ask).and_return(user)
-      Zenflow::Shell.should_receive(:run).with(/github\.user #{user}/, silent: true)
+      Zenflow::Github.should_receive(:set_config_for_hub).with(nil, 'github.user', user)
       Zenflow::Github.set_user
     end
   end
@@ -26,9 +74,10 @@ describe Zenflow::Github do
   describe '.authorize' do
     context "when authorization fails" do
       before do
-        Zenflow.should_receive("Log").with("Authorizing with GitHub... Enter your GitHub password.")
-        Zenflow::Github.should_receive(:user).and_return('adamkittelson')
-        Zenflow::Shell.should_receive(:run).and_return('{"message": "failed to authorize, bummer"}')
+        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"}')
       end
 
       it "logs that something went wrong" do
@@ -39,17 +88,266 @@ describe Zenflow::Github do
 
     context "when authorization succeeds" do
       before do
-        Zenflow.should_receive("Log").with("Authorizing with GitHub... Enter your GitHub password.")
-        Zenflow::Github.should_receive(:user).and_return('adamkittelson')
-        Zenflow::Shell.should_receive(:run).with(%{curl -u "adamkittelson" https://api.github.com/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, :silent => true).and_return('{"token": "super secure token"}')
+        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"}')
       end
 
       it "adds the token to git config and logs a happy message of success" do
-        Zenflow::Shell.should_receive(:run).with("git config --global zenflow.token super secure token", :silent => true)
+        Zenflow::Github.should_receive(:set_config_for_hub).with(nil, 'token', "super secure token")
         Zenflow.should_receive("Log").with("Authorized!")
         Zenflow::Github.authorize
       end
     end
 
   end
+
+  describe '.user_agent_base' do
+    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")
+      }
+
+      context 'and default is true' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.user_agent_base('test-hub', true)).to eq("user-agent-base")
+        end
+      end
+
+      context 'and default is false' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.user_agent_base('test-hub', 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)
+      }
+
+      context 'and default is true' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.user_agent_base('test-hub', true)).to eq("Zencoder")
+        end
+      end
+
+      context 'and default is false' do
+        it 'returns the expected value' do
+          expect(Zenflow::Github.user_agent_base('test-hub', false)).to eq(nil)
+        end
+      end
+    end
+  end
+
+  describe '.set_user_agent_base' do
+    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
+
+  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 '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 'returns the repo hub' do
+          expect(Zenflow::Github.resolve_hub(nil)).to eq 'repo-hub'
+        end    
+      end
+
+      context 'and the repo hub is nil' do
+        before(:each){
+          Zenflow::Repo.should_receive(:hub).and_return(nil)
+        }
+
+        it 'returns the default hub' do
+          expect(Zenflow::Github.resolve_hub(nil)).to eq Zenflow::Github::DEFAULT_HUB
+        end    
+      end
+    end
+  end
+
+  describe '.construct_key_for_hub' do
+    context 'when hub is the default hub' do
+      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")
+        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')
+        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")
+        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")
+        end
+      end
+    end
+
+    context 'hub is not the default hub' do
+      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")
+        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")
+        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")
+        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")
+        end
+      end
+    end
+  end
+
+  describe '.get_config_for_hub' do
+    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')
+    end
+  end
+
+  describe '.set_config_for_hub' do
+    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')
+    end
+  end
+
+  describe '.get_global_config' do
+    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')
+      end
+    end
+
+    context 'when value is missing' do
+      before(:each){
+        Zenflow::Shell.should_receive(:run).with('git config --get key', silent: true).and_return('')
+      }
+
+      it 'returns nil' do
+        expect(Zenflow::Github.get_global_config('key')).to eq(nil)
+      end
+    end
+  end
+
+  describe '.set_global_config' do
+    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')
+    end
+  end
+
+  describe '.config_keys' do
+    it 'returns the expected array of keys' do
+      expect(Zenflow::Github::CONFIG_KEYS).to eq([
+        'api.base.url',
+        'github.user',
+        'token',
+        'user.agent.base'
+      ])
+    end
+  end
+
+  describe '.describe_hub_parameter' do
+    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(
+        ['name', 'zenflow.hub.my-hub.key', 'config-value', 'value']
+      )
+    end
+  end
+
+  describe '.describe_hub' do
+    context 'all parameters configured' do
+      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')
+
+        expect(Zenflow::Github.describe_hub('my-hub')).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'],
+          ['User Agent Base', 'zenflow.hub.my-hub.user.agent.base', 'user-agent-base-config-value', 'user-agent-base-config-value']
+        ])
+      end
+    end
+
+    context 'no parameters configured' do
+      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)
+
+        expect(Zenflow::Github.describe_hub('my-hub')).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],
+          ['User Agent Base', 'zenflow.hub.my-hub.user.agent.base', nil, 'Zencoder']
+        ])
+      end
+    end
+
+    context 'hub is default' do
+      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)
+
+        expect(Zenflow::Github.describe_hub('github.com')).to eq([
+          ['API Base URL',    'zenflow.api.base.url',    nil, 'https://api.github.com'],
+          ['User',            'github.user',             nil, nil],
+          ['Token',           'zenflow.token',           nil, nil],
+          ['User Agent Base', 'zenflow.user.agent.base', nil, 'Zencoder']
+        ])
+      end
+    end
+  end
 end

data/spec/zenflow/helpers/repo_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Zenflow::Repo do
+  describe '.hub' do
+    before(:each){  
+      Zenflow::Repo.should_receive(:url).twice.and_return("git@github.com:zencoder/zenflow.git")
+    }
+
+    it 'selects the hub from the git remote -v url' do
+      expect(Zenflow::Repo.hub).to eq("github.com")
+    end
+  end
+
+  describe '.slug' do
+    before(:each){  
+      Zenflow::Repo.should_receive(:url).twice.and_return("git@github.com:zencoder/zenflow.git")
+    }
+
+    it 'selects the repo slug from the git remote -v url' do
+      expect(Zenflow::Repo.slug).to eq("zencoder/zenflow")
+    end
+  end
+
+  describe '.is_current_hub?' do
+    before(:each){  
+      Zenflow::Repo.should_receive(:url).twice.and_return("git@github.com:zencoder/zenflow.git")
+    }
+
+    context 'when check matches hub' do
+      it 'returns true' do
+        expect(Zenflow::Repo.is_current_hub?("github.com")).to eq(true)
+      end
+    end
+
+    context 'when check does not match hub' do
+      it 'returns false' do
+        expect(Zenflow::Repo.is_current_hub?("my-hub")).to eq(false)
+      end
+    end
+  end
+
+  describe '.is_default_hub?' do
+    context 'when check is not supplied' do
+      context 'and current hub matches default hub' do
+        before(:each){  
+          Zenflow::Repo.should_receive(:url).twice.and_return("git@github.com:zencoder/zenflow.git")
+        }
+
+        it 'returns true' do
+          expect(Zenflow::Repo.is_default_hub?).to eq(true)
+        end
+      end
+
+      context 'and current hub does not match default hub' do
+        before(:each){  
+          Zenflow::Repo.should_receive(:url).twice.and_return("git@my-hub:zencoder/zenflow.git")
+        }
+
+        it 'returns true' do
+          expect(Zenflow::Repo.is_default_hub?).to eq(false)
+        end
+      end
+    end
+
+    context 'when check is supplied' do
+      context 'and check matches default hub' do
+        it 'returns true' do
+          expect(Zenflow::Repo.is_default_hub?("github.com")).to eq(true)
+        end
+      end
+
+      context 'and check does not match default hub' do
+        it 'returns false' do
+          expect(Zenflow::Repo.is_default_hub?("my-hub")).to eq(false)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zenflow
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.8.6
 platform: ruby
 authors:
 - Adam Kittelson
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-13 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -194,6 +194,7 @@ files:
 - lib/zenflow/commands/deploy.rb
 - lib/zenflow/commands/feature.rb
 - lib/zenflow/commands/hotfix.rb
+- lib/zenflow/commands/hubs.rb
 - lib/zenflow/commands/release.rb
 - lib/zenflow/commands/reviews.rb
 - lib/zenflow/helpers/ask.rb
@@ -232,6 +233,7 @@ files:
 - spec/zenflow/commands/deploy_spec.rb
 - spec/zenflow/commands/feature_spec.rb
 - spec/zenflow/commands/hotfix_spec.rb
+- spec/zenflow/commands/hubs_spec.rb
 - spec/zenflow/commands/release_spec.rb
 - spec/zenflow/commands/reviews_spec.rb
 - spec/zenflow/helpers/ask_spec.rb
@@ -243,6 +245,7 @@ files:
 - spec/zenflow/helpers/help_spec.rb
 - spec/zenflow/helpers/log_spec.rb
 - spec/zenflow/helpers/pull_request_spec.rb
+- spec/zenflow/helpers/repo_spec.rb
 - spec/zenflow/helpers/shell_spec.rb
 - spec/zenflow/helpers/version_spec.rb
 - zenflow.gemspec
@@ -266,7 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Branch management and deployment tool.