heroku-commander 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rbx

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format=documentation
+

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby
+  - rbx
+
+notifications:
+  email:
+    - dblock@dblock.org

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+0.1.0 (01/31/2013)
+==================
+
+* Initial public release with support for `heroku config`, `heroku run` and `heroku run:detached` - [@dblock](https://github.com/dblock), [@macreery](https://github.com/macreery).

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "heroku"
+  gem "rake"
+  gem "bundler"
+  gem "rspec"
+end

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2012 Daniel Doubrovkine, Artsy Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+![](assets/heroku-commander.png)
+Heroku::Commander [![Build Status](https://travis-ci.org/dblock/heroku-commander.png?branch=master)](https://travis-ci.org/dblock/heroku-commander)
+=================
+
+Master the Heroku CLI from Ruby.
+
+Usage
+-----
+
+Add `heroku` and `heroku-commander` to Gemfile.
+
+``` ruby
+gem "heroku"
+gem "heroku-commander"
+```
+
+Heroku Configuration
+--------------------
+
+Returns a hash of an application's configuration (output from `heroku config`).
+
+
+``` ruby
+commander = Heroku::Commander.new({ :app => "heroku-commander" })
+commander.config # => a hash of all settings for the heroku-commander app
+```
+
+Heroku Run
+----------
+
+Executes a command via `heroku run`, pipes and returns output lines. Unlike the heroku client, this also checks the process return code and raises a `Heroku::Commander::Errors::CommandError` if the latter is not zero, which makes this suitable for Rake tasks.
+
+``` ruby
+commander = Heroku::Commander.new({ :app => "heroku-commander" })
+commander.run "uname -a" # => [ "Linux 2.6.32-348-ec2 #54-Ubuntu SMP x86_64 GNU" ]
+```
+
+Heroku Detached Run
+-------------------
+
+Executes a command via `heroku run:detached`, spawns a `heroku logs --tail -p pid` for the process started on Heroku, pipes and returns output lines. This also checks the process return code and raises a `Heroku::Commander::Errors::CommandError` if the latter is not zero.
+
+``` ruby
+commander = Heroku::Commander.new({ :app => "heroku-commander" })
+commander.run("uname -a", { :detached => true }) # => [ "Linux 2.6.32-348-ec2 #54-Ubuntu SMP x86_64 GNU" ]
+```
+
+You can examine the output from `heroku logs --tail -p pid` line-by-line.
+
+``` ruby
+commander.run("ls -R", { :detached => true }) do |line|
+  # each line from the output of the command
+end
+```
+
+For more information about Heroku one-off dynos see [this documentation](https://devcenter.heroku.com/articles/one-off-dynos).
+
+More Examples
+-------------
+
+See [examples](examples) for more.
+
+Contributing
+------------
+
+Fork the project. Make your feature addition or bug fix with tests. Send a pull request. Bonus points for topic branches.
+
+Copyright and License
+---------------------
+
+MIT License, see [LICENSE](LICENSE.md) for details.
+
+(c) 2013 [Daniel Doubrovkine](http://github.com/dblock), [Frank Macreery](http://github.com/macreery), [Artsy Inc.](http://artsy.net)

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'bundler/gem_tasks'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+

data/examples/heroku-config.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+require 'heroku-commander'
+
+logger = Logger.new($stdout)
+logger.level = Logger::DEBUG
+commander = Heroku::Commander.new({ :logger => logger })
+config = commander.config
+config.each_pair do |name, value|
+  logger.info "#{name}: #{value}"
+end

data/examples/heroku-run-detached.rb

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+require 'heroku-commander'
+
+logger = Logger.new($stdout)
+logger.level = Logger::DEBUG
+commander = Heroku::Commander.new({ :logger => logger })
+
+uname = commander.run "uname -a", { :detached => true }
+logger.info "Heroku dyno is a #{uname.join('\n')}."
+
+files = []
+commander.run "ls -1", { :detached => true } do |line|
+  files << line
+end
+logger.info "The Heroku file system has #{files.count} file(s): #{files.join(', ')}"

data/examples/heroku-run.rb

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+require 'heroku-commander'
+
+logger = Logger.new($stdout)
+logger.level = Logger::DEBUG
+commander = Heroku::Commander.new({ :logger => logger })
+
+uname = commander.run "uname -a"
+logger.info "Heroku dyno is a #{uname.join('\n')}."
+
+files = []
+commander.run "ls -1" do |line|
+  files << line
+end
+logger.info "The Heroku file system has #{files.count} file(s): #{files.join(', ')}"

data/heroku-commander.gemspec

@@ -0,0 +1,17 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "heroku/commander/version"
+
+Gem::Specification.new do |s|
+  s.name = "heroku-commander"
+  s.version = Heroku::Commander::VERSION
+  s.authors = [ "Daniel Doubrovkine", "Frank Macreery" ]
+  s.email = "dblock@dblock.org"
+  s.platform = Gem::Platform::RUBY
+  s.required_rubygems_version = '>= 1.3.6'
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = [ "lib" ]
+  s.homepage = "http://github.com/dblock/heroku-commander"
+  s.licenses = [ "MIT" ]
+  s.summary = "Control Heroku from Ruby via its `heroku` shell command."
+  s.add_dependency "i18n"
+end

data/lib/config/locales/en.yml

@@ -0,0 +1,26 @@
+en:
+  heroku:
+    commander:
+      errors:
+        messages:
+          client_eio:
+            message: "Heroku client stopped sending output."
+            summary: "The heroku client stopped sending output before exiting."
+            resolution: "This is unexpected and represents a Heroku server error. Try again."
+          command_error:
+            message: "The command `%{cmd}` failed with exit status %{status}."
+            summary: "%{message}%{lines}"
+            resolution: "Examine the command line and refer to the command documentation."
+          unexpected_output:
+            message: "The command `%{cmd}` returned unexpected output."
+            summary: "The output unexpectedly contained %{line}."
+            resolution: "This is unexpected and could represent a Heroku server error. Try again."
+          missing_command_error:
+            message: "Missing command."
+            summary: "The instance of Heroku::Runner is missing a command argument."
+            resolution: "Specify a command, for example:\n
+            \_\_Heroku::Runner.new({ :command => 'ls -1' })"
+          already_running_error:
+            message: "The process is already running with pid %{pid}."
+            summary: "You can only run! or detach! an instance of Heroku::Runner once."
+            resolution: "This is a bug in your code."

data/lib/heroku-commander.rb

@@ -0,0 +1,15 @@
+require 'i18n'
+
+I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
+
+require 'pty'
+require 'heroku/pty.rb'
+require 'logger'
+
+require 'heroku/commander/version'
+require 'heroku/commander/errors'
+require 'heroku/config'
+require 'heroku/commander'
+require 'heroku/executor'
+require 'heroku/runner'
+

data/lib/heroku/commander.rb

@@ -0,0 +1,25 @@
+module Heroku
+  class Commander
+
+    attr_accessor :app, :logger, :config
+
+    def initialize(options = {})
+      @app = options[:app]
+      @logger = options[:logger]
+    end
+
+    # Returns a loaded Heroku::Config instance.
+    def config
+      @config ||= Heroku::Config.new({ :app => app, :logger => logger }).tap do |config|
+        config.reload!
+      end
+    end
+
+    # Run a process synchronously
+    def run(command, options = {}, &block)
+      runner = Heroku::Runner.new({ :app => app, :logger => logger, :command => command })
+      runner.run!(options, &block)
+    end
+
+  end
+end

data/lib/heroku/commander/errors.rb

@@ -0,0 +1,6 @@
+require 'heroku/commander/errors/base'
+require 'heroku/commander/errors/client_eio_error'
+require 'heroku/commander/errors/command_error'
+require 'heroku/commander/errors/missing_command_error'
+require 'heroku/commander/errors/unexpected_output_error'
+require 'heroku/commander/errors/already_running_error'

data/lib/heroku/commander/errors/already_running_error.rb

@@ -0,0 +1,13 @@
+module Heroku
+  class Commander
+    module Errors
+      class AlreadyRunningError < Heroku::Commander::Errors::Base
+
+        def initialize(opts)
+          super(compose_message("already_running_error", opts))
+        end
+
+      end
+    end
+  end
+end

data/lib/heroku/commander/errors/base.rb

@@ -0,0 +1,81 @@
+module Heroku
+  class Commander
+    module Errors
+      class Base < StandardError
+
+        # Problem occurred.
+        attr_reader :problem
+
+        # Summary of the problem.
+        attr_reader :summary
+
+        # Suggested problem resolution.
+        attr_reader :resolution
+
+        # Compose the message.
+        # === Parameters
+        # [key] Lookup key in the translation table.
+        # [attributes] The objects to pass to create the message.
+        def compose_message(key, attributes = {})
+          @problem = create_problem(key, attributes)
+          @summary = create_summary(key, attributes)
+          @resolution = create_resolution(key, attributes)
+
+          "\nProblem:\n  #{@problem}"+
+          "\nSummary:\n  #{@summary}"+
+          "\nResolution:\n  #{@resolution}"
+        end
+
+        private
+
+          BASE_KEY = "heroku.commander.errors.messages" #:nodoc:
+
+          # Given the key of the specific error and the options hash, translate the
+          # message.
+          #
+          # === Parameters
+          # [key] The key of the error in the locales.
+          # [options] The objects to pass to create the message.
+          #
+          # Returns a localized error message string.
+          def translate(key, options)
+            ::I18n.translate("#{BASE_KEY}.#{key}", { :locale => :en }.merge(options)).strip
+          end
+
+          # Create the problem.
+          #
+          # === Parameters
+          # [key] The error key.
+          # [attributes] The attributes to interpolate.
+          #
+          # Returns the problem.
+          def create_problem(key, attributes)
+            translate("#{key}.message", attributes)
+          end
+
+          # Create the summary.
+          #
+          # === Parameters
+          # [key] The error key.
+          # [attributes] The attributes to interpolate.
+          #
+          # Returns the summary.
+          def create_summary(key, attributes)
+            translate("#{key}.summary", attributes)
+          end
+
+          # Create the resolution.
+          #
+          # === Parameters
+          # [key] The error key.
+          # [attributes] The attributes to interpolate.
+          #
+          # Returns the resolution.
+          def create_resolution(key, attributes)
+            translate("#{key}.resolution", attributes)
+          end
+
+      end
+    end
+  end
+end

data/lib/heroku/commander/errors/client_eio_error.rb

@@ -0,0 +1,11 @@
+module Heroku
+  class Commander
+    module Errors
+      class ClientEIOError < Heroku::Commander::Errors::Base
+        def initialize
+          super(compose_message("client_eio"))
+        end
+      end
+    end
+  end
+end

data/lib/heroku/commander/errors/command_error.rb

@@ -0,0 +1,34 @@
+module Heroku
+  class Commander
+    module Errors
+      class CommandError < Heroku::Commander::Errors::Base
+
+        attr_accessor :inner_exception
+
+        def initialize(opts = {})
+          @inner_exception = opts[:inner_exception]
+          super(compose_message("command_error", prepare_lines(opts)))
+        end
+
+        private
+
+          def prepare_lines(opts)
+            if opts[:lines] && opts[:lines].size > 4
+              lines = opts[:lines][0..2]
+              lines.push "... skipping #{opts[:lines].size - 4} line(s) ..."
+              lines.concat opts[:lines][-2..-1]
+              result = opts.dup
+              result[:lines] = "\n\t" + lines.join("\n\t")
+              result
+            elsif opts[:lines]
+              result = opts.dup
+              result[:lines] = "\n\t" + result[:lines].join("\n\t")
+              result
+            else
+              opts
+            end
+          end
+      end
+    end
+  end
+end

data/lib/heroku/commander/errors/missing_command_error.rb

@@ -0,0 +1,13 @@
+module Heroku
+  class Commander
+    module Errors
+      class MissingCommandError < Heroku::Commander::Errors::Base
+
+        def initialize
+          super(compose_message("missing_command_error"))
+        end
+
+      end
+    end
+  end
+end

data/lib/heroku/commander/errors/unexpected_output_error.rb

@@ -0,0 +1,14 @@
+module Heroku
+  class Commander
+    module Errors
+      class UnexpectedOutputError < Heroku::Commander::Errors::Base
+
+        attr_accessor :inner_exception
+
+        def initialize(opts)
+          super(compose_message("unexpected_output", opts))
+        end
+      end
+    end
+  end
+end

data/lib/heroku/commander/version.rb

@@ -0,0 +1,5 @@
+module Heroku
+  class Commander
+    VERSION = '0.1.0'
+  end
+end

data/lib/heroku/config.rb

@@ -0,0 +1,33 @@
+module Heroku
+  class Config < Hash
+
+    attr_accessor :app, :logger
+
+    def initialize(options = {})
+      @app = options[:app]
+      @logger = options[:logger]
+    end
+
+    def reload!
+      clear
+      cmd = cmdline
+      Heroku::Executor.run cmd, { :logger => logger } do |line|
+        logger.debug "< #{line}" if logger
+        parts = line.split "=", 2
+        raise Heroku::Commander::Errors::UnexpectedOutputError.new({
+          :cmd => cmd,
+          :line => line
+        }) if parts.size != 2
+        self[parts[0].strip] = parts[1].strip
+      end
+      self
+    end
+
+    protected
+
+      def cmdline
+        [ "heroku", "config", "-s", @app ? "--app #{@app}" : nil ].compact.join(" ")
+      end
+
+  end
+end

data/lib/heroku/executor.rb

@@ -0,0 +1,82 @@
+module Heroku
+  class Executor
+
+    class Terminate < StandardError
+    end
+
+    class << self
+
+      # Executes a command and yields output line-by-line.
+      def run(cmd, options = {}, &block)
+        lines = []
+        logger = options[:logger]
+        logger.debug "Running: #{cmd}" if logger
+        PTY.spawn(cmd) do |r, w, pid|
+          logger.debug "Started: #{pid}" if logger
+          terminated = false
+          begin
+            r.sync = true
+            r.each do |line|
+              line.strip! if line
+              logger.debug "#{pid}: #{line}" if logger
+              if block_given?
+                yield line
+              end
+              lines << line
+            end
+          rescue Heroku::Executor::Terminate
+            logger.debug "Terminating #{pid}." if logger
+            Process.kill("TERM", pid)
+            terminated = true
+          rescue Errno::EIO, IOError => e
+            logger.debug "#{e.class}: #{e.message}" if logger
+          rescue PTY::ChildExited => e
+            logger.debug "Terminated: #{pid}" if logger
+            terminted = true
+            raise e
+          ensure
+            unless terminated
+              logger.debug "Waiting: #{pid}" if logger
+              Process.wait(pid) rescue Errno::ECHILD
+            end
+          end
+        end
+        check_exit_status! cmd, $?.exitstatus, lines
+        lines
+      rescue Errno::ECHILD => e
+        logger.debug "#{e.class}: #{e.message}" if logger
+        check_exit_status! cmd, $?.exitstatus, lines
+        lines
+      rescue PTY::ChildExited => e
+        logger.debug "#{e.class}: #{e.message}" if logger
+        check_exit_status! cmd, $!.status.exitstatus, lines
+        lines
+      rescue Heroku::Commander::Errors::Base => e
+        logger.debug "Error: #{e.problem}" if logger
+        raise
+      rescue Exception => e
+        logger.debug "#{e.class}: #{e.respond_to?(:problem) ? e.problem : e.message}" if logger
+        raise Heroku::Commander::Errors::CommandError.new({
+          :cmd => cmd,
+          :status => $?.exitstatus,
+          :message => e.message,
+          :inner_exception => e,
+          :lines => lines
+        })
+      end
+
+      private
+
+        def check_exit_status!(cmd, status, lines = nil)
+          return if ! status || status == 0
+          raise Heroku::Commander::Errors::CommandError.new({
+            :cmd => cmd,
+            :status => status,
+            :message => "The command #{cmd} failed with exit status #{status}.",
+            :lines => lines
+          })
+        end
+
+    end
+  end
+end

data/lib/heroku/pty.rb

@@ -0,0 +1,7 @@
+if ! defined? PTY::ChildExited
+  module PTY
+    class ChildExited < StandardError
+      # missing on JRuby
+    end
+  end
+end

data/lib/heroku/runner.rb

@@ -0,0 +1,114 @@
+module Heroku
+  class Runner
+
+    attr_accessor :app, :logger, :command
+    attr_reader :pid, :running, :tail
+
+    def initialize(options = {})
+      @app = options[:app]
+      @logger = options[:logger]
+      @command = options[:command]
+      raise Heroku::Commander::Errors::MissingCommandError unless @command
+    end
+
+    def running?
+      !! @running
+    end
+
+    def run!(options = {}, &block)
+      if options && options[:detached]
+        run_detached! &block
+      else
+        run_attached! &block
+      end
+    end
+
+    protected
+
+      def run_attached!(&block)
+        @pid = nil
+        previous_line = nil # delay by 1 to avoid rc=status line
+        lines = Heroku::Executor.run cmdline, { :logger => logger } do |line|
+          if ! @pid
+            check_pid(line)
+          elsif block_given?
+            yield previous_line if previous_line
+            previous_line = line
+          end
+        end
+        lines.shift # remove Running `...` attached to terminal... up, run.xyz
+        check_exit_status! lines
+        lines
+      end
+
+      def run_detached!(&block)
+        raise Heroku::Commander::Errors::AlreadyRunningError.new({ :pid => @pid }) if running?
+        @running = true
+        @pid = nil
+        @tail = nil
+        lines = Heroku::Executor.run cmdline({ :detached => true }), { :logger => logger } do |line|
+          check_pid(line) unless @pid
+          @tail ||= tail!(&block) if @pid
+        end
+        check_exit_status! @tail || lines
+        @running = false
+        @tail || lines
+      end
+
+      def cmdline(options = {})
+        [ "heroku", options[:detached] ? "run:detached" : "run", "\"(#{command} 2>&1 ; echo rc=\\$?)\"", @app ? "--app #{@app}" : nil ].compact.join(" ")
+      end
+
+      def check_exit_status!(lines)
+        status = (lines.size > 0) && (match = lines[-1].match(/^rc=(\d+)$/)) ? match[1] : nil
+        lines.pop if status
+        raise Heroku::Commander::Errors::CommandError.new({
+          :cmd => @command,
+          :status => status,
+          :message => "The command #{@command} failed with exit status #{status}.",
+          :lines => lines
+        }) unless status && status == "0"
+      end
+
+      def check_pid(line)
+        if (match = line.match /attached to terminal... up, (run.\d+)$/)
+          @pid = match[1]
+          logger.debug "Heroku pid #{@pid} up." if logger
+        elsif (match = line.match /detached... up, (run.\d+)$/)
+          @pid = match[1]
+          logger.debug "Heroku detached pid #{@pid} up." if logger
+        else
+          @pid = ''
+        end
+      end
+
+      def tail!(&block)
+        lines = []
+        tail_cmdline = [ "heroku", "logs", "-p #{@pid}", "--tail", @app ? "--app #{@app}" : nil ].compact.join(" ")
+        previous_line = nil # delay by 1 to avoid rc=status line
+        Heroku::Executor.run tail_cmdline, { :logger => logger } do |line|
+          # remove any ANSI output
+          line = line.gsub /\e\[(\d+)m/, ''
+          # lines are returned as [date/time] app/heroku[pid]: output
+          line = line.split("[#{@pid}]:")[-1].strip
+          if line.match(/Starting process with command/) || line.match(/State changed from \w+ to up/)
+            # ignore
+          elsif line.match(/State changed from \w+ to complete/) || line.match(/Process exited with status \d+/)
+            terminate_executor!
+          else
+            if block_given?
+              yield previous_line if previous_line
+              previous_line = line
+            end
+            lines << line
+          end
+        end
+        lines
+      end
+
+      def terminate_executor!
+        raise Heroku::Executor::Terminate
+      end
+
+  end
+end

data/lib/heroku_commander.rb

@@ -0,0 +1,2 @@
+require 'heroku-commander'
+

data/spec/heroku/commander_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Heroku::Commander do
+  context "without arguments" do
+    subject do
+      Heroku::Commander.new
+    end
+    its(:app) { should be_nil }
+  end
+  context "with app" do
+    before :each do
+      Heroku::Executor.stub(:run)
+    end
+    subject do
+      Heroku::Commander.new({ :app => "heroku-commander" })
+    end
+    its(:app) { should eq "heroku-commander" }
+    its(:config) { should be_a Heroku::Config }
+  end
+  context "with a heroku configuration" do
+    before :each do
+      Heroku::Executor.stub(:run).with("heroku config -s --app heroku-commander", { :logger => nil }).
+        and_yield("APP_NAME=heroku-commander").
+        and_yield("RACK_ENV=staging")
+    end
+    subject { Heroku::Commander.new({ :app => "heroku-commander" }).config }
+    context "config" do
+      its(:size) { should == 2 }
+      it { subject["APP_NAME"].should eq "heroku-commander" }
+    end
+  end
+  context "with logger" do
+    subject do
+      logger = Logger.new($stdout)
+      Heroku::Commander.new({ :logger => logger })
+    end
+    context "reload!" do
+      it "passes the logger" do
+        PTY.stub(:spawn)
+        subject.logger.should_receive(:debug).with("Running: heroku config -s")
+        subject.config
+      end
+    end
+  end
+  context "run" do
+    it "runs the command" do
+      Heroku::Executor.stub(:run).
+        and_yield("Running `...` attached to terminal... up, run.1234").
+        and_yield("app").
+        and_yield("bin").
+        and_yield("rc=0").
+        and_return([ "Running `...` attached to terminal... up, run.1234", "app", "bin", "rc=0" ])
+      subject.run("ls -1").should == [ "app", "bin" ]
+    end
+    it "runs the command detached" do
+      Heroku::Executor.stub(:run).with("heroku run:detached \"(ls -1 2>&1 ; echo rc=\\$?)\"", { :logger => nil }).
+        and_yield("Running `ls -1` detached... up, run.8748").
+        and_yield("Use `heroku logs -p run.8748` to view the output.").
+        and_yield("rc=0").
+        and_return([ "Running `ls -1` detached... up, run.8748", "Use `heroku logs -p run.8748` to view the output.", "rc=0" ])
+      Heroku::Executor.stub(:run).with("heroku logs -p run.8748 --tail", { :logger => nil }).
+        and_yield("2013-01-31T01:39:30+00:00 heroku[run.8748]: Starting process with command `ls -1`").
+        and_yield("2013-01-31T01:39:31+00:00 app[run.8748]: bin").
+        and_yield("2013-01-31T01:39:31+00:00 app[run.8748]: app").
+        and_yield("2013-01-31T00:56:13+00:00 app[run.8748]: rc=0").
+        and_yield("2013-01-31T01:39:33+00:00 heroku[run.8748]: Process exited with status 0").
+        and_yield("2013-01-31T01:39:33+00:00 heroku[run.8748]: State changed from up to complete").
+        and_return([
+          "2013-01-31T01:39:30+00:00 heroku[run.8748]: Starting process with command `ls -1`",
+          "2013-01-31T01:39:31+00:00 app[run.8748]: bin",
+          "2013-01-31T01:39:31+00:00 app[run.8748]: app",
+          "2013-01-31T00:56:13+00:00 app[run.8748]: rc=0",
+          "2013-01-31T01:39:33+00:00 heroku[run.8748]: Process exited with status 0",
+          "2013-01-31T01:39:33+00:00 heroku[run.8748]: State changed from up to complete"
+        ])
+      Heroku::Runner.any_instance.should_receive(:terminate_executor!).twice
+      subject.run("ls -1", { :detached => true }).should == [ "bin", "app" ]
+    end
+  end
+end
+

data/spec/heroku/config_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Heroku::Config do
+  context "without arguments" do
+    subject do
+      Heroku::Config.new
+    end
+    its(:app) { should be_nil }
+    its(:cmdline) { should eq "heroku config -s" }
+    context "reload!" do
+      it "reloads the configuration" do
+        Heroku::Executor.stub(:run).with("heroku config -s", { :logger => nil }).
+          and_yield("APP_NAME=heroku-commander").
+          and_yield("RACK_ENV=staging")
+        subject.reload!
+        subject.size.should == 2
+        subject["APP_NAME"].should eq "heroku-commander"
+        subject["RACK_ENV"].should eq "staging"
+      end
+      it "reloads the configuration a second time" do
+        subject["APP_NAME"] = "old"
+        subject["OLD_VARIABLE"] = "old"
+        Heroku::Executor.stub(:run).with("heroku config -s", { :logger => nil }).
+          and_yield("APP_NAME=heroku-commander").
+          and_yield("RACK_ENV=staging")
+        subject.reload!
+        subject.size.should == 2
+        subject["APP_NAME"].should eq "heroku-commander"
+        subject["RACK_ENV"].should eq "staging"
+      end
+    end
+  end
+  context "with app" do
+    subject do
+      Heroku::Config.new({ :app => "heroku-commander" })
+    end
+    its(:app) { should eq "heroku-commander" }
+    its(:cmdline) { should eq "heroku config -s --app heroku-commander" }
+    context "reload!" do
+      it "reloads the configuration" do
+        Heroku::Executor.stub(:run).with("heroku config -s --app heroku-commander", { :logger => nil }).
+          and_yield("APP_NAME=heroku-commander").
+          and_yield("RACK_ENV=staging")
+        subject.reload!
+        subject.size.should == 2
+        subject["APP_NAME"].should eq "heroku-commander"
+        subject["RACK_ENV"].should eq "staging"
+      end
+    end
+  end
+  context "with logger" do
+    subject do
+      logger = Logger.new($stdout)
+      Heroku::Config.new({ :logger => logger })
+    end
+    context "reload!" do
+      it "passes the logger" do
+        PTY.stub(:spawn)
+        subject.logger.should_receive(:debug).with("Running: heroku config -s")
+        subject.reload!
+      end
+    end
+  end
+end
+

data/spec/heroku/executor_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Heroku::Executor do
+  context "missing argument" do
+    subject { lambda { Heroku::Executor.run } }
+    it { should raise_error ArgumentError }
+  end
+  context "command does not exist" do
+    subject { lambda { Heroku::Executor.run "executor_spec.rb" } }
+    it { should raise_error Heroku::Commander::Errors::CommandError, /The command `executor_spec.rb` failed with exit status \d+./ }
+  end
+  context "command exists" do
+    subject { lambda { Heroku::Executor.run "ls -1" } }
+    it { should_not raise_error }
+    its(:call) { should include "Gemfile" }
+  end
+  context "line-by-line" do
+    it "yields" do
+      lines = []
+      Heroku::Executor.run "ls -1" do |line|
+        lines << line
+      end
+      lines.should include "Gemfile"
+    end
+    it "doesn't yield nil lines" do
+      r = double(IO)
+      r.stub(:sync=)
+      r.stub(:each).and_yield("line1").and_yield(nil).and_yield("rc=0")
+      Process.stub(:wait)
+      PTY.stub(:spawn).and_yield(r, nil, 42)
+      Heroku::Executor.run("foobar").should == [ "line1", nil, "rc=0" ]
+    end
+  end
+  context "logger" do
+    it "logs command" do
+      logger = Logger.new($stdout)
+      logger.should_receive(:debug).at_least(2).times
+      Heroku::Executor.run "ls -1", { :logger => logger }
+    end
+  end
+end
+

data/spec/heroku/runner_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Heroku::Runner do
+  context "without a command" do
+    it "raises a missing command error" do
+      expect {
+        Heroku::Runner.new
+      }.to raise_error Heroku::Commander::Errors::MissingCommandError, /Missing command./
+    end
+  end
+  context "with a command" do
+    subject do
+      Heroku::Runner.new({ :command => "ls -1" })
+    end
+    its(:app) { should be_nil }
+    its(:logger) { should be_nil }
+    its(:command) { should eq "ls -1" }
+    its(:cmdline) { should eq "heroku run \"(ls -1 2>&1 ; echo rc=\\$?)\"" }
+    its(:running?) { should be_false }
+    context "run!" do
+      before :each do
+        Heroku::Executor.stub(:run).with(subject.send(:cmdline), { :logger => nil }).
+          and_yield("Running `...` attached to terminal... up, run.9783").
+          and_yield("app").
+          and_yield("bin").
+          and_yield("rc= 0").
+          and_return([ "Running `...` attached to terminal... up, run.9783", "app", "bin", "rc=0" ])
+      end
+      it "runs the command w/o a block" do
+        subject.run!.should == [ "app", "bin" ]
+        subject.pid.should == "run.9783"
+        subject.should_not be_running
+      end
+      it "runs the command with a block" do
+        lines = []
+        subject.run!.each do |line|
+          lines << line
+        end
+        lines.should == [ "app", "bin" ]
+        subject.pid.should == "run.9783"
+        subject.should_not be_running
+      end
+      it "raises an exception if the command fails" do
+        Heroku::Executor.stub(:run).with(subject.send(:cmdline), { :logger => nil }).
+          and_return([ "Running `...` attached to terminal... up, run.9783", "app", "bin", "rc=1" ])
+        expect {
+          subject.run!
+        }.to raise_error Heroku::Commander::Errors::CommandError, /The command `ls -1` failed with exit status 1./
+      end
+    end
+    context "run! detached" do
+      before :each do
+        Heroku::Executor.stub(:run).with(subject.send(:cmdline, { :detached => true }), { :logger => nil }).
+          and_yield("Running `ls -1` detached... up, run.8748").
+          and_yield("Use `heroku logs -p run.8748` to view the output.").
+          and_yield("rc=0").
+          and_return([ "Running `ls -1` detached... up, run.8748", "Use `heroku logs -p run.8748` to view the output.", "rc=0" ])
+        Heroku::Executor.stub(:run).with("heroku logs -p run.8748 --tail", { :logger => nil }).
+          and_yield("2013-01-31T01:39:30+00:00 heroku[run.8748]: Starting process with command `ls -1`").
+          and_yield("2013-01-31T01:39:31+00:00 app[run.8748]: bin").
+          and_yield("2013-01-31T01:39:31+00:00 app[run.8748]: app").
+          and_yield("2013-01-31T00:56:13+00:00 app[run.8748]: rc=0").
+          and_yield("2013-01-31T01:39:33+00:00 heroku[run.8748]: Process exited with status 0").
+          and_yield("2013-01-31T01:39:33+00:00 heroku[run.8748]: State changed from up to complete").
+          and_return([
+            "2013-01-31T01:39:30+00:00 heroku[run.8748]: Starting process with command `ls -1`",
+            "2013-01-31T01:39:31+00:00 app[run.8748]: bin",
+            "2013-01-31T01:39:31+00:00 app[run.8748]: app",
+            "2013-01-31T00:56:13+00:00 app[run.8748]: rc=0",
+            "2013-01-31T01:39:33+00:00 heroku[run.8748]: Process exited with status 0",
+            "2013-01-31T01:39:33+00:00 heroku[run.8748]: State changed from up to complete"
+          ])
+        Heroku::Runner.any_instance.should_receive(:terminate_executor!).twice
+      end
+      it "runs the command w/o a block" do
+        subject.run!({ :detached => true }).should == [ "bin", "app" ]
+        subject.pid.should == "run.8748"
+        subject.should_not be_running
+      end
+      it "runs the command with a block" do
+        lines = []
+        subject.run!({ :detached => true }).each do |line|
+          lines << line
+        end
+        lines.should == [ "bin", "app" ]
+        subject.pid.should == "run.8748"
+        subject.should_not be_running
+      end
+    end
+  end
+end
+

data/spec/heroku/version_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Heroku::Commander do
+  it "has a version" do
+    Heroku::Commander::VERSION.should_not be_nil
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'rspec'
+require 'heroku-commander'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: heroku-commander
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Doubrovkine
+- Frank Macreery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: dblock@dblock.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- assets/heroku-commander.png
+- examples/heroku-config.rb
+- examples/heroku-run-detached.rb
+- examples/heroku-run.rb
+- heroku-commander.gemspec
+- lib/config/locales/en.yml
+- lib/heroku-commander.rb
+- lib/heroku/commander.rb
+- lib/heroku/commander/errors.rb
+- lib/heroku/commander/errors/already_running_error.rb
+- lib/heroku/commander/errors/base.rb
+- lib/heroku/commander/errors/client_eio_error.rb
+- lib/heroku/commander/errors/command_error.rb
+- lib/heroku/commander/errors/missing_command_error.rb
+- lib/heroku/commander/errors/unexpected_output_error.rb
+- lib/heroku/commander/version.rb
+- lib/heroku/config.rb
+- lib/heroku/executor.rb
+- lib/heroku/pty.rb
+- lib/heroku/runner.rb
+- lib/heroku_commander.rb
+- spec/heroku/commander_spec.rb
+- spec/heroku/config_spec.rb
+- spec/heroku/executor_spec.rb
+- spec/heroku/runner_spec.rb
+- spec/heroku/version_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/dblock/heroku-commander
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 155166833
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Control Heroku from Ruby via its `heroku` shell command.
+test_files: []