hrk 0.0.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8df14c2ca4330a91a5cf758825844724e93a4b6
-  data.tar.gz: 4cf32f72933c72821c09b662ed07fbb62525e3bf
+  metadata.gz: 6dfbf2f64a50461372620e5d7aa9bcc4295de6d5
+  data.tar.gz: ab1f2fe43247946ce291faadadaeb4e10f7fcb2a
 SHA512:
-  metadata.gz: fbaf173a98a54834352a8bd0122d21561760f4a6d8f77922b44aac0a2d702b7ecac4a72ac51cdb4fd93c2669693b8a270c6bc91cb99a5940adf3a0f47e67032a
-  data.tar.gz: 98edc74b9c2f69ca20be31d9d3b84319da03046a02aff5bf55bb94d17c47103159482daa6f1ccc122b2e0291cfa7fe269780aa5c899de6eb272f63b971e61e3b
+  metadata.gz: 9cbe4f176099d1f231cc492ec591e6307255ee5e46bb051cd984854576065305dac3c17dcf959199725522978703eb6a1c69a2f82a95fa99e5216be9e650e28a
+  data.tar.gz: 905d3bb4978f67bdbfd55a3e67897e7559a88254a59d8f1bc45d33fa9759f272603de513972195a8f54f46ef364b1ddad7cf416140cf6db1129a282e3038af94

data/README.md

@@ -1,6 +1,9 @@
 # Hrk
+[![Gem Version](https://badge.fury.io/rb/hrk.svg)](http://badge.fury.io/rb/hrk)
+[![Build Status](https://travis-ci.org/Bastes/hrk.svg?branch=master)](https://travis-ci.org/Bastes/hrk)
+[![Dependency Status](https://gemnasium.com/Bastes/hrk.svg)](https://gemnasium.com/Bastes/hrk)
 
-Hrk 2 swim like a dolphin in a sea of heroku commands
+Hrk remembers your heroku remotes for you.
 
 ```
       ,|
@@ -21,17 +24,19 @@ Hrk 2 swim like a dolphin in a sea of heroku commands
           ``--''        `
 ```
 
+Hrk 2 swim like a dolphin in a sea of heroku commands
+
 ## Getting started
 
 You can install the Hrk gem using the gem command:
 
-```
+```bash
 $ gem install hrk
 ```
 
 Or through bundler:
 
-```
+```ruby
 # in your Gemfile
 gem 'hrk', group: :development
 
@@ -39,7 +44,7 @@ $ bundle install
 ```
 
 And enjoy the hrk command awesome power:
-```
+```bash
 $ hrk logs -r your-heroku-remote-name && hrk run console
 ```
 
@@ -50,7 +55,7 @@ It's a command that calls the heroku toolbelt command for you, remembers the
 name of the previous remote so you don't have to re-type it again and again
 and again each time you want to chain heroku commands.
 
-For example, let's say I've got an heroku app that's called:
+For example, let's say I've got an heroku app which remote is called:
 
 > this-really-long-remote-name
 
@@ -75,13 +80,18 @@ And sometimes you mistype, and the chain breaks in the middle, and it sucks.
 **Wait, I can do something like that**
 
 ```bash
-$ export REMOTE_NAME=this-really-long-remote-name && \
-  heroku run rake do:something:else -r $REMOTE_NAME && \
-  heroku run rake other:thing       -r $REMOTE_NAME && \
-  heroku run rake yet:another:task  -r $REMOTE_NAME
+$ export HEROKU_APP=this-app-name-that-is-usually-even-longer-than-the-remote-name && \
+  heroku run rake do:something:else && \
+  heroku run rake other:thing       && \
+  heroku run rake yet:another:task
 ```
 
-Yup. Now It doesn't look really that better now does it?
+Yup, it works.
+Still feels like one command too many.
+Still have to remember the names of my apps for each project instead of using my
+aptly, conventionnaly named remotes ('test', 'staging', 'prod'...).
+
+Isn't there a better way?
 
 **Hrk to the rescue!**
 
@@ -157,10 +167,63 @@ $ hrk maintenance:on -a my-super-duper-app && \ # happens on my-super-duper-app
   hrk maintenance:off                           # aaand on my-super-duper-app
 ```
 
+**...if I don't chain commands?**
+
+Hrk has been designed to help when chaining commands, but it will remember your
+last remote until you close your terminal. So this will work:
+
+```bash
+$ hrk logs -r demo
+...
+$ hrk console # happens on demo
+```
+
+This also means you have to be a little careful not to forget on which remote
+you are. We are currently planning on adding a little more security there, so
+stay tuned.
+
+## Where will it run?
+
+It should run on Linux and MacOSX, provided you've installed ruby.
+
+It might run on Windows, although it hasn't been tested and relies on system
+commands that might be different. If you're a windows user and would like to
+give it a try, please do send us your issues and / or pull requests to make hrk
+run there.
+
 ## Do I still need the heroku toolbelt?
 
 Yes. The hrk command calls the heroku command for you, it does not replace it.
 
+## How do I contribute?
+
+In many ways:
+
+**If you're having fun using hrk...**
+
+...you can of course give your feedback and ideas for improvements through
+[github issues](https://github.com/Bastes/hrk/issues).
+
+**If you'd like to tweak something...**
+
+Fork the project on the [github page](https://github.com/Bastes/hrk/issues)
+and do what you want with it, that's what free software (and github) is for.
+
+If you added something awesome or killed a nasty bug and want everybody to
+rejoice, you can send a pull request and it'll be merged (or you'll receive an
+explaination why it won't as is).
+
+Pull requests with specs improve their chances to be accepted, so don't shy away
+from adding / changing / fixing the specs.
+
+If you'd like to to help on current issues, feel also free to browse them and
+attack the ones you'd like to get your hands on. Pull requests that fix issues
+are always welcome.
+
+And if you read the code and feel your eyes start to bleed, maybe you can
+notify me (preferably after consulting a good eye doctor). Code reviews lead to
+better code, and better code makes hrk happy.
+
 ## Very important warning!
 
 Hrk is pronounced like "a shark" because it's funny.

data/lib/hrk.rb

@@ -1,6 +1,6 @@
-module Hrk
-  VERSION = '0.0.8'
+require 'hrk/version'
 
+module Hrk
   autoload :Env,     'hrk/env'
   autoload :Heroku,  'hrk/heroku'
   autoload :Execute, 'hrk/execute'

data/lib/hrk/env.rb

@@ -5,30 +5,78 @@ require 'tmpdir'
 
 module Hrk
   class Env
-    def remote= *args
-      if args
-        socket_path.write args.join(' ') unless remote == args
-      else
-        socket_path.delete if remote?
+    attr_reader :tty_digest
+
+    def initialize
+      @tty_digest = Digest::MD5.hexdigest(`tty`)
+    end
+
+    def schedule_cleanup!
+      unless cleanup_scheduled?
+        self.pid = fork do
+          at_exit { cleanup! }
+          while(true) do
+            `tty`
+            exit if $? != 0
+            sleep 1
+          end
+        end
       end
     end
 
+    def cleanup!
+      remote_path.delete if remote_path.exist?
+      pid_path.delete    if pid_path.exist?
+    end
+
+    def remote= args
+      schedule_cleanup!
+      remote_path.write args.join(' ') unless remote == args
+    end
+
     def remote
-      socket_path.read.split(' ', 2) if remote?
+      remote_path.read.split(' ', 2) if remote?
     end
 
     def remote?
-      socket_path.exist?
+      remote_path.exist?
     end
 
     def tmp_path
-      Pathname.
-        new(File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, 'hrk')).
+      tmp_dir.join('hrk').
         tap { |path| FileUtils.mkdir_p(path) unless path.exist? }
     end
 
-    def socket_path
-      tmp_path.join Digest::MD5.hexdigest(`tty`)
+    def tmp_dir
+      Pathname.new(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir)
+    end
+
+    def remote_path
+      tmp_path.join tty_digest
+    end
+
+    def cleanup_scheduled?
+      begin
+        pid? && Process.kill(0, pid)
+      rescue Errno::ESRCH
+        false
+      end
+    end
+
+    def pid
+      pid_path.read.to_i if pid?
+    end
+
+    def pid?
+      pid_path.exist?
+    end
+
+    def pid= value
+      pid_path.write(value)
+    end
+
+    def pid_path
+      tmp_path.join "#{tty_digest}.pid"
     end
   end
 end

data/lib/hrk/execute.rb

@@ -4,12 +4,11 @@ module Hrk
     autoload :Help,    'hrk/execute/help'
 
     def self.call *args
-      executer.call *args
+      executer.call(*args)
     end
 
     def self.executer
-      Hrk::Execute::Help.new \
-        Hrk::Execute::Command.new
+      Help.new Command.new
     end
   end
 end

data/lib/hrk/execute/help.rb

@@ -9,7 +9,7 @@ module Hrk
         if args.empty? || args.first =~ %r(\A(?:(?:(?:-)?h)|(?:(?:--)?help))\Z)
           display || true
         else
-          fallback *args
+          fallback(*args)
         end
       end
 
@@ -40,7 +40,7 @@ https://github.com/Bastes/hrk
 
       def fallback *args
         if @fallback
-          @fallback.call *args
+          @fallback.call(*args)
         else
           raise ArgumentError.new
         end

data/lib/hrk/heroku.rb

@@ -5,13 +5,13 @@ module Hrk
     end
 
     def call *command
-      validate! *command
+      validate! command
       system 'heroku', *(command + @remote)
     end
 
     private
 
-    def validate! *command
+    def validate! command
       remote = (command.each_cons(2).detect { |(parameter, _)| parameter =~ %r{\A-[ar]\Z} }.join ' ' rescue nil)
       raise ExplicitApplicationError.new, "You're calling a command on remote #{@remote.join " "} yet the command explicitly references #{remote}" if remote
     end

data/lib/hrk/version.rb

@@ -0,0 +1,3 @@
+module Hrk
+  VERSION = '1.0.0'
+end

data/spec/hrk/env_spec.rb

@@ -0,0 +1,283 @@
+require 'spec_helper'
+
+RSpec.describe Hrk::Env do
+  subject(:env) { Hrk::Env.new }
+
+  shared_context 'fake remote_path' do
+    let(:remote_path) { double(Pathname) }
+
+    before { allow(remote_path).to receive(:delete) }
+    before { allow(remote_path).to receive(:write) }
+    before { allow(env).to receive(:remote_path).and_return remote_path }
+  end
+
+  shared_context 'fake pid_path' do
+    let(:pid_path) { double(Pathname) }
+
+    before { allow(pid_path).to receive(:write) }
+    before { allow(pid_path).to receive(:delete) }
+    before { allow(env).to receive(:pid_path).and_return pid_path }
+  end
+
+  shared_context 'fake tty' do
+    let(:tty) { "/dev/pts/#{rand(1..9)}" }
+
+    before { allow_any_instance_of(Hrk::Env).to receive(:`).and_return(tty) }
+  end
+
+  describe '#initialize' do
+    include_context 'fake tty'
+
+    subject!(:env) { Hrk::Env.new }
+
+    it { expect(env.tty_digest).to eq Digest::MD5.hexdigest(tty) }
+  end
+
+  describe '#cleanup!' do
+    include_context 'fake remote_path'
+    include_context 'fake pid_path'
+
+    let(:the_remote_pre_exist) { [true, false].sample }
+    let(:the_pid_pre_exist)    { [true, false].sample }
+    before { allow(remote_path).to receive(:exist?).and_return the_remote_pre_exist }
+    before { allow(pid_path).to receive(:exist?).and_return the_pid_pre_exist }
+
+    before { env.cleanup! }
+
+    context 'the remote file pre-exists' do
+      let(:the_remote_pre_exist) { true }
+
+      it { expect(remote_path).to have_received(:delete) }
+    end
+
+    context 'the remote file does not pre-exists' do
+      let(:the_remote_pre_exist) { false }
+
+      it { expect(remote_path).not_to have_received(:delete) }
+    end
+
+    context 'the pid file pre-exists' do
+      let(:the_pid_pre_exist) { true }
+
+      it { expect(pid_path).to have_received(:delete) }
+    end
+
+    context 'the pid file does not pre-exists' do
+      let(:the_pid_pre_exist) { false }
+
+      it { expect(pid_path).not_to have_received(:delete) }
+    end
+  end
+
+  describe '#remote=' do
+    include_context 'fake remote_path'
+
+    let(:remote_arg)   { "-#{%w(a r).sample}" }
+    let(:remote_name)  { "remote##{rand(1..9)}" }
+
+    before { allow(env).to receive(:remote).and_return(previous_remote) }
+    before { allow(env).to receive(:schedule_cleanup!) }
+
+    before { env.remote = [remote_arg, remote_name] }
+
+    context 'no previous remote' do
+      let(:previous_remote) { nil }
+
+      it { expect(remote_path).to have_received(:write).with("#{remote_arg} #{remote_name}") }
+    end
+
+    context 'the previous remote is different' do
+      let(:previous_remote) { ['-r', 'previous'] }
+
+      it { expect(remote_path).to have_received(:write).with("#{remote_arg} #{remote_name}") }
+      it { expect(env).to have_received(:schedule_cleanup!) }
+    end
+
+    context 'the previous remote is identical' do
+      let(:previous_remote) { [remote_arg, remote_name] }
+
+      it { expect(remote_path).not_to have_received(:write) }
+      it { expect(env).to have_received(:schedule_cleanup!) }
+    end
+  end
+
+  describe '#remote' do
+    include_context 'fake remote_path'
+
+    before { allow(remote_path).to receive(:exist?).and_return it_pre_exist }
+    before { allow(remote_path).to receive(:read).and_return remote }
+
+    context 'no remote file exists' do
+      let(:it_pre_exist) { false }
+      let(:remote)       { nil }
+
+      it { expect(env.remote).to eq nil }
+    end
+
+    context 'the remote file exists' do
+      let(:it_pre_exist) { true }
+      let(:remote_arg)   { "-#{%w(a r).sample}" }
+      let(:remote_name)  { "remote##{rand(1..9)}" }
+      let(:remote)       { "#{remote_arg} #{remote_name}" }
+
+      it { expect(env.remote).to eq [remote_arg, remote_name] }
+    end
+  end
+
+  describe '#remote?' do
+    include_context 'fake remote_path'
+
+    before { allow(remote_path).to receive(:exist?).and_return it_pre_exist }
+
+    context 'the remote file exists' do
+      let(:it_pre_exist) { true }
+
+      it { expect(env.remote?).to eq true }
+    end
+
+    context 'the remote file does not exist' do
+      let(:it_pre_exist) { false }
+
+      it { expect(env.remote?).to eq false }
+    end
+  end
+
+  describe '#tmp_path' do
+    let(:some_dir) { Pathname.new "/some#{rand(1..9)}/fake/dir" }
+    before { allow(env).to receive(:tmp_dir).and_return(some_dir) }
+    before { allow_any_instance_of(Pathname).to receive(:exist?).and_return(it_pre_exist) }
+    before { allow(FileUtils).to receive(:mkdir_p) }
+
+    subject!(:path) { env.tmp_path }
+
+    context 'the path did not already exist' do
+      let(:it_pre_exist) { false }
+
+      it { expect(path).to eq Pathname.new("#{some_dir}/hrk") }
+      it { expect(FileUtils).to have_received(:mkdir_p).with(path) }
+    end
+
+    context 'the path did already exist' do
+      let(:it_pre_exist) { true }
+
+      it { expect(path).to eq Pathname.new("#{some_dir}/hrk") }
+      it { expect(FileUtils).not_to have_received(:mkdir_p) }
+    end
+  end
+
+  describe '#tmp_dir' do
+    let(:tmpdir)          { "/another/silly/path#{rand(1..9)}" }
+    before { allow(Dir).to receive(:tmpdir).and_return(tmpdir) }
+    before { allow(ENV).to receive(:[]).with('XDG_RUNTIME_DIR').and_return(xdg_runtime_dir) }
+    context 'there is an XDG_RUNTIME_DIR in the ENV' do
+      let(:xdg_runtime_dir) { "/yet_again/a#{rand(1..9)}/folder" }
+
+      it { expect(env.tmp_dir).to eq Pathname.new(xdg_runtime_dir) }
+    end
+
+    context 'there is no XDG_RUNTIME_DIR in the ENV' do
+      let(:xdg_runtime_dir) { nil }
+
+      it { expect(env.tmp_dir).to eq Pathname.new(tmpdir) }
+    end
+  end
+
+  describe '#remote_path' do
+    include_context 'fake tty'
+
+    let(:some_dir) { Pathname.new "/and#{rand(1..9)}/another_/dir" }
+
+    before { allow(env).to receive(:tmp_path).and_return(Pathname.new(some_dir)) }
+
+    it { expect(env.remote_path).to eq Pathname.new("#{some_dir}/#{Digest::MD5.hexdigest(tty)}") }
+  end
+
+  describe '#cleanup_scheduled?' do
+    let(:pid) { rand(1000..99999) }
+    before { allow(env).to receive(:pid).and_return(pid) }
+    before { allow(env).to receive(:pid?).and_return(the_pid_exist) }
+
+    context 'there is no pid file' do
+      let(:the_pid_exist)        { false }
+      let(:the_process_be_alive) { [false, true].sample }
+
+      it { expect(env.cleanup_scheduled?).to be_falsy }
+    end
+
+    context 'there is a pid file' do
+      let(:the_pid_exist) { true }
+
+      context 'the process is alived' do
+        let(:the_process_be_alive) { true }
+        before { allow(Process).to receive(:kill).with(0, pid).and_return(the_process_be_alive) }
+
+        it { expect(env.cleanup_scheduled?).to be_truthy }
+      end
+
+      context 'the process is dead' do
+        let(:the_process_be_alive) { false }
+        before { allow(Process).to receive(:kill).with(0, pid).and_raise(Errno::ESRCH) }
+
+        it { expect(env.cleanup_scheduled?).to be_falsy }
+      end
+    end
+  end
+
+  describe '#pid' do
+    include_context 'fake pid_path'
+
+    before { allow(pid_path).to receive(:exist?).and_return it_pre_exist }
+    before { allow(pid_path).to receive(:read).and_return pid }
+
+    context 'no pid file exists' do
+      let(:it_pre_exist) { false }
+      let(:pid)          { nil }
+
+      it { expect(env.pid).to eq nil }
+    end
+
+    context 'the pid file exists' do
+      let(:it_pre_exist) { true }
+      let(:pid)          { "#{rand(1000..99999)}" }
+
+      it { expect(env.pid).to eq pid.to_i }
+    end
+  end
+
+  describe '#pid?' do
+    include_context 'fake pid_path'
+
+    before { allow(pid_path).to receive(:exist?).and_return it_pre_exist }
+
+    context 'the pid file exists' do
+      let(:it_pre_exist) { true }
+
+      it { expect(env.pid?).to eq true }
+    end
+
+    context 'the pid file does not exist' do
+      let(:it_pre_exist) { false }
+
+      it { expect(env.pid?).to eq false }
+    end
+  end
+
+  describe '#pid=' do
+    let(:pid)      { rand(1000..99999) }
+    include_context 'fake pid_path'
+
+    before { env.pid = pid }
+
+    it { expect(pid_path).to have_received(:write).with(pid) }
+  end
+
+  describe '#pid_path' do
+    include_context 'fake tty'
+
+    let(:some_dir) { Pathname.new "/and#{rand(1..9)}/another_/dir" }
+
+    before { allow(env).to receive(:tmp_path).and_return(Pathname.new(some_dir)) }
+
+    it { expect(env.pid_path).to eq Pathname.new("#{some_dir}/#{Digest::MD5.hexdigest(tty)}.pid") }
+  end
+end

data/spec/hrk/execute/command_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Hrk::Execute::Command do
             end
 
             describe 'interactions' do
-              before { command.call opt, remote, *args }
+              before { command.call(opt, remote, *args) }
 
               it { expect(Hrk::Heroku).to have_received(:new).with(opt, remote) }
               it { expect(heroku).to have_received(:call).with(*%w{whatever that:may -b}) }
@@ -46,9 +46,9 @@ RSpec.describe Hrk::Execute::Command do
 
         it { expect { command.call }.to raise_error ArgumentError }
         it { expect { command.call "parameterless-remote", *other_args }.to raise_error ArgumentError }
-        it { expect { command.call *other_args }.to raise_error ArgumentError }
-        it { expect { command.call *other_args, '-r' }.to raise_error ArgumentError }
-        it { expect { command.call *other_args, '-a' }.to raise_error ArgumentError }
+        it { expect { command.call(*other_args) }.to raise_error ArgumentError }
+        it { expect { command.call(*other_args, '-r') }.to raise_error ArgumentError }
+        it { expect { command.call(*other_args, '-a') }.to raise_error ArgumentError }
         it { expect { command.call '-r', 'remote', *other_args, '-r', 'other-remote' }.to raise_error ArgumentError }
         it { expect { command.call '-r', 'remote', *other_args, '-a', 'app' }.to raise_error ArgumentError }
         it { expect { command.call '-a', 'app', *other_args, '-a', 'other-app' }.to raise_error ArgumentError }
@@ -94,7 +94,7 @@ RSpec.describe Hrk::Execute::Command do
         end
 
         describe 'interactions' do
-          before { command.call *args }
+          before { command.call(*args) }
 
           it { expect(Hrk::Heroku).to have_received(:new).with('-r', previous_remote) }
           it { expect(heroku).to have_received(:call).with(*%w{whatever that:may -b}) }
@@ -107,12 +107,12 @@ RSpec.describe Hrk::Execute::Command do
         before { expect(heroku).not_to receive(:call) }
         before { expect(command.env).not_to receive(:remote=) }
 
-        it { expect { command.call *other_args, '-r' }.to raise_error ArgumentError }
-        it { expect { command.call *other_args, '-a' }.to raise_error ArgumentError }
-        it { expect { command.call '-r', 'remote', *other_args, '-r', 'other-remote' }.to raise_error ArgumentError }
-        it { expect { command.call '-r', 'remote', *other_args, '-a', 'app' }.to raise_error ArgumentError }
-        it { expect { command.call '-a', 'app', *other_args, '-a', 'other-app' }.to raise_error ArgumentError }
-        it { expect { command.call '-r', 'something', *other_args, '-a', 'something-else' }.to raise_error ArgumentError }
+        it { expect { command.call(*other_args, '-r') }.to raise_error ArgumentError }
+        it { expect { command.call(*other_args, '-a') }.to raise_error ArgumentError }
+        it { expect { command.call('-r', 'remote', *other_args, '-r', 'other-remote') }.to raise_error ArgumentError }
+        it { expect { command.call('-r', 'remote', *other_args, '-a', 'app') }.to raise_error ArgumentError }
+        it { expect { command.call('-a', 'app', *other_args, '-a', 'other-app') }.to raise_error ArgumentError }
+        it { expect { command.call('-r', 'something', *other_args, '-a', 'something-else') }.to raise_error ArgumentError }
       end
     end
   end

data/spec/hrk/execute_spec.rb

@@ -16,4 +16,13 @@ RSpec.describe Hrk::Execute do
       end
     end
   end
+
+  describe '.executer' do
+    let(:help)    { double(Hrk::Execute::Help) }
+    let(:command) { double(Hrk::Execute::Command) }
+    before { allow(Hrk::Execute::Help).to receive(:new).with(command).and_return(help) }
+    before { allow(Hrk::Execute::Command).to receive(:new).and_return(command) }
+
+    it { expect(Hrk::Execute.executer).to eq help }
+  end
 end

data/spec/hrk/heroku_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Hrk::Heroku do
         describe "calling '#{command.join ' '}' on remote '#{on_remote}', system" do
           subject(:heroku) { Hrk::Heroku.new(*on_remote) }
 
-          before { heroku.call *command }
+          before { heroku.call(*command) }
 
           it { expect(heroku).to have_received(:system).with(*starts) }
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hrk
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Michel Belleville
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-07 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -128,6 +128,8 @@ files:
 - lib/hrk/execute/command.rb
 - lib/hrk/execute/help.rb
 - lib/hrk/heroku.rb
+- lib/hrk/version.rb
+- spec/hrk/env_spec.rb
 - spec/hrk/execute/command_spec.rb
 - spec/hrk/execute/help_spec.rb
 - spec/hrk/execute_spec.rb
@@ -156,5 +158,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Hrk remembers your heroku remotes
+summary: Hrk remembers your heroku remotes for you.
 test_files: []