hanzo 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05ff7891e2f1cd3041503706e0e8f29d743666a6
-  data.tar.gz: 2383e9fc6c162684aea15a41ef99e82844d990d2
+  metadata.gz: 5bf18b51a540cd3579bf82622bfd45fc4f034449
+  data.tar.gz: af91b4057463254d56c85702720fd50e7c99148c
 SHA512:
-  metadata.gz: 74429412cca30fffd9865f3082a7b9a25572e264a73a46f25e84264dbd0e4e4e990c86213400c3a65ca3db4ece09e0ddf472f4974d39704a960f5c0ab6642544
-  data.tar.gz: e06c64150b810ea024dc36f699d4f6a2aabb3e45f945dedf894817e839f2ca73bb60f6541452f7b1e2ef3ad0a4b222bf8d9f96ff9fe1bc85eb4cb2f02cefdadf
+  metadata.gz: 98700c6b8a43094637a57ba492730ba12894e213ec6cd59b30b1f6ee40d8823ad23a968147b9ecfb5e7687bad8c78cfb064a07332429b82e1d00140311f9a0d1
+  data.tar.gz: a0ddffdf1bac4fd26f7b6cb618f887a60ef25ef70238d492777448f4e1d8bfc3183e0b09e094c752b53cb51aec0c571573cd4b75f12b8b8f0f3594a22e63d615

data/.rubocop.yml

@@ -0,0 +1,58 @@
+Documentation:
+  Enabled: false
+
+Encoding:
+  Enabled: false
+
+LineLength:
+  Max: 200
+
+ClassLength:
+  Max: 200
+
+AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+IfUnlessModifier:
+  Enabled: false
+
+CaseIndentation:
+  IndentWhenRelativeTo: case
+  IndentOneStep: true
+
+MethodLength:
+  CountComments: false
+  Max: 20
+
+SignalException:
+  Enabled: false
+
+ColonMethodCall:
+  Enabled: false
+
+AsciiComments:
+  Enabled: false
+
+Lambda:
+  Enabled: false
+
+RegexpLiteral:
+  Enabled: false
+
+RedundantBegin:
+  Enabled: false
+
+AssignmentInCondition:
+  Enabled: false
+
+ParameterLists:
+  Enabled: false
+
+ClassAndModuleChildren:
+  Enabled: false
+
+DoubleNegation:
+  Enabled: false
+
+TrivialAccessors:
+  ExactNameMatch: true

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 
 rvm:
+  - 2.1.2
   - 2.0.0
   - 1.9.3
 

data/bin/hanzo

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w(.. lib))
 
 require 'hanzo'
 

data/hanzo.gemspec

@@ -14,14 +14,16 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/mirego/hanzo'
   spec.license       = 'BSD 3-Clause'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split("\n")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(spec)/})
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'phare', '~> 0.6'
+  spec.add_development_dependency 'rubocop', '~> 0.24'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '~> 3.1'
 
   spec.add_dependency 'highline', '>= 1.6.19'
 end

data/lib/hanzo/cli.rb

@@ -3,7 +3,7 @@ require 'hanzo/modules/install'
 require 'hanzo/modules/config'
 
 module Hanzo
- class CLI < Base
+  class CLI < Base
     def run
       @options.parse!(@args) if @opts.respond_to? :parse!
       puts @options unless @options.to_s == "Usage: hanzo [options]\n"
@@ -16,7 +16,7 @@ module Hanzo
     end
 
     def initialize_cli
-      initialize_help and return if @app.nil?
+      initialize_help && return if @app.nil?
 
       begin
         @options = Hanzo.const_get(@app.capitalize).new(@args).options

data/lib/hanzo/fetchers/environment.rb

@@ -0,0 +1,27 @@
+module Hanzo
+  module Fetchers
+    class Environment
+      def initialize(env)
+        @env = env
+      end
+
+      def exist?
+        environments.include?(@env)
+      end
+
+      def installed?
+        installed_environments.include?(@env)
+      end
+
+    protected
+
+      def installed_environments
+        Hanzo::Installers::Remotes.installed_environments
+      end
+
+      def environments
+        Hanzo::Installers::Remotes.environments
+      end
+    end
+  end
+end

data/lib/hanzo/heroku.rb

@@ -1,9 +1,8 @@
 module Hanzo
   module Heroku
     class << self
-
       def available_labs
-        Hanzo.run("heroku labs").each_line.to_a.inject([]) do |memo, line|
+        Hanzo.run('heroku labs').each_line.to_a.reduce([]) do |memo, line|
           if line = /^\[\s\]\s+(?<name>\w+)\s+(?<description>.+)$/.match(line)
             memo << [line[:name], line[:description]]
           else
@@ -11,7 +10,6 @@ module Hanzo
           end
         end
       end
-
     end
   end
 end

data/lib/hanzo/modules/config.rb

@@ -1,11 +1,10 @@
 module Hanzo
   class Config < Base
-
     def compare
-      Hanzo.title "Fetching environment variables"
+      Hanzo.title('Fetching environment variables')
       fetch_variables
 
-      Hanzo.title "Comparing environment variables"
+      Hanzo.title('Comparing environment variables')
       compare_variables
     end
 
@@ -16,7 +15,8 @@ module Hanzo
     end
 
     def initialize_cli
-      initialize_help and return if @type != "compare"
+      initialize_help && return if @type != 'compare'
+
       compare
     end
 
@@ -32,7 +32,7 @@ module Hanzo
   private
 
     def fetch_variables
-      @variables = Hanzo::Installers::Remotes.environments.keys.inject({}) do |memo, env|
+      @variables = Hanzo::Installers::Remotes.environments.keys.reduce({}) do |memo, env|
         # Fetch the variables over at Heroku
         config = Hanzo.run("heroku config -r #{env}", true).split("\n")
 

data/lib/hanzo/modules/deploy.rb

@@ -1,21 +1,24 @@
 module Hanzo
   class Deploy < Base
+    UnknownEnvironment = Class.new(StandardError)
+    UninstalledEnvironment = Class.new(StandardError)
 
   protected
 
     def initialize_variables
       @env = extract_argument(1)
-
-      if @env.nil? and Hanzo::Installers::Remotes.environments.keys.length == 1
-        @env = Hanzo::Installers::Remotes.environments.keys.first
-      end
+      @env ||= Hanzo::Installers::Remotes.environments.keys.first
     end
 
     def initialize_cli
-      initialize_help and return if @env.nil?
-
-      deploy
-      run_migrations
+      initialize_help && return if @env.nil?
+
+      deploy && run_migrations
+    rescue UnknownEnvironment
+      Hanzo.unindent_print "Environment `#{@env}` doesn't exist. Add it to .heroku-remotes and run:\n  hanzo install remotes", :red
+      Hanzo.unindent_print "\nFor more information, read https://github.com/mirego/hanzo#install-remotes", :red
+    rescue UninstalledEnvironment
+      Hanzo.unindent_print "Environment `#{@env}` has been found in your .heroku-remotes file. Before using it, you must install it:\n  hanzo install remotes", :red
     end
 
     def initialize_help
@@ -31,20 +34,28 @@ module Hanzo
     end
 
     def deploy
-      branch = Hanzo.ask("Branch to deploy in #{@env}:") { |q| q.default = "HEAD" }
+      validate_environment_existence!
+
+      branch = Hanzo.ask("Branch to deploy in #{@env}:") { |q| q.default = 'HEAD' }
 
       Hanzo.run "git push -f #{@env} #{branch}:master"
     end
 
     def run_migrations
-      if Dir.exists?('db/migrate')
-        migration = Hanzo.agree('Run migrations?')
+      return unless Dir.exist?('db/migrate')
+      return unless Hanzo.agree('Run migrations?')
 
-        if migration
-          Hanzo.run "heroku run rake db:migrate --remote #{@env}"
-          Hanzo.run "heroku ps:restart --remote #{@env}"
-        end
-      end
+      Hanzo.run "heroku run rake db:migrate --remote #{@env}"
+      Hanzo.run "heroku ps:restart --remote #{@env}"
+    end
+
+    def validate_environment_existence!
+      raise UnknownEnvironment unless fetcher.exist?
+      raise UninstalledEnvironment unless fetcher.installed?
+    end
+
+    def fetcher
+      @fetcher ||= Hanzo::Fetchers::Environment.new(@env)
     end
   end
 end

data/lib/hanzo/modules/install.rb

@@ -13,7 +13,7 @@ module Hanzo
     end
 
     def initialize_cli
-      initialize_help and return if @type.nil?
+      initialize_help && return if @type.nil?
 
       method = "install_#{@type}"
 

data/lib/hanzo/modules/installers/labs.rb

@@ -2,13 +2,13 @@ module Hanzo
   module Installers
     module Labs
       def install_labs
-        Hanzo.title 'Activating Heroku Labs'
+        Hanzo.title('Activating Heroku Labs')
 
-        Hanzo::Heroku.available_labs.each do |name, description|
-          if Hanzo.agree("Add #{name}?")
-            Hanzo::Installers::Remotes.environments.each_pair do |env, app|
-              Hanzo::Installers::Labs.enable(env, name)
-            end
+        Hanzo::Heroku.available_labs.each do |name, _|
+          next unless Hanzo.agree("Add #{name}?")
+
+          Hanzo::Installers::Remotes.environments.each_pair do |env, _|
+            Hanzo::Installers::Labs.enable(env, name)
           end
         end
       end

data/lib/hanzo/modules/installers/remotes.rb

@@ -16,12 +16,16 @@ module Hanzo
       end
 
       def self.environments
-        return YAML.load_file('.heroku-remotes') if File.exists?('.heroku-remotes')
+        return YAML.load_file('.heroku-remotes') if File.exist?('.heroku-remotes')
 
         Hanzo.print 'Cannot locate .heroku-remotes'
         Hanzo.print 'For more information, please read https://github.com/mirego/hanzo'
         exit
       end
+
+      def self.installed_environments
+        `git remote`.split("\n")
+      end
     end
   end
 end

data/lib/hanzo/version.rb

@@ -1,3 +1,3 @@
 module Hanzo
-  VERSION = '0.4.2'
+  VERSION = '0.4.3'
 end

data/lib/hanzo.rb

@@ -7,6 +7,8 @@ require 'hanzo/cli'
 require 'hanzo/heroku'
 require 'hanzo/version'
 
+require 'hanzo/fetchers/environment'
+
 module Hanzo
   def self.run(command, fetch_output = false)
     print(command, :green)
@@ -16,7 +18,7 @@ module Hanzo
       if fetch_output
         output = `#{command}`
       else
-        system(command)
+        output = system(command)
       end
     end
 
@@ -37,6 +39,11 @@ module Hanzo
     HighLine.say HighLine.color("       #{text}", *colors)
   end
 
+  def self.unindent_print(text = '', *colors)
+    colors = colors.map { |c| HighLine.const_get(c.to_s.upcase) }
+    HighLine.say HighLine.color(text, *colors)
+  end
+
   def self.title(text)
     HighLine.say HighLine.color("-----> #{text}", :blue)
   end
@@ -52,6 +59,6 @@ end
 
 class String
   def unindent
-    gsub /^#{scan(/^\s*/).min_by{|l|l.length}}/, ''
+    gsub(/^#{scan(/^\s*/).min_by { |l| l.length }}/, '')
   end
 end

data/spec/cli/config_spec.rb

@@ -5,7 +5,7 @@ describe Hanzo::CLI do
     let(:config!) { Hanzo::CLI.new(['config', action]) }
     let(:heroku_remotes) { { 'production' => 'heroku-app-production', 'qa' => 'heroku-app-qa' } }
 
-    before { Hanzo::Installers::Remotes.stub(:environments).and_return(heroku_remotes) }
+    before { expect(Hanzo::Installers::Remotes).to receive(:environments).and_return(heroku_remotes) }
 
     describe :compare do
       let(:action) { 'compare' }
@@ -16,31 +16,31 @@ describe Hanzo::CLI do
 
       let(:environment_one_name) { 'production' }
       let(:environment_two_name) { 'qa' }
-      let(:environment_one) {
-<<-RUBY
-SMTP_PORT:     25
-SMTP_PASSWORD: hanzo
-SMTP_HOST:     localhost
-RUBY
-      }
-      let(:environment_two) {
-<<-RUBY
-SMTP_PORT:     25
-SMTP_USERNAME: hanzo
-RUBY
-      }
+      let(:environment_one) do
+        <<-RUBY.unindent
+        SMTP_PORT:     25
+        SMTP_PASSWORD: hanzo
+        SMTP_HOST:     localhost
+        RUBY
+      end
+      let(:environment_two) do
+        <<-RUBY.unindent
+        SMTP_PORT:     25
+        SMTP_USERNAME: hanzo
+        RUBY
+      end
 
       before do
-        Hanzo.should_receive(:title).with(fetch_environment_title)
-        Hanzo.should_receive(:title).with(compare_environment_title)
+        expect(Hanzo).to receive(:title).with(fetch_environment_title)
+        expect(Hanzo).to receive(:title).with(compare_environment_title)
 
-        Hanzo.should_receive(:run).with("#{config_cmd} -r #{environment_one_name}", true).and_return(environment_one)
-        Hanzo.should_receive(:run).with("#{config_cmd} -r #{environment_two_name}", true).and_return(environment_two)
+        expect(Hanzo).to receive(:run).with("#{config_cmd} -r #{environment_one_name}", true).and_return(environment_one)
+        expect(Hanzo).to receive(:run).with("#{config_cmd} -r #{environment_two_name}", true).and_return(environment_two)
 
-        Hanzo.should_receive(:print).with("Missing variables in #{environment_one_name}", :yellow)
-        Hanzo.should_receive(:print).with(['- SMTP_USERNAME'])
-        Hanzo.should_receive(:print).with("Missing variables in #{environment_two_name}", :yellow)
-        Hanzo.should_receive(:print).with(['- SMTP_PASSWORD', '- SMTP_HOST'])
+        expect(Hanzo).to receive(:print).with("Missing variables in #{environment_one_name}", :yellow)
+        expect(Hanzo).to receive(:print).with(['- SMTP_USERNAME'])
+        expect(Hanzo).to receive(:print).with("Missing variables in #{environment_two_name}", :yellow)
+        expect(Hanzo).to receive(:print).with(['- SMTP_PASSWORD', '- SMTP_HOST'])
       end
 
       it 'should install specified labs for each environment' do

data/spec/cli/deploy_spec.rb

@@ -5,7 +5,6 @@ describe Hanzo::CLI do
     let(:env) { 'production' }
     let(:branch) { '1.0.0' }
     let(:deploy!) { Hanzo::CLI.new(['deploy', env]) }
-    let(:migrations_exist) { false }
     let(:heroku_remotes) { { 'production' => 'heroku-app-production' } }
     let(:migration_dir) { 'db/migrate' }
 
@@ -17,43 +16,71 @@ describe Hanzo::CLI do
     let(:deploy_cmd) { "git push -f #{env} #{branch}:master" }
 
     before do
-      Dir.should_receive(:exists?).with(migration_dir).and_return(migrations_exist)
-      Hanzo::Installers::Remotes.stub(:environments).and_return(heroku_remotes)
-      Hanzo.should_receive(:ask).with(deploy_question).and_return(branch)
-      Hanzo.should_receive(:run).with(deploy_cmd).once
+      expect(Hanzo::Installers::Remotes).to receive(:environments).and_return(['production'])
+      expect(Hanzo::Installers::Remotes).to receive(:installed_environments).and_return(['production'])
     end
 
-    context 'without migration' do
+    context 'successful deploy and without migrations' do
+      let(:migrations_exist) { false }
+      let(:deploy_result) { true }
+
+      before do
+        expect(Dir).to receive(:exist?).with(migration_dir).and_return(migrations_exist)
+        expect(Hanzo).to receive(:ask).with(deploy_question).and_return(branch)
+        expect(Hanzo).to receive(:run).with(deploy_cmd).once.and_return(deploy_result)
+      end
+
       it 'should git push to heroku upstream' do
         deploy!
       end
     end
 
-    context 'with migrations' do
+    context 'with existing migrations' do
       let(:migrations_exist) { true }
 
-      context 'that should be ran' do
+      before do
+        expect(Hanzo).to receive(:ask).with(deploy_question).and_return(branch)
+        expect(Hanzo).to receive(:run).with(deploy_cmd).once.and_return(deploy_result)
+      end
+
+      context 'with successful deploy' do
+        let(:deploy_result) { true }
+
         before do
-          Hanzo.should_receive(:agree).with(migration_question).and_return(true)
-          Hanzo.should_receive(:run).with(migration_cmd)
-          Hanzo.should_receive(:run).with(restart_cmd)
+          expect(Dir).to receive(:exist?).with(migration_dir).and_return(migrations_exist)
         end
 
-        it 'should run migrations' do
-          deploy!
+        context 'and migrations that should be ran' do
+          before do
+            expect(Hanzo).to receive(:agree).with(migration_question).and_return(true)
+            expect(Hanzo).to receive(:run).with(migration_cmd)
+            expect(Hanzo).to receive(:run).with(restart_cmd)
+          end
+
+          specify { deploy! }
+        end
+
+        context 'and migrations that should not be ran' do
+          before do
+            expect(Hanzo).to receive(:agree).with(migration_question).and_return(false)
+            expect(Hanzo).not_to receive(:run).with(migration_cmd)
+            expect(Hanzo).not_to receive(:run).with(restart_cmd)
+          end
+
+          specify { deploy! }
         end
       end
 
-      context 'that should not be ran' do
+      context 'without successful deploy' do
+        let(:deploy_result) { false }
+
         before do
-          Hanzo.should_receive(:agree).with(migration_question).and_return(false)
-          Hanzo.should_not_receive(:run).with(migration_cmd)
-          Hanzo.should_not_receive(:run).with(restart_cmd)
+          expect(Hanzo).not_to receive(:agree).with(migration_question)
+          expect(Hanzo).not_to receive(:run).with(migration_cmd)
+          expect(Hanzo).not_to receive(:run).with(restart_cmd)
         end
 
-        it 'should not run migrations' do
-          deploy!
-        end
+        specify { deploy! }
       end
     end
   end

data/spec/cli/install_spec.rb

@@ -10,20 +10,20 @@ describe Hanzo::CLI do
       let(:labs_title) { 'Activating Heroku Labs' }
       let(:available_labs) { { 'user-env-compile' => 'Description' } }
 
-      let(:enable_labs_cmd) { "heroku labs:enable" }
+      let(:enable_labs_cmd) { 'heroku labs:enable' }
       let(:enable_labs_info) { '- Enabled for' }
 
       before do
-        Hanzo::Installers::Remotes.stub(:environments).and_return(heroku_remotes)
-        Hanzo::Heroku.stub(:available_labs).and_return(available_labs)
-        Hanzo.should_receive(:title).with(labs_title)
+        expect(Hanzo::Installers::Remotes).to receive(:environments).and_return(heroku_remotes)
+        expect(Hanzo::Heroku).to receive(:available_labs).and_return(available_labs)
+        expect(Hanzo).to receive(:title).with(labs_title)
 
-        available_labs.each do |name, description|
-          Hanzo.should_receive(:agree).with("Add #{name}?").and_return(true)
+        available_labs.each do |name, _|
+          expect(Hanzo).to receive(:agree).with("Add #{name}?").and_return(true)
 
-          heroku_remotes.each do |env, app|
-            Hanzo.should_receive(:run).with("#{enable_labs_cmd} #{name} --remote #{env}")
-            Hanzo.should_receive(:print).with("#{enable_labs_info} #{env}")
+          heroku_remotes.each do |env, _|
+            expect(Hanzo).to receive(:run).with("#{enable_labs_cmd} #{name} --remote #{env}")
+            expect(Hanzo).to receive(:print).with("#{enable_labs_info} #{env}")
           end
         end
       end
@@ -37,15 +37,16 @@ describe Hanzo::CLI do
       let(:type) { 'remotes' }
       let(:create_remotes_title) { 'Creating git remotes' }
 
-      before { Hanzo.should_receive(:title).with(create_remotes_title) }
+      before { expect(Hanzo).to receive(:title).with(create_remotes_title) }
 
       context '.heroku-remotes exists' do
         before do
-          Hanzo::Installers::Remotes.stub(:environments).and_return(heroku_remotes)
+          expect(Hanzo::Installers::Remotes).to receive(:environments).and_return(heroku_remotes)
+
           heroku_remotes.each do |env, app|
-            Hanzo.should_receive(:print).with("Adding #{env}")
-            Hanzo.should_receive(:run).with("git remote rm #{env} 2>&1 > /dev/null")
-            Hanzo.should_receive(:run).with("git remote add #{env} git@heroku.com:#{app}.git")
+            expect(Hanzo).to receive(:print).with("Adding #{env}")
+            expect(Hanzo).to receive(:run).with("git remote rm #{env} 2>&1 > /dev/null")
+            expect(Hanzo).to receive(:run).with("git remote add #{env} git@heroku.com:#{app}.git")
           end
         end
 
@@ -55,10 +56,10 @@ describe Hanzo::CLI do
       end
 
       context '.heroku-remotes file is missing' do
-        before { Hanzo.should_receive(:print).twice }
+        before { expect(Hanzo).to receive(:print).twice }
 
         it 'should display error message' do
-          lambda { install! }.should raise_error SystemExit
+          expect { install! }.to raise_error SystemExit
         end
       end
     end

data/spec/fetchers/environment_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Hanzo::Fetchers::Environment do
+  let(:fetcher) { Hanzo::Fetchers::Environment.new(current_environment) }
+  let(:current_environment) { 'production' }
+
+  describe :exist? do
+    let(:environments) { ['production'] }
+
+    before { expect(fetcher).to receive(:environments).and_return(environments) }
+
+    context 'with an existing environment' do
+      it { expect(fetcher.exist?).to be_truthy }
+    end
+
+    context 'with an unexisting environment' do
+      let(:current_environment) { 'staging' }
+      it { expect(fetcher.exist?).to be_falsey }
+    end
+  end
+
+  describe :installed? do
+    let(:environments) { ['production'] }
+
+    before { expect(fetcher).to receive(:installed_environments).and_return(environments) }
+
+    context 'with an installed environment' do
+      it { expect(fetcher.installed?).to be_truthy }
+    end
+
+    context 'with an uninstalled environment' do
+      let(:current_environment) { 'staging' }
+      it { expect(fetcher.installed?).to be_falsey }
+    end
+  end
+
+  describe :installed_environments do
+    before { expect(Hanzo::Installers::Remotes).to receive(:installed_environments) }
+
+    specify { fetcher.send(:installed_environments) }
+  end
+
+  describe :environments do
+    before { expect(Hanzo::Installers::Remotes).to receive(:environments) }
+
+    specify { fetcher.send(:environments) }
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w(.. lib))
 
 require 'hanzo'
 
-RSpec.configure do |c|
+RSpec.configure do
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanzo
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Samuel Garneau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-24 00:00:00.000000000 Z
+date: 2015-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: phare
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -42,16 +70,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
@@ -76,6 +104,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE.md
@@ -86,6 +115,7 @@ files:
 - lib/hanzo.rb
 - lib/hanzo/base.rb
 - lib/hanzo/cli.rb
+- lib/hanzo/fetchers/environment.rb
 - lib/hanzo/heroku.rb
 - lib/hanzo/modules/config.rb
 - lib/hanzo/modules/deploy.rb
@@ -96,6 +126,7 @@ files:
 - spec/cli/config_spec.rb
 - spec/cli/deploy_spec.rb
 - spec/cli/install_spec.rb
+- spec/fetchers/environment_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/mirego/hanzo
 licenses:
@@ -125,4 +156,5 @@ test_files:
 - spec/cli/config_spec.rb
 - spec/cli/deploy_spec.rb
 - spec/cli/install_spec.rb
+- spec/fetchers/environment_spec.rb
 - spec/spec_helper.rb