sfb_scripts 1.9.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 498e977aaa2988859e2162edc371e32f65fbb19d
-  data.tar.gz: 839ee5851b096005e3700d3732537163abbd7cba
+  metadata.gz: a4146f286959b332098dde53e71bb82ec044b97e
+  data.tar.gz: 2d5a529036e5af8cc65dbd45a2a96c68cea21b4e
 SHA512:
-  metadata.gz: bd061700b515123a5038e79564173cf75f0b02a4e5c3c3bf58b7c45d3cc00335d765a2b4bf9ba019fdc68e78fcd14012cb4962086299c131e1c7542cd48bf6b9
-  data.tar.gz: a14b0991f1764915a03ed21d76d21c819bed3a8c7e39bf5293830bbe2fdcd591b13c8e5d5bd609ef5147fbd9cb2034cab0b6f53ad3a997dcc12b1fd6c53ab52a
+  metadata.gz: 458eb666e7f48ed93e9b9db28e1506a1b8a793ae9f983e402866766aca856c0309ea61dba8da1f6f0dec25fb0b8db7cb714e4ec7e6aa320fa20830664637df83
+  data.tar.gz: d23e50573381d2a6526931af2293e27e43e95f98ab8dafdd2888ec8f64cc312510c1b959ceadbf6e369d7dc7ac167715249bd6c91eabc1e4bece917f1b928f7e

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sfb_scripts
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Pete Kinnecom
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2016-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: app_up
@@ -30,45 +30,21 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 1.0.0
 description: Easily update your rails app and run tests from command line
 email:
 - pete.kinnecom@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files:
-- lib/sfb_scripts/bundler/bundle_manager.rb
-- lib/sfb_scripts/dependency_loader.rb
-- lib/sfb_scripts/folder_guard.rb
-- lib/sfb_scripts/hook_manager.rb
-- lib/sfb_scripts/hooks/pre_push_hook.rb
-- lib/sfb_scripts/migrations/migrator.rb
-- lib/sfb_scripts/monkey_patches/string_extension.rb
-- lib/sfb_scripts/needs_manager.rb
-- lib/sfb_scripts/repositories/active_repo.rb
-- lib/sfb_scripts/repositories/lazy_repo.rb
-- lib/sfb_scripts/repositories/repo.rb
-- lib/sfb_scripts/shells/loud_shell_runner.rb
-- lib/sfb_scripts/shells/shell_runner.rb
-- lib/sfb_scripts/shells/verbose_shell_runner.rb
-- lib/sfb_scripts/test_running/status_checker.rb
-- lib/sfb_scripts/test_running/status_test_runner.rb
-- lib/sfb_scripts/test_running/test_case.rb
-- lib/sfb_scripts/test_running/test_collection.rb
-- lib/sfb_scripts/test_running/test_filter.rb
-- lib/sfb_scripts/test_running/test_finder.rb
-- lib/sfb_scripts/test_running/test_runner.rb
-- lib/sfb_scripts/tester.rb
-- lib/sfb_scripts/upper.rb
-- lib/sfb_scripts/version.rb
+files: []
 homepage: http://github.com/petekinnecom/sfb_scripts/
 licenses:
 - MIT
@@ -89,9 +65,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Easily update your rails app and run tests from command line
 test_files: []
-has_rdoc: 

data/lib/sfb_scripts/bundler/bundle_manager.rb

@@ -1,59 +0,0 @@
-class BundleManager
-  attr_accessor :shell, :repo, :queue, :folder_guard
-
-  def initialize(repo: raise, shell: raise, queue: raise, folder_guard: folder_guard)
-    @shell = shell
-    @repo = repo
-    @queue = queue
-    @folder_guard = folder_guard
-  end
-
-  def bundle_where_necessary
-    shell.notify "\nBundling:"
-    directories_to_bundle.each do |dir|
-      queue.enqueue_b do
-        bundle(dir)
-      end
-    end
-    queue.join
-  end
-
-  private
-
-  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 directories_to_bundle
-    changed_gemfile_locks.map do |gemfile_lock|
-      directory_of(gemfile_lock)
-    end
-    .select do |dir|
-      folder_guard.allowed?(dir)
-    end
-  end
-
-  def changed_gemfile_locks
-    all_gemfile_locks.select do |gemfile_lock|
-      repo.changed?(gemfile_lock)
-    end
-  end
-
-  def all_gemfile_locks
-    find("Gemfile.lock")
-  end
-
-  def find(file_name)
-    Dir.glob("**/#{file_name}")
-  end
-
-  def directory_of(file_path)
-    File.dirname(file_path)
-  end
-
-end

data/lib/sfb_scripts/dependency_loader.rb

@@ -1,22 +0,0 @@
-require 'work_queue'
-
-# this is a bummer...
-require_relative 'monkey_patches/string_extension'
-require_relative 'bundler/bundle_manager'
-require_relative 'hooks/pre_push_hook'
-require_relative 'hook_manager'
-require_relative 'migrations/migrator'
-require_relative 'repositories/repo'
-require_relative 'repositories/active_repo'
-require_relative 'repositories/lazy_repo'
-require_relative 'shells/shell_runner'
-require_relative 'shells/loud_shell_runner'
-require_relative 'shells/verbose_shell_runner'
-require_relative 'test_running/status_checker'
-require_relative 'test_running/test_case'
-require_relative 'test_running/test_collection'
-require_relative 'test_running/status_test_runner'
-require_relative 'test_running/test_runner'
-require_relative 'test_running/test_finder'
-require_relative 'test_running/test_filter'
-require_relative 'folder_guard'

data/lib/sfb_scripts/folder_guard.rb

@@ -1,11 +0,0 @@
-class FolderGuard
-
-  attr_reader :denied_matches
-  def initialize(denied_matches)
-    @denied_matches = denied_matches
-  end
-
-  def allowed?(folder)
-    denied_matches.select { |d| folder.match(d) }.empty?
-  end
-end

data/lib/sfb_scripts/hook_manager.rb

@@ -1,36 +0,0 @@
-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/sfb_scripts/hooks/pre_push_hook.rb

@@ -1,31 +0,0 @@
-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/sfb_scripts/migrations/migrator.rb

@@ -1,42 +0,0 @@
-class Migrator
-  attr_accessor :shell, :repo, :queue, :folder_guard, :drop_dbs
-
-  def initialize(repo:, shell:, queue:, folder_guard:, drop_dbs: false)
-    @shell = shell
-    @repo = repo
-    @queue = queue
-    @drop_dbs = drop_dbs
-    @folder_guard = folder_guard
-  end
-
-  def migrate_where_necessary
-    shell.notify "\nMigrating:"
-    migrations.each do |migration|
-      queue.enqueue_b do
-        shell.run "RAILS_ENV=#{migration[:env]} bundle exec rake #{drop_dbs ? 'db:drop' : ''} db:create 2> /dev/null;\n RAILS_ENV=#{migration[:env]} bundle exec rake db:migrate", dir: migration[:dir]
-      end
-    end
-    queue.join
-  end
-
-  def directories_to_migrate
-    migrate_dirs = repo.files_changed.select {|f| f.match("/migrate/") }.map {|f| File.dirname(f) }.map {|dir| dir.gsub(/\/db\/migrate$/, '')}.uniq
-    migrate_dirs.select {|d| folder_guard.allowed?(d) };
-  end
-
-  private
-
-  def migrations
-    directories_to_migrate.map do |dir|
-      [
-        {env: "development",dir: dir},
-        {env: "test", dir: dir}
-      ]
-    end.flatten
-  end
-
-  def in_rack_application?(migrate_dir)
-    folder_guard.allowed?(migrate_dir)
-  end
-
-end

data/lib/sfb_scripts/monkey_patches/string_extension.rb

@@ -1,22 +0,0 @@
-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/sfb_scripts/needs_manager.rb

@@ -1,94 +0,0 @@
-require_relative 'dependency_loader'
-
-class NeedsManager
-
-  BUNDLER_MAX_THREAD_COUNT = 4
-  MIGRATOR_MAX_THREAD_COUNT = 8
-
-  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
-    # symbolize_keys
-    @options = options.inject({}){|results,(k,v)| results[k.to_sym] = v; results}
-    @env = {}
-  end
-
-  def configure
-    set_working_directory
-
-    create_shell
-    create_folder_guard
-
-    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[:verbose]
-      VerboseShellRunner
-    elsif options[:loud]
-      LoudShellRunner
-    else
-      ShellRunner
-    end
-  end
-
-  def create_folder_guard
-    denied_folders = options[:ignore] || []
-    env[:folder_guard] = FolderGuard.new(denied_folders)
-  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
-    queue = WorkQueue.new(BUNDLER_MAX_THREAD_COUNT, nil)
-    env[:bundler] = BundleManager.new(shell: env[:shell], repo: env[:repo], queue: queue, folder_guard: env[:folder_guard])
-  end
-
-  def create_migrator
-    queue = WorkQueue.new(MIGRATOR_MAX_THREAD_COUNT, nil)
-    env[:migrator] = Migrator.new(shell: env[:shell], repo: env[:repo], queue: queue, folder_guard: env[:folder_guard], drop_dbs: options[:reset])
-  end
-
-  def create_test_runner
-    env[:test_runner] = TestRunner.new(
-      shell: env[:shell],
-      all_engines: options[:all_engines],
-      always_ask_before_grouping_tests: options[:timid]
-    )
-  end
-
-  def log_file_for(task)
-    "/tmp/#{task}.log"
-  end
-end

data/lib/sfb_scripts/repositories/active_repo.rb

@@ -1,60 +0,0 @@
-class ActiveRepo < Repo
-
-  def alter!(git_command)
-    shell.notify "\nUpdating repo state:"
-    up do
-      # will raise an error with merge conflicts
-      begin
-        shell.run "git #{git_command}"
-      rescue ShellRunner::CommandFailureError
-        puts "Unable to rebase.  Maybe you need to stash local changes, or there are rebase conflicts"
-        exit
-      end
-    end
-  end
-
-  def up_master!
-    move_to_master!
-    rebase_on_master!
-  end
-
-  def up
-    old_sha = current_sha
-    yield
-
-    set_files_changed(old_sha)
-  end
-
-  def set_files_changed(old_sha)
-    shell.notify "\nIdentifying changed files:"
-    @files_changed = (shell.run "git diff --name-only #{old_sha}").split("\n")
-  end
-
-  def files_changed
-    @files_changed
-  end
-
-  def pull_origin_master!
-    up do
-      fetch_origin
-      reset_hard_origin_master!
-    end
-  end
-
-  def compare_with_reflog
-    old_sha = shell.run "git rev-parse HEAD@{2}"
-    set_files_changed(old_sha)
-  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/sfb_scripts/repositories/lazy_repo.rb

@@ -1,16 +0,0 @@
-class LazyRepo < Repo
-
-  def initialize(*args)
-    super
-    set_all_files
-  end
-
-  def files_changed
-    @all_files
-  end
-
-  def set_all_files
-    shell.notify "\nIdentifying all files:"
-    @all_files = shell.run("git ls-tree --full-tree -r HEAD --name-only").split("\n")
-  end
-end

data/lib/sfb_scripts/repositories/repo.rb

@@ -1,70 +0,0 @@
-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 changed?(file_path)
-    files_changed.include? file_path
-  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 --untracked '#{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.strip
-    # we rejoin on ':' because our
-    # code may have colons inside of it.
-    #
-    # example:
-    # path/to/file: run_method(a: A, b: B)
-    #
-    # so shift the first one out, then
-    # rejoin the rest
-    line = splits.join(':').strip
-
-    {
-      :file => file,
-      :line => line,
-    }
-  end
-
-  def current_sha
-    shell.run "git rev-parse HEAD"
-  end
-
-
-end

data/lib/sfb_scripts/shells/loud_shell_runner.rb

@@ -1,7 +0,0 @@
-class LoudShellRunner < ShellRunner
-
-  def handle_output_for(cmd)
-    puts cmd
-    log(cmd)
-  end
-end

data/lib/sfb_scripts/shells/shell_runner.rb

@@ -1,88 +0,0 @@
-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}"
-    handle_output_for(command)
-    shell_out(command)
-  end
-
-  def shell_out(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 get_number_list_for_question(question)
-    warn question 
-    answer = STDIN.gets.strip
-
-    answer.split(',').map do |term|
-      if term.include?('-')
-        (term.split('-')[0].to_i..term.split('-')[1].to_i).to_a
-      else
-        term.to_i
-      end
-    end.flatten
-  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
-
-  def handle_output_for(cmd)
-    log(cmd)
-  end
-
-end

data/lib/sfb_scripts/shells/verbose_shell_runner.rb

@@ -1,8 +0,0 @@
-class VerboseShellRunner < LoudShellRunner
-
-  def run(*args)
-    super(*args).tap do |results|
-      puts results
-    end
-  end
-end

data/lib/sfb_scripts/test_running/status_checker.rb

@@ -1,62 +0,0 @@
-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
-    TestFilter.select_tests(file_names)
-  end
-
-  def non_test_files
-    TestFilter.reject_tests(file_names)
-  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/sfb_scripts/test_running/status_test_runner.rb

@@ -1,41 +0,0 @@
-class StatusTestRunner
-
-  def self.status(env, ignore_selenium=false)
-    new(env, ignore_selenium).status
-  end
-
-  attr_reader :repo, :shell, :test_runner, :status_tests, :ignore_selenium
-  def initialize(env, ignore_selenium)
-    @repo = env[:repo]
-    @shell = env[:shell]
-    @test_runner = env[:test_runner]
-    @ignore_selenium = ignore_selenium
-    @status_tests = get_status_tests
-  end
-
-  def status
-    if status_tests.include_selenium?
-      handle_selenium
-    end
-
-    if status_tests.empty?
-      shell.notify 'No tests to run'
-      exit
-    end
-
-    test_runner.run_files(status_tests)
-  end
-
-  private
-
-  def handle_selenium
-    if ignore_selenium || shell.deny?("The status includes some selenium files.  Do you wish to run those?")
-      status_tests.remove_selenium!
-    end
-  end
-
-  def get_status_tests
-    files = TestFilter.select_tests(repo.status_files)
-    TestCollection.new(files)
-  end
-end

data/lib/sfb_scripts/test_running/test_case.rb

@@ -1,38 +0,0 @@
-class TestCase
-  TestDirectoryError = Class.new(StandardError)
-
-  attr_reader :working_dir, :relative_path, :test_name, :full_path
-
-  def initialize(full_path: raise, line: '')
-    raise 'Bad Test File' unless full_path.match(/_test\.rb/)
-
-    @test_name = test_name_from_grepped_line(line)
-    @full_path = full_path
-  end
-
-  def working_dir
-    @working_dir ||=
-      if full_path.match(/^(.*)test\//)
-        File.join(".", full_path.match(/^(.*)test\//)[1])
-      else
-        raise TestDirectoryError.new("Can't find test's working directory")
-      end
-  end
-
-  def is_method?
-    ! @test_name.nil?
-  end
-
-  def relative_path
-    @relative_path ||= full_path.gsub(/^#{working_dir.gsub(/^\.\//, '')}/, '') || raise_file_path_error
-  end
-
-  def raise_file_path_error
-    raise TestDirectoryError.new("Can't find test's relative path")
-  end
-
-  def test_name_from_grepped_line(line)
-    return unless line && line.match(/^\s*def\s+test_/)
-    @test_name = line.strip.gsub(/^\s*def\s+/, '').strip
-  end
-end

data/lib/sfb_scripts/test_running/test_collection.rb

@@ -1,97 +0,0 @@
-class TestCollection
-
-  MultipleWorkingDirectoriesError = Class.new(StandardError)
-
-  attr_reader :tests, :query
-
-  def initialize(tests_data=[], query: '')
-    @query = query
-    @tests = tests_data.map do |test_data|
-      if test_data.is_a? TestCase
-        test_data
-      else
-        test_data = {file: test_data} if test_data.is_a?(String)
-
-        TestCase.new(
-          full_path: test_data[:file],
-          line: test_data[:line]
-        )
-      end
-    end.compact
-  end
-
-  def empty?
-    tests.empty?
-  end
-
-  def uniq!
-    @tests = @tests.uniq {|e| "#{e.full_path} #{e.test_name} #{e.working_dir}" }
-  end
-
-  def present?
-    ! empty?
-  end
-
-  def size
-    tests.size
-  end
-
-  def first
-    tests.first
-  end
-
-  def [](*args)
-    tests[*args]
-  end
-
-  def all?(&block)
-    tests.all?(&block)
-  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
-
-  def is_one_test_method?
-    (size == 1) &&  tests.first.is_method?
-  end
-
-end

data/lib/sfb_scripts/test_running/test_filter.rb

@@ -1,15 +0,0 @@
-class TestFilter
-  def self.select_tests(files)
-    filter(action: :select, files: files)
-  end
-
-  def self.reject_tests(files)
-    filter(action: :reject, files: files)
-  end
-
-  private
-
-  def self.filter(action:, files:)
-    files.send(action) {|f| f.match(/_test(\.rb)?$/) }
-  end
-end

data/lib/sfb_scripts/test_running/test_finder.rb

@@ -1,70 +0,0 @@
-class TestFinder
-
-  def self.find(query, env)
-    new(env, query).find
-  end
-
-  attr_accessor :shell, :repo, :query
-  def initialize(env, query)
-    @shell = env[:shell]
-    @repo = env[:repo]
-    @query = query
-    @regex_searches = {}
-  end
-
-  def find
-    return tests_found_by_absolute_path if query.match(Repo.root_dir)
-
-    return tests_found_by_name if tests_found_by_name.present?
-
-    return tests_found_by_file_name if tests_found_by_file_name.present?
-
-    return tests_found_by_full_regex if tests_found_by_full_regex.present?
-
-    return TestCollection.new
-  end
-
-  private
-
-  def tests_found_by_absolute_path
-    TestCollection.new([file: query.gsub(Repo.root_dir, '')])
-  end
-
-  def tests_found_by_name
-    @tests_found_by_name ||=
-      begin
-        tests_found_by_full_regex("^\s*def .*#{query}.*")
-      end
-  end
-
-  def tests_found_by_full_regex(regex = query)
-    @regex_searches[regex] ||=
-      begin
-        test_matches = []
-        begin
-          test_matches =  repo.grep(regex, file_pattern: '*_test.rb')
-        rescue ShellRunner::CommandFailureError
-          # git grep returns 1 if no results found
-        end
-
-        TestCollection.new(test_matches, query: query)
-      end
-  end
-
-  def tests_found_by_file_name
-    @tests_found_by_file_name ||=
-      begin
-        files = TestFilter.select_tests(repo.find_files(query))
-        TestCollection.new(files)
-      end
-  end
-
-  def might_be_method?(query)
-    ! is_file_path?(query)
-  end
-
-  def is_file_path?(query)
-    !! query.match(/\.rb/)
-  end
-
-end

data/lib/sfb_scripts/test_running/test_runner.rb

@@ -1,121 +0,0 @@
-class TestRunner
-
-  attr_reader :shell, :all_engines_param, :always_ask_before_grouping_tests
-  def initialize(env)
-    @shell = env[:shell]
-    @all_engines_param = env[:all_engines]
-    @always_ask_before_grouping_tests = env[:always_ask_before_grouping_tests]
-  end
-
-  # Hack: this could use *a lot* of love
-  # this could use some love
-  def run(tests)
-
-    if tests.empty?
-      shell.warn "Unable to identify any tests."
-      exit
-
-    elsif tests.is_one_test_method?
-      test = tests.first
-      run_method(path: test.relative_path, name: test.test_name, dir: test.working_dir)
-    elsif always_ask_before_grouping_tests
-      ask_user_which_tests_to_run(tests)
-    elsif tests.in_one_file? && tests.all? {|t| t.is_method? }
-      shell.notify "Multiple matches in same file. Running those tests"
-      test = tests.first
-      run_method(path: test.relative_path, name: tests.query, dir: test.working_dir)
-
-    elsif tests.in_one_file? #catches regex that matched a test file or other regex that matched in the body
-      shell.notify "Matched one file. Running that file."
-      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."
-      run_files(tests)
-
-    else
-      ask_user_which_tests_to_run(tests)
-    end
-  end
-
-  def run_method(path:, name:, dir:)
-    test_runner = named_test_runner(dir)
-    shell.exec("#{test_runner} #{path} --name=/#{name}/", dir: dir)
-  end
-
-  def ask_user_which_tests_to_run(tests)
-      shell.warn 'Found too many tests. Please choose which matches you would like to run:'
-
-      tests.uniq!.each_with_index do |t, index| 
-        shell.notify "(#{index}) #{t.full_path}: #{t.test_name}" 
-      end
-
-      tests_to_run = shell.get_number_list_for_question('Please enter the match numbers you would like to run(comma seperated)')
-
-      new_tests = tests_to_run.map do |index|
-        tests[index]
-      end
-      @always_ask_before_grouping_tests = false
-      run(TestCollection.new(new_tests))
-  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
-
-  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/sfb_scripts/tester.rb

@@ -1,44 +0,0 @@
-require_relative 'needs_manager'
-
-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(input)
-    tests = TestFinder.find(input, env)
-
-    env[:test_runner].run(tests)
-    env[:shell].warn "Giving up :("
-  end
-
-  def status(options)
-    StatusTestRunner.status(env, options[:no_selenium])
-  end
-
-  def status_check(options)
-    StatusChecker.report(env, options[:confirm_exit_status])
-  end
-
-end

data/lib/sfb_scripts/upper.rb

@@ -1,93 +0,0 @@
-require_relative 'needs_manager'
-
-class Upper
-
-  def self.needs
-    [:shell, :repo, :bundler, :migrator]
-  end
-
-  def self.with_defaults(options)
-    {loud: true}.merge(options)
-  end
-
-  def self.arbitrary_action!(git_command, options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :active))
-    new(env).arbitrary_action!(git_command)
-  end
-
-  def self.rebase_on_branch!(options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :active))
-    new(env).arbitrary_action!("pull --rebase origin #{env[:repo].current_branch}")
-  end
-
-  def self.rebase_on_master!(options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :active))
-    new(env).arbitrary_action!("pull --rebase origin master")
-  end
-
-  def self.up_master!(options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :active))
-    new(env).up_master!
-  end
-
-  def self.no_git(options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :lazy))
-    new(env).no_git
-  end
-
-  def self.finish_rebase(options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :active))
-    new(env).finish_rebase
-  end
-
-  def self.install_hooks(options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :lazy))
-    new(env).install_hooks
-  end
-
-  def self.pre_push_hook(git_command, options)
-    env = NeedsManager.configure(:up, needs, with_defaults(options).merge(repo_type: :active))
-    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 arbitrary_action!(git_command)
-    repo.alter!(git_command)
-    bundler.bundle_where_necessary
-    migrator.migrate_where_necessary
-  end
-
-  def no_git
-    env[:shell].notify "\nBundling and migrating without checking diffs:"
-    bundler.bundle_where_necessary
-    migrator.migrate_where_necessary
-  end
-
-  def finish_rebase
-    repo.compare_with_reflog
-    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

data/lib/sfb_scripts/version.rb

@@ -1,3 +0,0 @@
-module SfbScripts
-  VERSION = "1.9.0"
-end