sfb_scripts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7cbc870683c0380827cabc69fd8840684dc81abc
+  data.tar.gz: e129a948b2183ffa885bae660d5dcadfd32e0977
+SHA512:
+  metadata.gz: 2c2c5d7cf13aa8a9633adf665571a9279b82fca2df14fa4360d1ba282ad5a6550ee0059f09ae3f5435efa180742884c5c3245014c8f5b64fcc83e6ea6a214e65
+  data.tar.gz: 8cf02cba029addbbef7fc424f4d2cf305adf20b1c5c06a0966031e34481edc8b3954ba3a5003440c441086deeb632bff7620080f755ff9c7354df7e07a04e4fe

data/bin/app_up

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/upper'
+require 'thor'
+
+class CLI < Thor
+
+  #
+  # REBASE
+  #
+
+  desc "rebase", "Rebase your commits onto master. Bundle installs and migrates as needed.  Will terminate if conflicts are found."
+  option :loud, :type => :boolean, :desc => 'Pipe output to terminal or not (output is always piped to /tmp/up.log)'
+  option :all, :type => :boolean, :desc => "Don't update the repo, just bundle and migrate everywhere."
+
+  def up
+    if options[:all]
+      Upper.no_git(options)
+    else
+      Upper.rebase_on_master!(options)
+    end
+  end
+
+  desc "install_hooks", "Install a pre-push git hook that will not let you push to remote master."
+  def install_hooks
+    Upper.install_hooks(options)
+  end
+
+  desc "pre_push_hook", "Deny destructive actions to the remote master."
+  def pre_push_hook(git_command)
+    Upper.pre_push_hook(git_command, options)
+  end
+
+  default_task :up
+end
+
+CLI.start(ARGV)

data/bin/test_runner

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/tester'
+require 'thor'
+
+class CLI < Thor
+
+  #
+  # run
+  #
+  desc "status", "Find dirty tests in your git status and run them."
+  option :all_engines, :type => :boolean, :desc => 'Run all tests identified, regardless of engine'
+  option :no_selenium, :type => :boolean, :desc => 'Ignore selenium'
+  def status
+    Tester.status(options)
+  end
+
+  #
+  # run
+  #
+  desc "find", <<-DESC
+    Find tests and run them. By trying to match an individual test or the name of a test file(s).
+  DESC
+  def find(*inputs)
+    Tester.find(inputs, options)
+  end
+
+  desc "status_check", "Verify that you don't edit a file without editing its corresponding test file."
+  option :confirm_exit_status, :type => :boolean, :desc => 'Asks user whether to exit with status 0 or 1.  Used in the pre-commit hook'
+  def status_check
+    Tester.status_check(options)
+  end
+
+  default_task :status
+
+end
+
+CLI.start(ARGV)

data/lib/active_repo.rb

@@ -0,0 +1,47 @@
+require_relative 'repo'
+
+class ActiveRepo < Repo
+
+  def rebase_on_master!
+    up do
+      # will raise an error with merge conflicts
+      begin
+        shell.run "git pull --rebase origin master"
+      rescue ShellRunner::CommandFailureError
+        puts "Unable to rebase.  Maybe you need to stash local changes, or there are rebase conflicts"
+        puts `git status`
+        exit
+      end
+    end
+  end
+
+  def up_master!
+    move_to_master!
+    rebase_on_master!
+  end
+
+  def up
+    @old_sha = current_sha
+    yield
+    @new_sha = current_sha
+  end
+
+  def pull_origin_master!
+    up do
+      fetch_origin
+      reset_hard_origin_master!
+    end
+  end
+
+  def fetch_origin
+    shell.run 'git fetch origin'
+  end
+
+  def reset_hard_origin_master!
+    shell.run "git reset --hard origin/master"
+  end
+
+  def move_to_master!
+    shell.run "git checkout master"
+  end
+end

data/lib/bundle_manager.rb

@@ -0,0 +1,34 @@
+class BundleManager
+  attr_accessor :shell, :repo
+
+  def initialize(repo: raise, shell: raise)
+    @shell = shell
+    @repo = repo
+  end
+
+  def bundle_where_necessary
+    find("Gemfile.lock").each do |gemfile_lock|
+      if repo.changed?(gemfile_lock)
+        bundle(directory_of(gemfile_lock))
+      end
+    end
+  end
+
+  def bundle(gemfile_directory)
+    begin
+      shell.run "bundle install --local", dir: gemfile_directory
+    rescue ShellRunner::CommandFailureError
+      puts 'trying without --local'
+      shell.run "bundle install", dir: gemfile_directory
+    end
+  end
+
+  def find(file_name)
+    Dir.glob("**/#{file_name}")
+  end
+
+  def directory_of(file_path)
+    File.dirname(file_path)
+  end
+
+end

data/lib/hook_manager.rb

@@ -0,0 +1,36 @@
+class HookManager
+
+  def self.install!(env)
+    new(env).install!
+  end
+
+  attr_reader :shell, :repo
+
+  def initialize(env)
+    @shell = env[:shell]
+    @repo = env[:repo]
+  end
+
+  def is_installed?
+    File.file?('.git/hooks/pre-push')
+  end
+
+  def install!
+    return if is_installed?
+
+    create_file
+    make_executable
+  end
+
+  private
+
+  def create_file
+    shell.run %{echo 'app_up pre_push_hook "$(ps -ocommand= -p $PPID)"' > .git/hooks/pre-push}
+    shell.run %{echo 'test_runner status_check --confirm_exit_status' > .git/hooks/pre-commit}
+  end
+
+  def make_executable
+    shell.run "chmod +x .git/hooks/pre-push"
+    shell.run "chmod +x .git/hooks/pre-commit"
+  end
+end

data/lib/lazy_repo.rb

@@ -0,0 +1,9 @@
+require_relative 'repo'
+
+class LazyRepo < Repo
+
+  def files_changed
+    all_files
+  end
+
+end

data/lib/loud_shell_runner.rb

@@ -0,0 +1,10 @@
+require_relative 'shell_runner'
+
+class LoudShellRunner < ShellRunner
+
+  def run(*args)
+    super(*args).tap do |results|
+      puts results
+    end
+  end
+end

data/lib/migrator.rb

@@ -0,0 +1,28 @@
+class Migrator
+  attr_accessor :shell, :repo
+
+  def initialize(repo: raise, shell: raise)
+    @shell = shell
+    @repo = repo
+  end
+
+  def migrate_where_necessary
+    directories_to_migrate.each do |dir|
+      shell.run "bundle exec rake db:create db:migrate", dir: dir
+      shell.run "RAILS_ENV=test bundle exec rake db:create db:migrate", dir: dir
+    end
+  end
+
+  def directories_to_migrate
+    migrate_dirs = repo.files_changed.select {|f| f.match("/migrate/") }.map {|f| File.dirname(f) }.uniq
+    migrate_dirs.select {|d| in_rack_application?(d) };
+  end
+
+  private
+
+  def in_rack_application?(migrate_dir)
+    root_dir = migrate_dir.gsub(/db\/migrate$/, '')
+    File.file?("#{root_dir}/config.ru")
+  end
+
+end

data/lib/needs_manager.rb

@@ -0,0 +1,85 @@
+require_relative 'shell_runner'
+require_relative 'loud_shell_runner'
+require_relative 'repo'
+require_relative 'lazy_repo'
+require_relative 'active_repo'
+require_relative 'migrator'
+require_relative 'bundle_manager'
+require_relative 'test_runner'
+
+class NeedsManager
+
+  def self.configure(task, needs, options)
+    new(task, needs, options).configure
+  end
+
+  attr_reader :needs, :options, :env, :log_file
+  def initialize(task, needs, options)
+    @log_file = log_file_for(task)
+    @needs = needs
+    @options = options
+    @env = {}
+  end
+
+  def configure
+    set_working_directory
+
+    create_shell
+    create_repo if needs.include? :repo
+    create_bundler if needs.include? :bundler
+    create_migrator if needs.include? :migrator
+    create_test_runner if needs.include? :test_runner
+
+    return env
+  end
+
+  def set_working_directory
+    @working_directory = Repo.root_dir
+    Dir.chdir(@working_directory)
+  end
+
+  def create_shell
+    env[:shell] = shell_class.new(log_file, @working_directory)
+  end
+
+  def shell_class
+    if options[:loud]
+      LoudShellRunner
+    else
+      ShellRunner
+    end
+  end
+
+  def create_repo
+    env[:repo] = repo_class.new(shell: env[:shell])
+  end
+
+  def repo_class
+    if options[:repo_type] == :active
+      ActiveRepo
+    elsif options[:repo_type] == :lazy
+      LazyRepo
+    else
+      Repo
+    end
+  end
+
+  def create_bundler
+    env[:bundler] = BundleManager.new(shell: env[:shell], repo: env[:repo])
+  end
+
+  def create_migrator
+    env[:migrator] = Migrator.new(shell: env[:shell], repo: env[:repo])
+  end
+
+  def create_test_runner
+    env[:test_runner] = TestRunner.new(
+      shell: env[:shell],
+      all_engines: options[:all_engines]
+    )
+  end
+
+  def log_file_for(task)
+    "/tmp/#{task}.log"
+  end
+end

data/lib/pre_push_hook.rb

@@ -0,0 +1,31 @@
+class PrePushHook
+
+  def self.check(command, env)
+    new(command, env).check
+  end
+
+  attr_reader :shell, :repo, :push_command
+  def initialize(command, env)
+    @shell = env[:shell]
+    @repo = env[:repo]
+    @push_command = command
+  end
+
+  def check
+    if affects_master? && is_destructive?
+      shell.warn "[Policy] Don't force push or delete master.  (Denied by pre-push hook)"
+      exit 1
+    end
+  end
+
+  private
+
+  def affects_master?
+    push_command.match(/master/) || (repo.current_branch == 'master')
+  end
+
+  def is_destructive?
+    push_command.match(/-f|delete|force| :master/)
+  end
+
+end

data/lib/repo.rb

@@ -0,0 +1,69 @@
+class Repo
+
+  def self.root_dir
+    @root_dir ||= %x[ git rev-parse --show-toplevel ].chomp
+  end
+
+  attr_reader :shell
+
+  def initialize(shell: shell)
+    @shell = shell
+  end
+
+  def files_changed
+    @files_changed ||= (shell.run "git diff --name-only #{@old_sha}").split("\n")
+  end
+
+  def changed?(file_path)
+    files_changed.include? file_path
+  end
+
+  def all_files
+    @all_files ||= shell.run("git ls-tree --full-tree -r HEAD --name-only").split("\n")
+  end
+
+  def find_files(pattern)
+    shell.run("git ls-files '*#{pattern}*'").split("\n")
+  end
+
+  def status_files
+    statii = shell.run("git status -s").split("\n")
+    r = statii.map do |status|
+      status.strip!
+      if status[0] == 'D'
+        nil
+      else
+        status.split(' ').last
+      end
+    end.compact
+  end
+
+  def grep(regex, file_pattern: '*')
+    results = shell.run("git grep '#{regex}' -- '#{file_pattern}'").split("\n")
+    results.map do |result|
+      interpret_grep_result(result)
+    end
+  end
+
+  def current_branch
+    shell.run 'git rev-parse --abbrev-ref HEAD'
+  end
+
+  private
+
+  def interpret_grep_result(grep_result)
+    splits = grep_result.split(/:/)
+    file = splits.shift
+    line = splits.join(':')
+
+    {
+      :file => file,
+      :line => line,
+    }
+  end
+
+  def current_sha
+    shell.run "git rev-parse HEAD"
+  end
+
+end

data/lib/shell_runner.rb

@@ -0,0 +1,70 @@
+require_relative 'string_extension'
+
+class ShellRunner
+  CommandFailureError = Class.new(StandardError)
+
+  attr_accessor :working_directory, :log_path
+
+  def initialize(log_path, working_directory)
+    @working_directory = working_directory
+    @queue = ''
+    @log_path = log_path
+    reset_log
+  end
+
+  def run(cmd, dir: working_directory)
+    command = "cd #{dir} && #{cmd}"
+    puts command
+    log command
+    %x{ set -o pipefail && #{command} 2>> #{log_path} | tee -a #{log_path} }.chomp.tap do
+      raise CommandFailureError, "The following command has failed: #{command}.  See #{log_path} for a full log." if ($?.exitstatus != 0)
+    end
+  end
+
+  def exec(cmd, dir: working_directory)
+    command = "cd #{dir} && #{cmd}"
+    notify "\n#{command}"
+    Kernel.exec command
+  end
+
+  def enqueue(cmd, dir: working_directory)
+    command = "cd #{dir} && #{cmd} && cd -"
+    @queue += "#{command};\n"
+  end
+
+  def confirm?(question)
+    warn "#{question} [Yn]"
+    answer = STDIN.gets.strip.downcase
+    return answer != 'n'
+  end
+
+  def deny?(question)
+    ! confirm?(question)
+  end
+
+  def exec_queue
+    notify 'running: '
+    notify ''
+    notify @queue
+    Kernel.exec @queue
+  end
+
+  def warn(msg)
+    log msg
+    puts msg.red
+  end
+
+  def notify(msg)
+    log msg
+    puts msg.yellow
+  end
+
+  def log(msg)
+    %x{echo "#{msg}" >> #{log_path}}
+  end
+
+  def reset_log
+    %x{echo "" > #{log_path}}
+  end
+
+end

data/lib/status_checker.rb

@@ -0,0 +1,62 @@
+class StatusChecker
+  def self.report(env, confirm_exit_status)
+    new(env, confirm_exit_status).report
+  end
+
+  attr_reader :repo, :shell, :untested_files
+  def initialize(env, confirm_exit_status)
+    @repo = env[:repo]
+    @shell = env[:shell]
+    @untested_files = []
+    @confirm_exit_status = confirm_exit_status
+  end
+
+  def report
+    non_test_files.each do |file|
+      if ! test_files.include? "#{file}_test"
+        untested_files << full_path_by_basename(file)
+      end
+    end
+
+    if untested_files.empty?
+      shell.notify "All ruby files are tested!"
+      exit 0
+    else
+      shell.warn "The following files have changed without being tested:\n\n#{untested_files.join("\n")}"
+
+      STDIN.reopen('/dev/tty')
+      if confirm_exit_status? && shell.confirm?("\nDo you still wish to commit?")
+        exit 0
+      else
+        exit 1
+      end
+    end
+
+  end
+
+  private
+
+  def test_files
+    file_names.select {|f| f.match(/_test$/) }
+  end
+
+  def non_test_files
+    file_names.reject {|f| f.match(/_test$/) }
+  end
+
+  def file_names
+    @file_names ||= files.select {|f| f.match(/\.rb$/)}.map {|f| File.basename(f, '.rb') }
+  end
+
+  def files
+    @files ||= repo.status_files
+  end
+
+  def full_path_by_basename(file)
+    files.select {|f| File.basename(f, '.rb') == file }.first
+  end
+
+  def confirm_exit_status?
+    @confirm_exit_status
+  end
+end

data/lib/string_extension.rb

@@ -0,0 +1,22 @@
+class String
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def pink
+    colorize(35)
+  end
+end

data/lib/test_case.rb

@@ -0,0 +1,27 @@
+class TestCase
+  TestDirectoryError = Class.new(StandardError)
+
+  attr_reader :working_dir, :relative_path, :test_name, :full_path
+
+  def initialize(full_path: raise, test_name: '')
+    @test_name = test_name
+    @full_path = full_path
+  end
+
+  def working_dir
+    @working_dir ||=
+      if full_path.match(/^(.*)test\//)
+        "#{full_path.match(/^(.*)test\//)[1]}"
+      else
+        raise TestDirectoryError.new("Can't find test's working directory")
+      end
+  end
+
+  def relative_path
+    @relative_path ||= full_path.gsub(/^#{working_dir}/, '') || raise_file_path_error
+  end
+
+  def raise_file_path_error
+    raise TestDirectoryError.new("Can't find test's relative path")
+  end
+end

data/lib/test_collection.rb

@@ -0,0 +1,105 @@
+require_relative 'test_case'
+
+class TestCollection
+
+  MultipleWorkingDirectoriesError = Class.new(StandardError)
+
+  def self.parse(grep_result)
+    new(grep_result[:file], line: grep_result[:line]).parse
+  end
+
+
+  def self.from_file_path(file_path)
+    new(file_path).from_file_path
+  end
+
+  attr_reader :tests
+
+  def initialize(tests_data)
+    @tests = tests_data.map do |test_data|
+      create_test_case(test_data)
+    end.compact
+  end
+
+  def empty?
+    tests.empty?
+  end
+
+  def present?
+    ! empty?
+  end
+
+  def size
+    tests.size
+  end
+
+  def first
+    tests.first
+  end
+
+  def [](*args)
+    tests[*args]
+  end
+
+  def in_one_file?
+    full_paths.size == 1
+  end
+
+  def in_one_engine?
+    working_dirs.size == 1
+  end
+
+  def full_paths
+    @full_paths ||= tests.map {|t| t.full_path }.uniq
+  end
+
+  def relative_paths
+    @relative_paths ||= tests.map {|t| t.relative_path }.uniq
+  end
+
+  def working_dirs
+    @working_dirs ||= tests.map {|t| t.working_dir }.uniq
+  end
+
+  def relative_paths_in(working_directory)
+    tests.select {|t| t.working_dir == working_directory}.map {|t| t.relative_path }.uniq
+  end
+
+  def include_selenium?
+    ! selenium_tests.empty?
+  end
+
+  def remove_selenium!
+    @tests = tests - selenium_tests
+  end
+
+  def selenium_tests
+    tests.select {|t| t.full_path.match(/selenium/)}
+  end
+
+  def working_dir
+    raise MultipleWorkingDirectoriesError.new("Can't run tests for more than one engine") unless working_dirs.size == 1
+
+    return working_dirs.first
+  end
+
+  private
+
+  def find_test_name(grepped_line)
+    return nil unless grepped_line
+    grepped_line.strip.gsub(/^\s*def /, '').strip
+  end
+
+  def create_test_case(test_data)
+    file_path = test_data[:file]
+    test_name = find_test_name(test_data[:line])
+    return nil if ! file_path.match(/_test\.rb/)
+    return nil if (test_name && ! test_name.match(/^test_/))
+
+    TestCase.new(
+      full_path: file_path,
+      test_name: test_name
+    )
+  end
+
+end

data/lib/test_file_runner.rb

@@ -0,0 +1,56 @@
+require_relative 'test_collection'
+
+class TestFileRunner
+
+  def self.find(inputs, env)
+    new(env, false).find(inputs)
+  end
+
+  def self.status(env, ignore_selenium=false)
+    new(env, ignore_selenium).status
+  end
+
+  attr_reader :repo, :shell, :test_runner, :tests, :ignore_selenium
+  def initialize(env, ignore_selenium)
+    @repo = env[:repo]
+    @shell = env[:shell]
+    @test_runner = env[:test_runner]
+    @ignore_selenium = ignore_selenium
+  end
+
+  def find(inputs)
+    files = []
+    inputs.each {|input| files << repo.find_files(input).map {|f| {:file => f} } }
+    files.flatten!
+    @tests = TestCollection.new(files)
+    if @tests.present?
+      test_runner.run_files(tests)
+    else
+      shell.notify "Could not find matching test file."
+    end
+  end
+
+  def status
+    files = repo.status_files.map {|f| {:file => f} }
+    @tests = TestCollection.new(files)
+
+    if tests.include_selenium?
+      handle_selenium
+    end
+
+    if tests.empty?
+      shell.notify 'No tests to run'
+      exit
+    end
+
+    test_runner.run_files(tests)
+  end
+
+  private
+
+  def handle_selenium
+    if ignore_selenium || shell.deny?("The status includes some selenium files.  Do you wish to run those?")
+      tests.remove_selenium!
+    end
+  end
+end

data/lib/test_method_runner.rb

@@ -0,0 +1,53 @@
+require_relative 'test_runner'
+require_relative 'shell_runner'
+
+class TestMethodRunner
+
+  def self.run(regex, env)
+    new(env).run(regex)
+  end
+
+  attr_reader :regex, :repo, :shell, :test_runner
+  def initialize(env)
+    @repo = env[:repo]
+    @shell = env[:shell]
+    @test_runner = env[:test_runner]
+  end
+
+  def run(regex)
+    @regex = regex
+
+    if tests.empty?
+      shell.notify "Could not find matching test method."
+      return false
+    elsif tests.size == 1
+      test_runner.run_method(tests.first)
+    elsif tests.in_one_file?
+      shell.notify "Multiple matches in same file. Running that file."
+      test_runner.run_files(tests)
+    elsif tests.in_one_engine? && tests.full_paths.size < 4 # hack: maybe should ask here?
+      shell.notify "Multiple matches across files in same engine. Running those files."
+      test_runner.run_files(tests)
+    else
+      shell.warn 'Found too many tests:'
+      tests[0..10].each {|t| shell.notify "#{t.full_path}: #{t.test_name}" }
+      shell.notify '...'
+      exit
+    end
+  end
+
+  def tests
+    @test_collection ||= TestCollection.new(find_tests_by_name)
+  end
+
+  def find_tests_by_name
+    test_def_regex = "^\s*def .*#{regex}.*"
+    begin
+      return repo.grep(test_def_regex, file_pattern: '*_test.rb')
+    rescue ShellRunner::CommandFailureError
+      # git grep exits with 1 if no results
+      return []
+    end
+  end
+
+end

data/lib/test_runner.rb

@@ -0,0 +1,78 @@
+require_relative 'shell_runner'
+
+class TestRunner
+
+  attr_reader :shell, :all_engines_param
+  def initialize(env)
+    @shell = env[:shell]
+    @all_engines_param = env[:all_engines]
+  end
+
+  def run_method(test)
+    test_runner = named_test_runner(test.working_dir)
+
+    shell.exec("#{test_runner} #{test.relative_path} --name=#{test.test_name}", dir: test.working_dir)
+  end
+
+  def run_files(tests)
+    begin
+      test_runner = test_collection_runner(tests.working_dir)
+      test_files = tests.relative_paths.join(' ')
+
+      shell.exec("#{test_runner} #{test_files}", dir: tests.working_dir)
+    rescue TestCollection::MultipleWorkingDirectoriesError => e
+      if run_across_engines?
+        run_across_engines(tests)
+      end
+    end
+  end
+
+  private
+
+  def run_across_engines(tests)
+    shell.notify "\nfinding test runners"
+    tests.working_dirs.each do |engine_dir|
+      test_files = tests.relative_paths_in(engine_dir).join(' ')
+      test_runner = test_collection_runner(engine_dir)
+
+      shell.enqueue("#{test_runner} #{test_files}", dir: engine_dir)
+    end
+    shell.exec_queue
+  end
+
+  def test_runner_type(working_dir)
+    if shell.run("ls bin", dir: working_dir).split("\n").include? 'testunit'
+      :spring
+    else
+      :ruby
+    end
+  rescue ShellRunner::CommandFailureError
+    :ruby
+  end
+
+  def named_test_runner(working_dir)
+    if test_runner_type(working_dir) == :spring
+      # hack:
+      # Add some options for using spring.
+      #
+      #"bin/testunit"
+      "ruby -I test"
+    else
+      "ruby -I test"
+    end
+  end
+
+  def test_collection_runner(working_dir)
+    if test_runner_type(working_dir) == :spring
+      #"bin/testunit"
+      %{ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + "/" + file) }'}
+    else
+      %{ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + "/" + file) }'}
+    end
+  end
+
+  def run_across_engines?
+    all_engines_param || shell.confirm?("Test files are in multiple engines.  Run them all?")
+  end
+
+end

data/lib/tester.rb

@@ -0,0 +1,70 @@
+require_relative 'needs_manager'
+require_relative 'test_collection'
+require_relative 'test_method_runner'
+require_relative 'test_file_runner'
+require_relative 'status_checker'
+
+require 'rubygems'
+require 'pry'
+
+class Tester
+
+  def self.needs
+    [:shell, :repo, :test_runner]
+  end
+
+  def self.find(inputs, options)
+    env = NeedsManager.configure(:test_runner, needs, options.merge(repo_type: :info))
+    new(env).find(inputs)
+  end
+
+  def self.status(options)
+    env = NeedsManager.configure(:test_runner, needs, options.merge(repo_type: :info))
+    new(env).status(options)
+  end
+
+  def self.status_check(options)
+    env = NeedsManager.configure(:test_runner, (needs - [:test_runner]), options.merge(repo_type: :info))
+    new(env).status_check(options)
+  end
+
+  attr_accessor :env
+  def initialize(env)
+    @env = env
+  end
+
+  def find(inputs)
+    # each of these replaces this process if successful
+    # so no need for logic control flow
+    if query_might_be_method?(inputs)
+      TestMethodRunner.run(inputs.first, env)
+    end
+    TestFileRunner.find(inputs, env)
+    env[:shell].warn "Giving up :("
+  end
+
+  def status(options)
+    TestFileRunner.status(env, options[:no_selenium])
+  end
+
+  def status_check(options)
+    StatusChecker.report(env, options[:confirm_exit_status])
+  end
+
+  private
+
+  def query_might_be_method?(inputs)
+    if inputs.any? {|input| is_file_path?(input) }
+      false
+    elsif inputs.size > 1
+      false
+    else
+      true
+    end
+  end
+
+  def is_file_path?(input)
+    !! input.match(/\.rb/)
+  end
+
+end

data/lib/upper.rb

@@ -0,0 +1,72 @@
+require_relative 'needs_manager'
+require_relative 'hook_manager'
+require_relative 'pre_push_hook'
+
+require 'rubygems'
+require 'pry'
+
+class Upper
+
+  def self.needs
+    [:shell, :repo, :bundler, :migrator]
+  end
+
+  def self.rebase_on_master!(options)
+    env = NeedsManager.configure(:up, needs, options.merge(repo_type: :active))
+    new(env).rebase_on_master!
+  end
+
+  def self.up_master!(options)
+    env = NeedsManager.configure(:up, needs, options.merge(repo_type: :active))
+    new(env).up_master!
+  end
+
+  def self.no_git(options)
+    env = NeedsManager.configure(:up, needs, options.merge(repo_type: :lazy))
+    new(env).no_git
+  end
+
+  def self.install_hooks(options)
+    env = NeedsManager.configure(:up, needs, options.merge(repo_type: :lazy))
+    new(env).install_hooks
+  end
+
+  def self.pre_push_hook(git_command, options)
+    env = NeedsManager.configure(:up, needs, options.merge(repo_type: :lazy))
+    new(env).pre_push_hook(git_command)
+  end
+
+  attr_reader :env, :repo, :bundler, :migrator
+
+  def initialize(env)
+    @env = env
+    @repo = env[:repo]
+    @bundler = env[:bundler]
+    @migrator = env[:migrator]
+  end
+
+  def up_master!
+    repo.up_master!
+    bundler.bundle_where_necessary
+    migrator.migrate_where_necessary
+  end
+
+  def rebase_on_master!
+    repo.rebase_on_master!
+    bundler.bundle_where_necessary
+    migrator.migrate_where_necessary
+  end
+
+  def no_git
+    bundler.bundle_where_necessary
+    migrator.migrate_where_necessary
+  end
+
+  def install_hooks
+    HookManager.install!(env)
+  end
+
+  def pre_push_hook(git_command)
+    PrePushHook.check(git_command, env)
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: sfb_scripts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pete Kinnecom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Easily update your rails app and run tests from command line
+email:
+- pete.kinnecom@gmail.com
+executables:
+- test_runner
+- app_up
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_repo.rb
+- lib/bundle_manager.rb
+- lib/hook_manager.rb
+- lib/lazy_repo.rb
+- lib/loud_shell_runner.rb
+- lib/migrator.rb
+- lib/needs_manager.rb
+- lib/pre_push_hook.rb
+- lib/repo.rb
+- lib/shell_runner.rb
+- lib/status_checker.rb
+- lib/string_extension.rb
+- lib/test_case.rb
+- lib/test_collection.rb
+- lib/test_file_runner.rb
+- lib/test_method_runner.rb
+- lib/test_runner.rb
+- lib/tester.rb
+- lib/upper.rb
+- bin/test_runner
+- bin/app_up
+homepage: http://github.com/petekinnecom/dev_scripts/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Easily update your rails app and run tests from command line
+test_files: []
+has_rdoc: