app_up 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eef6f3f77e220c881a1ee5b8e4807976c6915a9c
-  data.tar.gz: 1fecafff7c0e6c14a60cc29f3097c8dcbe4a3fd7
+  metadata.gz: f6264df18b90b7334a402f1014f216dff432adcf
+  data.tar.gz: 8fe5a3b5832b6b28dc25e2e5603da299de8108e1
 SHA512:
-  metadata.gz: 200f718b10203e5b2db99ee188b2394d9e9acf4657d1792b346bf6efceda300753242458591bd0e60340cce68fea7859a2b134a4a7ff4209ee6f4945832547e8
-  data.tar.gz: 2f2abe122a1cfbe867010adcca4703a1a9a2f93b69fe11b9db73c3aa5b98f27b804bdf4daadf2e38b20458412dc712f5607be9362fa5f6e275e361fc9de56250
+  metadata.gz: 746d761c3b042190eae0047be9d768df94e0347d07e4ac1afc84a4c74b4672ec3cee10bee1f95d7b8d04178b9a90fb13b5b2b9e8e25f91838ef17482ba6592ae
+  data.tar.gz: 79bef96bf3eb9f891298604e4c5044f68cb1115b3d12cc8dc9a15b38f8320eabb41ac2fca49b52d78e69a958707fd1f2da213f39dc016d817de3be2ac936f1a9

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 *.gem
+notes.txt

data/Gemfile

@@ -5,6 +5,9 @@ gemspec
 
 gem 'minitest'
 gem 'pry'
+gem 'pry-byebug'
+gem 'pry-rescue'
+gem 'pry-stack_explorer'
 gem 'mocha'
 
 ruby '2.1.5'

data/README.md

@@ -1,31 +1,2 @@
-# GitUp
-
-TODO: Write a gem description
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'app_up'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install git_up
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it ( https://github.com/[my-github-username]/git_up/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+Todo: 
+  this

data/bin/app_up

@@ -1,24 +1,37 @@
 #!/usr/bin/env ruby
 
 require 'thor'
-require_relative '../lib/app_up'
+require 'app_up'
 
 class AppUpCLI < Thor
 
-  desc :run, description: "do stuff"
-  option :diff, type: :array, desc: "SHAs to be diffed"
-  option :all, type: :boolean, desc: "Run all of the hooks"
-  option :verbose, type: :boolean, desc: "say all things"
-  option :db_reset, aliases: ['--reset', '--drop-dbs'], type: :boolean, desc: "Drop and recreate all databases"
+  desc :run_hooks, %{Run "app_up --help run_hooks" to learn more}
+  long_desc <<-DESC
+    app_up automatically run "bundle install" and "rake db:migrate" in your app.  It decides what to do based on the options listed above.
+
+    The AppUp gem installs two executables: "app_up" and "git_up".  It is often more convenient to use the "git_up" command, which itself calls this "app_up" executable.
+  DESC
+
+  option :diff, type: :array, desc: %{Provide Git SHAs to be diffed.  e.g. "app_up --diff HEAD d3be822a".  If only one SHA is given, the second will default to HEAD.}
+  option :all, type: :boolean, desc: %{Run all hooks without diffing anything.  This is the default action.}
+  option :verbose, type: :boolean, desc: %{Show the commands being run}
+  option :db_reset, aliases: ['--reset', '--drop-dbs'], type: :boolean, desc: %{Drop databases before creating and migrating}
 
   def run_hooks
-    shell = AppUp::ShellRunner.new(
+    shell = AppUp::Shell::Runner.new(
       log_path: '/tmp/app_up.log',
-      working_directory: '.'
+      working_directory: '.',
+      verbose: options[:verbose],
     )
 
+    if !options.has_key?(:diff)
+      options[:all] = true
+    elsif options[:diff].size == 1
+      options[:diff] << "HEAD"
+    end
+
     files = AppUp::Repo.new(shell, options).files
-    AppUp::HookRunner.new(shell, files, options).run
+    AppUp::Hooks::Runner.new(shell, files, options).run
   end
 
   default_task :run_hooks

data/bin/git_up

@@ -1,6 +1,20 @@
 #!/usr/bin/env ruby
 
 #PETE: make this a bash script
+if ARGV[0] == "--help" || ARGV[0] == "-h"
+  puts <<-HELP
+  ---
+  git_up is a wrapper for git.  It compares the starting SHA and ending SHA of a git action and will run hooks to bundle and migrate your application.
+
+  You can pass git_up any git command.  e.g. "git_up pull origin master"
+
+  If you pass no arguments, git_up will default to calling "git_up pull --rebase origin master"
+
+  See "app_up --help run_hooks" to see how the bundle/migration works.
+  ---
+  HELP
+  exit
+end
 
 def get_sha
   %x{git rev-parse HEAD}.chomp

data/lib/app_up/configuration/config.rb

@@ -0,0 +1,13 @@
+module AppUp
+  module Configuration
+    class Config
+
+      @ignore = []
+
+      class << self
+        attr_accessor :ignore
+      end
+
+    end
+  end
+end

data/lib/app_up/configuration/loader.rb

@@ -0,0 +1,21 @@
+require "app_up/configuration/config"
+
+module AppUp
+  module Configuration
+    module Loader
+
+      def user_config(config_class: Config, filename:)
+
+        self.singleton_class.send(:define_method, :config) do |&config_block|
+          config_block.call(config_class)
+        end
+
+        home = File.expand_path("~")
+        config_file = File.join(home, filename)
+        if File.exists?(config_file)
+          load config_file
+        end
+      end
+    end
+  end
+end

data/lib/app_up/hooks/loader.rb

@@ -0,0 +1,14 @@
+require "app_up/hooks/rails_up"
+
+module AppUp
+  module Hooks
+    class Loader
+
+      def self.load
+        [
+          Hooks::RailsUp,
+        ]
+      end
+    end
+  end
+end

data/lib/app_up/hooks/rails_up.rb

@@ -14,12 +14,18 @@ module AppUp
         shell.notify( "Running RailsUp\n----------")
 
         files.each do |file|
-          if File.basename(file) == "Gemfile.lock"
-            add_command(:bundle, dir: File.split(file)[0])
+          exploded_path = Utils::Path.split(file)
+
+          # allow rebundle on only Gemfile edit, in case you're
+          # upping a gem, which probably doesn't have the Gemfile.lock
+          # checked in
+          if exploded_path.last.match(/Gemfile(\.lock)?|gemspec$/)
+            add_command(:bundle, dir: exploded_path[0..-2])
           end
 
-          if file.match(/db\/migrate/)
-            add_command(:migrate, dir: file.sub(/\/db\/migrate\/.*/, ''))
+          if exploded_path.include?("migrate")
+            last_db_index =  exploded_path.rindex("db")
+            add_command(:migrate, dir: exploded_path[0...last_db_index])
           end
         end
 
@@ -47,7 +53,7 @@ module AppUp
           }
 
           actions.each do |command|
-            shell.enqueue(:notify, "#{i.to_s.rjust(command_count.length)}/#{command_count.to_s} #{command.to_s.ljust(7)} : #{dir}")
+            shell.enqueue(:notify, "#{i.to_s.rjust(command_count.length)}/#{command_count.to_s} #{command.to_s.ljust(7)} : #{Utils::Path.join(dir)}")
             i+=1
           end
 

data/lib/app_up/hooks/runner.rb

@@ -0,0 +1,18 @@
+require "app_up/hooks/loader"
+
+module AppUp
+  module Hooks
+    class Runner < Struct.new(:shell, :files, :options)
+
+      def run
+        hooks = Hooks::Loader.load
+
+        hooks.each do |hook|
+          hook.run(shell, files, options)
+        end
+
+        shell.flush
+      end
+    end
+  end
+end

data/lib/app_up/repo.rb

@@ -1,7 +1,16 @@
 module AppUp
   class Repo < Struct.new(:shell, :options)
 
+    private :shell, :options
+
     def files
+      ignores = options.has_key?(:ingore) ? options[:ignore] : Configuration::Config.ignore
+      default_files.reject {|f| ignores.any? {|i| f.match(i)} }
+    end
+
+    private
+
+    def default_files
       if options[:diff]
         diff(*options[:diff])
       else
@@ -9,8 +18,6 @@ module AppUp
       end
     end
 
-    private
-
     def all
       shell.run "git ls-tree --full-tree -r HEAD --name-only"
     end

data/lib/app_up/shell/color.rb

@@ -0,0 +1,26 @@
+module AppUp
+  module Shell
+    module Color
+      CODES = {
+        red: 31,
+        green: 32,
+        yellow: 33,
+        pink: 35,
+      }.freeze
+
+      CODES.each do |color, code|
+        self.send(:define_method, color) do |string|
+          colorize(string, code)
+        end
+      end
+
+      private
+
+      # colorization
+      def colorize(string, color_code)
+        "\e[#{color_code}m#{string}\e[0m"
+      end
+
+    end
+  end
+end

data/lib/app_up/shell/runner.rb

@@ -0,0 +1,78 @@
+require "work_queue"
+require "app_up/shell/color"
+
+module AppUp
+  module Shell
+    class Runner
+      include Color
+
+      MAX_PROCESS_COUNT = 8
+      CommandFailureError = Class.new(StandardError)
+
+      attr_accessor :working_directory, :log_path, :queue
+      private :working_directory, :log_path, :queue
+
+      def initialize(log_path:, working_directory:, verbose: false)
+        @working_directory = working_directory
+        @log_path = log_path
+        @verbose = verbose
+
+        @queue = WorkQueue.new(MAX_PROCESS_COUNT, nil)
+
+        %x{echo "" > #{log_path}}
+        Dir.chdir(%x[ git rev-parse --show-toplevel ].chomp)
+      end
+
+      # The block passed to run is a callback. It is used
+      # to add a dependent command to the queue.
+      def run(cmd, dir: working_directory, &block)
+        command = "cd #{Utils::Path.relative_join(dir)} && #{cmd}"
+        handle_output_for(command)
+
+        shell_out(command).split("\n").tap do
+          block.call if block_given?
+        end
+      end
+
+      def warn(msg)
+        log msg.to_s
+        print "#{red(msg.to_s)}\n"
+      end
+
+      def notify(msg)
+        return if @verbose
+
+        log msg.to_s
+        print "#{yellow(msg.to_s)}\n"
+      end
+
+      def enqueue(method, *args, &block)
+        queue.enqueue_b do
+          send(method, *args, &block)
+        end
+      end
+
+      def flush
+        queue.join
+      end
+
+      private
+
+      def log(msg)
+        %x{echo "#{msg.to_s}" >> #{log_path}}
+      end
+
+      def handle_output_for(cmd)
+        puts cmd if @verbose
+        log(cmd)
+      end
+
+      def shell_out(command)
+        %x{ set -o pipefail && #{command} 2>> #{log_path} | tee -a #{log_path} }.chomp.tap do
+          warn "The following command has failed: #{command}.  See #{log_path} for a full log." if ($?.exitstatus != 0)
+        end
+      end
+
+    end
+  end
+end

data/lib/app_up/utils/path.rb

@@ -0,0 +1,32 @@
+require "pathname"
+
+module AppUp
+  module Utils
+    module Path
+
+      def self.split(filename)
+        self.prepend_pwd(Pathname.new(filename).each_filename.to_a)
+      end
+
+      def self.path_for(filename)
+        self.split(File.split(file)[0])
+      end
+
+      def self.join(*array)
+        File.join(*array)
+      end
+
+      def self.prepend_pwd(dirs)
+        if dirs[0] == "."
+          dirs
+        else
+          ["."] + dirs
+        end
+      end
+
+      def self.relative_join(array)
+        join(prepend_pwd(array))
+      end
+    end
+  end
+end

data/lib/app_up/version.rb

@@ -1,3 +1,3 @@
 module AppUp
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/app_up.rb

@@ -1,8 +1,12 @@
-require_relative "app_up/version"
-require_relative "app_up/hook_runner"
-require_relative 'app_up/repo'
-require_relative 'app_up/shell_runner'
+require "app_up/version"
+require "app_up/utils/path"
+require "app_up/hooks/runner"
+require "app_up/repo"
+require "app_up/shell/runner"
+require "app_up/configuration/loader"
 
 module AppUp
-  # Your code goes here...
+  extend Configuration::Loader
+
+  user_config filename: ".app_up"
 end

data/test/git_up/hooks/rails_up_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 module AppUp
   module Hooks
@@ -31,44 +31,46 @@ module AppUp
 
       def test_bundle_directories
         files = [
-          'folder/sub_folder/Gemfile.lock',
-          'other_folder/other_subfolder/more/Gemfile.lock',
-          'unused/Gemfile'
+          "folder/sub_folder/Gemfile",
+          "other_folder/other_subfolder/more/Gemfile.lock",
+          "some_gem/thing/thing.gemspec",
+          "unused/Gemthingspec",
         ]
 
         hook = RailsUp.new(@shell, files, {})
 
         hook.run
-        assert_equal 2, @shell.history[:enqueue].select {|c| c[0]==:run}.size
-        assert @shell.history[:enqueue].include?([:run, RailsUp::BUNDLE_COMMAND, dir: 'folder/sub_folder']), @shell.history
-        assert @shell.history[:enqueue].include?([:run, RailsUp::BUNDLE_COMMAND, dir: 'other_folder/other_subfolder/more']), @shell.history
+        assert_equal 3, @shell.history[:enqueue].select {|c| c[0]==:run}.size
+        assert @shell.history[:enqueue].include?([:run, RailsUp::BUNDLE_COMMAND, dir: [".", "folder", "sub_folder"]]), @shell.history
+        assert @shell.history[:enqueue].include?([:run, RailsUp::BUNDLE_COMMAND, dir: [".", "other_folder", "other_subfolder", "more"]]), @shell.history
+        assert @shell.history[:enqueue].include?([:run, RailsUp::BUNDLE_COMMAND, dir: [".", "some_gem", "thing"]]), @shell.history
       end
 
       def test_migrate_directories
         files = [
-          'folder/sub_folder/db/migrate/migration.rb',
-          'other_folder/other_subfolder/more/db/migrate/migration.rb',
-          'unused/db/config.rb',
+          "folder/sub_folder/db/migrate/migration.rb",
+          "other_folder/other_subfolder/more/db/migrate/migration.rb",
+          "unused/db/config.rb",
         ]
 
         hook = RailsUp.new(@shell, files, {})
-        hook.stubs(:migrate).with('test').returns('migrate_test')
-        hook.stubs(:migrate).with('development').returns('migrate_development')
+        hook.stubs(:migrate).with("test").returns("migrate_test")
+        hook.stubs(:migrate).with("development").returns("migrate_development")
 
         hook.run
         assert_equal 4, @shell.history[:enqueue].select {|c| c[0]==:run}.size
-        assert @shell.history[:enqueue].include?([:run, 'migrate_test', dir: 'folder/sub_folder']), @shell.history
-        assert @shell.history[:enqueue].include?([:run, 'migrate_development', dir: 'folder/sub_folder']), @shell.history
-        assert @shell.history[:enqueue].include?([:run, 'migrate_test', dir: 'other_folder/other_subfolder/more']), @shell.history
-        assert @shell.history[:enqueue].include?([:run, 'migrate_development', dir: 'other_folder/other_subfolder/more']), @shell.history
+        assert @shell.history[:enqueue].include?([:run, "migrate_test", dir: [".", "folder", "sub_folder"]]), @shell.history
+        assert @shell.history[:enqueue].include?([:run, "migrate_development", dir: [".", "folder", "sub_folder"]]), @shell.history
+        assert @shell.history[:enqueue].include?([:run, "migrate_test", dir: [".", "other_folder", "other_subfolder", "more"]]), @shell.history
+        assert @shell.history[:enqueue].include?([:run, "migrate_development", dir: [".", "other_folder", "other_subfolder", "more"]]), @shell.history
       end
 
       def test_migrate__drops_db
-        no_drop_hook = RailsUp.new('stub', 'stub', {})
-        assert_equal nil, no_drop_hook.send(:migrate, 'test').match(/db:drop/)
+        no_drop_hook = RailsUp.new("stub", "stub", {})
+        assert_equal nil, no_drop_hook.send(:migrate, "test").match(/db:drop/)
 
-        no_drop_hook = RailsUp.new('stub', 'stub', {db_reset: true})
-        assert no_drop_hook.send(:migrate, 'test').match(/db:drop/)
+        no_drop_hook = RailsUp.new("stub", "stub", {db_reset: true})
+        assert no_drop_hook.send(:migrate, "test").match(/db:drop/)
       end
     end
   end

data/test/test_helper.rb

@@ -1,6 +1,5 @@
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
 
-require 'pry'
 require 'minitest/autorun'
 require 'app_up'
 require 'mocha/mini_test'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: app_up
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Pete Kinnecom
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-25 00:00:00.000000000 Z
+date: 2015-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,12 +96,16 @@ files:
 - bin/app_up
 - bin/git_up
 - lib/app_up.rb
-- lib/app_up/hook_loader.rb
-- lib/app_up/hook_runner.rb
+- lib/app_up/configuration/config.rb
+- lib/app_up/configuration/loader.rb
 - lib/app_up/hooks/hook.rb
+- lib/app_up/hooks/loader.rb
 - lib/app_up/hooks/rails_up.rb
+- lib/app_up/hooks/runner.rb
 - lib/app_up/repo.rb
-- lib/app_up/shell_runner.rb
+- lib/app_up/shell/color.rb
+- lib/app_up/shell/runner.rb
+- lib/app_up/utils/path.rb
 - lib/app_up/version.rb
 - test/git_up/hooks/rails_up_test.rb
 - test/test_helper.rb

data/lib/app_up/hook_loader.rb

@@ -1,12 +0,0 @@
-require "app_up/hooks/rails_up"
-
-module AppUp
-  class HookLoader
-
-    def self.load
-      [
-        Hooks::RailsUp,
-      ]
-    end
-  end
-end

data/lib/app_up/hook_runner.rb

@@ -1,16 +0,0 @@
-require "app_up/hook_loader"
-
-module AppUp
-  class HookRunner < Struct.new(:shell, :files, :options)
-
-    def run
-      hooks = HookLoader.load
-
-      hooks.each do |hook|
-        hook.run(shell, files, options)
-      end
-
-      shell.flush
-    end
-  end
-end

data/lib/app_up/shell_runner.rb

@@ -1,99 +0,0 @@
-require 'work_queue'
-
-module AppUp
-  class ShellRunner
-    MAX_PROCESS_COUNT = 8
-    CommandFailureError = Class.new(StandardError)
-
-    attr_accessor :working_directory, :log_path, :queue
-    private :working_directory, :log_path, :queue
-
-    def initialize(log_path:, working_directory:, verbose: false)
-      @working_directory = working_directory
-      @log_path = log_path
-      @queue = WorkQueue.new(MAX_PROCESS_COUNT, nil)
-      @verbose = verbose
-      Dir.chdir(%x[ git rev-parse --show-toplevel ].chomp)
-
-      reset_log
-    end
-
-    # The block passed to run is a callback. It is used
-    # to add a dependent command to the queue.
-    def run(cmd, dir: working_directory, &block)
-      command = "cd #{dir} && #{cmd}"
-      handle_output_for(command)
-
-      shell_out(command).split("\n").tap do
-        block.call if block_given?
-      end
-    end
-
-    def warn(msg)
-      log msg.to_s
-      print "#{msg.to_s.red}\n"
-    end
-
-    def notify(msg)
-      log msg.to_s
-      print "#{msg.to_s.yellow}\n"
-    end
-
-    def enqueue(method, *args, &block)
-      queue.enqueue_b do
-        send(method, *args, &block)
-      end
-    end
-
-    def flush
-      queue.join
-    end
-
-    private
-
-    def log(msg)
-      %x{echo "#{msg.to_s}" >> #{log_path}}
-    end
-
-    def reset_log
-      %x{echo "" > #{log_path}}
-    end
-
-    def handle_output_for(cmd)
-      puts cmd if @verbose
-      log(cmd)
-    end
-
-    def shell_out(command)
-      %x{ set -o pipefail && #{command} 2>> #{log_path} | tee -a #{log_path} }.chomp.tap do
-        warn "The following command has failed: #{command}.  See #{log_path} for a full log." if ($?.exitstatus != 0)
-      end
-    end
-
-  end
-end
-
-#PETE: hack
-
-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