gitty 0.1.0 → 0.2.0

data/assets/hooks/{git-post-checkout-submodules → auto-submodules}

@@ -39,6 +39,7 @@ module GitMethods
   end
 end
 include GitMethods
+HELPERS = File.expand_path(ENV['HELPERS'], Dir.pwd)
 
 chdir_parent
 current_submodules = list_submodules('HEAD')
@@ -65,10 +66,35 @@ previous_submodules = list_submodules('HEAD@{1}')
   when rev != current_submodules[path]
     output_submodule_header(path)
     # it should be updated to the latest
-    # Fetch if it the change doesn't exist
     Dir.chdir(path) do
+      # Fetch if it the change doesn't exist
       system("(git show '#{current_submodules[path]}' 2> /dev/null 1> /dev/null) || git fetch")
-      system("git checkout '#{current_submodules[path]}'")
+
+      current_rev = current_submodules[path]
+      STDERR.puts("submodule is pointing to #{rev}")
+      rev, ref_kind, ref = %x{git for-each-ref}.split("\n").map { |l| l.split(" ") }.detect {|l| l.first == current_rev }
+
+      if ref.nil?
+        STDERR.puts "no known branch is currently at #{current_rev}, so we had to detach your HEAD."
+        STDERR.puts "here are some suggestions: "
+        system("git branch --contains #{current_rev} -a | egrep -v 'no branch|HEAD' 1>&2")
+        exit 1
+      end
+      if ref.match(/^refs\/heads/)
+        exec("git checkout '#{File.basename(ref)}'")
+      end
+
+      if ref.match(/^refs\/remotes/) then
+        local_ref=File.basename(ref)
+
+        STDERR.puts "Remote branch #{ref} matches"
+        divergent_commits=%x{git rev-list #{ref}..#{local_ref}}.strip
+        if divergent_commits.empty?
+          STDERR.puts "fastforwarding #{local_ref} to #{ref}"
+          system("git branch -f #{local_ref} #{ref}")
+          exec("git checkout #{local_ref}")
+        end
+      end
     end
   end
 end

data/bin/git-hook

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 $: << File.dirname(__FILE__) + "/../lib/"
 require "gitty"
-Gitty::Hook.new(ARGV).run
+Gitty::HookCommand.new(ARGV).run

data/lib/gitty.rb

@@ -25,31 +25,8 @@ module Gitty
     end
     nil
   end
-
-  def self.creating_dir_if_nonexistant(dir)
-    FileUtils.mkdir_p(dir)
-    Pathname.new(dir)
-  end
-
-  def self.extract_meta_data(string_or_io)
-    io = string_or_io.respond_to?(:readline) ? string_or_io : StringIO.new(string_or_io)
-    meta_yaml = ""
-    begin
-      while line = io.readline
-        next unless line.match(/^# (description.+)/)
-        meta_yaml = "#{$1}\n"
-        break
-      end
-
-      while line = io.readline
-        break unless line.match(/^# (.+)/)
-        meta_yaml << "#{$1}\n"
-      end
-    rescue EOFError
-    end
-    meta_yaml.empty? ? nil : YAML.load(meta_yaml)
-  end
 end
 
 require "gitty/runner.rb"
 require "gitty/hook.rb"
+require "gitty/hook_command.rb"

data/lib/gitty/commands/init.rb

@@ -1,5 +1,5 @@
 require 'fileutils'
-class Gitty::Hook::Init < Gitty::Runner
+class Gitty::HookCommand::Init < Gitty::Runner
   include ::Gitty::Helpers
   
   CLIENT_HOOKS = %w[
@@ -34,7 +34,7 @@ class Gitty::Hook::Init < Gitty::Runner
           cmd(*%w[git symbolic-ref HEAD refs/heads/--hooks--])
           cmd(*%w[git commit --allow-empty -m initial\ commit])
         end
-        cmd(*%w[git reset --hard], hooks_rev) if hooks_rev
+        cmd(*%w[git reset --hard] + hooks_rev) if hooks_rev
       end
     end
   end

data/lib/gitty/commands/install.rb

@@ -0,0 +1,32 @@
+class Gitty::HookCommand::Install < Gitty::Runner
+  include FileUtils
+  def initialize(args, stdout = STDOUT, stderr = STDERR)
+    super
+    @hookname = args.shift
+  end
+
+  def run
+    hook = Gitty::Hook.find(@hookname, :installed => false)
+    if hook.nil?
+      stderr.puts "no hook named '#{@hookname}' found."
+      exit 1
+    end
+
+    hook.install(options[:kind])
+    if options[:kind] == :shared
+      stdout.puts "To propagate this change other developers, run 'git hook publish -m \"added #{hook.name}...\""
+    end
+  end
+
+  def options
+    @options ||= super.update(:kind => :local)
+  end
+
+  def option_parser
+    @option_parser ||= super.tap do |opts|
+      opts.banner = "Usage: git hook install [opts] hook-name"
+      opts.on("-l", "--local", "Local hook (default)") { |l| options[:kind] = :local }
+      opts.on("-s", "--shared", "Remote hook") { |l| options[:kind] = :shared }
+    end
+  end
+end

data/lib/gitty/commands/list.rb

@@ -1,8 +1,8 @@
 require 'fileutils'
-class Gitty::Hook::List < Gitty::Runner
+class Gitty::HookCommand::List < Gitty::Runner
   include ::Gitty::Helpers
   include FileUtils
-  KINDS = [:local, :shared, :available]
+  KINDS = [:local, :shared, :uninstalled]
 
   def run
     stdout.puts "Listing hooks"
@@ -11,17 +11,19 @@ class Gitty::Hook::List < Gitty::Runner
     which_to_show.each { |w| show_hooks(w) }
   end
 
+  def all_hooks
+    @all_hooks = Gitty::Hook.find_all
+  end
+
   def show_hooks(which)
     case which
-    when :local     then show_local_or_shared_hooks('local')
-    when :shared    then show_local_or_shared_hooks('shared')
-    when :available then show_available_hooks
+    when :local, :shared then show_local_or_shared_hooks(which)
+    when :uninstalled then show_uninstalled_hooks
     end
   end
 
   def show_local_or_shared_hooks(which)
-    hook_names = filenames_in(installed_hooks_path(which))
-    return if hook_names.empty?
+    hook_names = all_hooks.select { |h| h.install_kind == which.to_sym }.map(&:name)
     puts "#{which}:\n#{listify(hook_names)}\n\n"
   end
 
@@ -29,25 +31,11 @@ class Gitty::Hook::List < Gitty::Runner
     hooks.map { |h| "- #{h}" }.join("\n")
   end
 
-  def filenames_in(dir)
-    if File.directory?(dir)
-      Dir.glob((dir + "*").to_s).sort.map do |path|
-        File.basename(path)
-      end
-    else
-      []
-    end
-  end
-
-  def installed_hooks_path(which)
-    Pathname.new(".git/hooks/#{which}/hooks")
-  end
-
-  def show_available_hooks
-    all_hooks = Gitty.asset_paths.map {|asset_path| filenames_in(asset_path + "hooks")}.flatten
-    installed_hooks = [:local, :shared].map { |which| filenames_in(installed_hooks_path(which)) }.flatten
-    available_hooks = all_hooks.sort - installed_hooks.sort
-    puts "available:\n#{listify(available_hooks)}\n\n"
+  def show_uninstalled_hooks
+    available_hook_names = all_hooks.select { |h| ! h.installed? }.map(&:name)
+    installed_hook_names = all_hooks.select { |h| h.installed? }.map(&:name)
+    uninstalled_hooks = (available_hook_names - installed_hook_names).sort
+    puts "uninstalled:\n#{listify(uninstalled_hooks)}\n\n"
   end
 
   def option_parser
@@ -56,11 +44,11 @@ class Gitty::Hook::List < Gitty::Runner
       opts.on("-l", "--local", "Show local hooks") do
         options[:local] = true
       end
-      opts.on("-r", "--shared", "Show shared hooks") do
+      opts.on("-s", "--shared", "Show shared hooks") do
         options[:shared] = true
       end
-      opts.on("-a", "--available", "Show available hooks") do
-        options[:available] = true
+      opts.on("-u", "--uninstalled", "Show uninstalled hooks") do
+        options[:uninstalled] = true
       end
     end
   end

data/lib/gitty/commands/publish.rb

@@ -1,4 +1,4 @@
-class Gitty::Hook::Publish < Gitty::Runner
+class Gitty::HookCommand::Publish < Gitty::Runner
   include ::Gitty::Helpers
   
   def run

data/lib/gitty/commands/shell.rb

@@ -1,5 +1,5 @@
 require 'fileutils'
-class Gitty::Hook::Shell < Gitty::Runner
+class Gitty::HookCommand::Shell < Gitty::Runner
   include ::Gitty::Helpers
 
   def run

data/lib/gitty/commands/uninstall.rb

@@ -0,0 +1,39 @@
+class Gitty::HookCommand::Uninstall < Gitty::Runner
+  include FileUtils
+  def initialize(args, stdout = STDOUT, stderr = STDERR)
+    super
+    @hookname = args.shift
+  end
+
+  def run
+    options = {:installed => true}
+    options[:install_kind] = options[:kind] if options[:kind]
+    hook = Gitty::Hook.find(@hookname, options)
+    return no_hook_found unless hook
+    hook.uninstall
+
+    stdout.puts "#{hook.install_kind} hook #{hook.name} has been successfully uninstalled."
+    if hook.install_kind == :shared
+      stdout.puts "To propagate this change other developers, run 'git hook publish -m \"removed #{hook.name}\""
+    end
+  end
+
+  protected
+
+  def no_hook_found
+    stderr.puts("there is no installed hook named '#{@hookname}'")
+    exit 1
+  end
+
+  def options
+    @options ||= super.update(:kind => :local)
+  end
+
+  def option_parser
+    @option_parser ||= super.tap do |opts|
+      opts.banner = "Usage: git hook uninstall [opts] hook-name"
+      opts.on("-l", "--local", "Local hook (default)") { |l| options[:kind] = :local }
+      opts.on("-s", "--shared", "Remote hook") { |l| options[:kind] = :shared }
+    end
+  end
+end

data/lib/gitty/helpers.rb

@@ -18,4 +18,8 @@ module Gitty::Helpers
   def cmd(*args)
     system(*args.flatten)
   end
+
+  def search_for_file_in_paths(paths, file)
+
+  end
 end

data/lib/gitty/hook.rb

@@ -1,42 +1,142 @@
-class Gitty::Hook < Gitty::Runner
-  COMMANDS = %w[
-    init
-    list
-    add
-    remove
-    publish
-    shell
-  ]
-  COMMANDS.each do |cmd|
-    autoload cmd.classify.to_sym, (GITTY_PATH + "commands/#{cmd}.rb").to_s
-  end
-  
-  def initialize(args, stdout = STDOUT, stderr = STDERR)
-    @args, @stdout, @stderr = args, stdout, stderr
-    if COMMANDS.include?(args.first)
-      @target = Gitty::Hook.const_get(args.shift.classify).new(args, stdout, stderr)
+class Gitty::Hook
+  include Gitty::Helpers
+  include FileUtils
+  attr_accessor :path
+
+  def initialize(options = {})
+    options.each do |k,v|
+      send("#{k}=", v)
+    end
+    if installed?
+      extend Gitty::Hook::InstalledHookStrategy
     else
-      parse_args!
+      extend Gitty::Hook::AvailableHookStrategy
     end
   end
-  
-  def option_parser
-    @option_parser ||= super.tap do |opts|
-      opts.banner = "Usage: git hook [command]\nCommands are: #{COMMANDS.join(', ')}"
+
+  def self.available_hooks_search_paths
+    Gitty.asset_paths.map { |ap| File.join(ap, "hooks") }
+  end
+
+  def self.installed_hooks_search_paths
+    [installed_hooks_path(:local), installed_hooks_path(:shared)]
+  end
+
+  def self.installed_path(which = :local)
+    Pathname.new(".git/hooks/#{which}")
+  end
+
+  def self.installed_hooks_path(which = :local)
+    installed_path(which) + "hooks"
+  end
+
+  def self.installed_helpers_path(which = :local)
+    installed_path(which) + "helpers"
+  end
+
+  def self.find_all(filters = {})
+    paths = installed_hooks_search_paths + available_hooks_search_paths
+    candidates = find_all_in_paths(paths)
+    filter_candidates(candidates, filters)
+  end
+
+  def self.filter_candidates(candidates, filters = {})
+    filters.each do |field, value|
+      candidates = candidates.select { |c| c.send(field) == value }
+    end
+    candidates
+  end
+
+  def self.find(name, options)
+    find_all(options.merge(:name => name)).first
+  end
+
+  def self.find_all_in_paths(paths)
+    paths.map { |hook_path| Dir.glob(File.join(hook_path, "*")) }.flatten.map do |path|
+      Gitty::Hook.new(:path => path)
     end
   end
 
-  def run
-    unless File.directory?(".git")
-      stderr.puts "You must run git hook from the root of a git repository"
-      exit 1
+  def self.extract_meta_data(string_or_io)
+    io = string_or_io.respond_to?(:readline) ? string_or_io : StringIO.new(string_or_io)
+    meta_yaml = ""
+    begin
+      while line = io.readline
+        next unless line.match(/^# (description.+)/)
+        meta_yaml = "#{$1}\n"
+        break
+      end
+
+      while line = io.readline
+        break unless line.match(/^#()$/) || line.match(/^# (.*?)$/)
+        meta_yaml << "#{$1}\n"
+      end
+    rescue EOFError
     end
-    @target && @target.run
+    meta_yaml.empty? ? nil : YAML.load(meta_yaml)
   end
 
-  def parse_args!
-    opt_p = option_parser
-    opt_p.parse!(args)
-    puts opt_p
+  def installed?
+    install_kind ? true : false
   end
-end
+  alias installed installed?
+
+  def install_kind
+    case
+    when path.include?(self.class.installed_hooks_path(:local).to_s) then :local
+    when path.include?(self.class.installed_hooks_path(:shared).to_s) then :shared
+    end
+  end
+
+  def name
+    File.basename(path)
+  end
+
+  def <=>(other)
+    path <=> other.path
+  end
+
+  def meta_data
+    @meta_data ||= self.class.extract_meta_data(File.read(path))
+  end
+
+  module AvailableHookStrategy
+    def install(which = :local)
+      target_hook_path = existing_directory!(self.class.installed_hooks_path(which))
+      target_helper_path = existing_directory!(self.class.installed_helpers_path(which))
+      base_directory = self.class.installed_path(which)
+      cp(path, target_hook_path + name)
+      chmod(0755, target_hook_path + name)
+      meta_data["targets"].each do |target|
+        ln_s(
+          "../hooks/#{name}",
+          file_with_existing_directory!(base_directory + "#{target}.d" + name)
+        )
+      end
+      (meta_data["helpers"] || []).each do |helper|
+        cp(Gitty.find_asset("helpers/#{helper}"), target_helper_path + helper)
+        chmod(0755, target_helper_path + helper)
+      end
+    end
+
+    def uninstall
+      # do nothing
+    end
+  end
+
+  module InstalledHookStrategy
+    def install(which = :local)
+      # do nothing
+    end
+
+    def uninstall
+      target_hook_path = path
+      base_directory = self.class.installed_path(install_kind)
+      meta_data["targets"].each { |target| rm_f(base_directory + "#{target}.d" + name) }
+      rm(target_hook_path)
+      # TODO - clean up helpers
+    end
+  end
+
+  private :path=
+end

data/lib/gitty/hook_command.rb

@@ -0,0 +1,42 @@
+class Gitty::HookCommand < Gitty::Runner
+  COMMANDS = %w[
+    init
+    list
+    install
+    uninstall
+    publish
+    shell
+  ]
+  COMMANDS.each do |cmd|
+    autoload cmd.classify.to_sym, (GITTY_PATH + "commands/#{cmd}.rb").to_s
+  end
+
+  def initialize(args, stdout = STDOUT, stderr = STDERR)
+    @args, @stdout, @stderr = args, stdout, stderr
+    if COMMANDS.include?(args.first)
+      @target = Gitty::HookCommand.const_get(args.shift.classify).new(args, stdout, stderr)
+    else
+      parse_args!
+    end
+  end
+
+  def option_parser
+    @option_parser ||= super.tap do |opts|
+      opts.banner = "Usage: git hook [command]\nCommands are: #{COMMANDS.join(', ')}"
+    end
+  end
+
+  def run
+    unless File.directory?(".git")
+      stderr.puts "You must run git hook from the root of a git repository"
+      exit 1
+    end
+    @target && @target.run
+  end
+
+  def parse_args!
+    opt_p = option_parser
+    opt_p.parse!(args)
+    puts opt_p
+  end
+end

data/spec/gitty/hook_spec.rb

@@ -0,0 +1,139 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Gitty::Hook do
+  def installed_hook(name, which = :local)
+    hook = Gitty::Hook.find(name, :installed => false)
+    hook.install(which)
+    Gitty::Hook.find(name, :installed => true)
+  end
+
+  before(:each) do
+    Gitty::Hook.stub!(:available_hooks_search_paths).and_return([SandboxWorld::GITTY_ASSETS + "hooks"])
+    create_file(SandboxWorld::GITTY_ASSETS + "hooks/submodule_updater", <<-EOF)
+#!/bin/bash
+# description: managers submodule updating for you
+# targets: ["post-checkout", "post-merge"]
+...
+EOF
+    create_file(SandboxWorld::GITTY_ASSETS + "hooks/no_messy_whitespace", <<-EOF)
+#!/bin/bash
+# description: prevents you from committing messy whitespace
+# targets: ["pre-commit"]
+...
+EOF
+  end
+
+  describe ".extract_meta_data" do
+    it "extracts meta data from a stream" do
+      stream = <<-EOF
+#!/usr/bash
+
+# description: |-
+#   hi
+#
+#   bye
+# targets: ["post-merge", "post-checkout"]
+#
+
+here's my hook
+EOF
+      Gitty::Hook.extract_meta_data(stream).should == {
+        "description" => "hi\n\nbye",
+        "targets" => ["post-merge", "post-checkout"]
+      }
+    end
+
+    it "returns nil when no data found" do
+      stream = <<-EOF
+#!/usr/bash
+#
+#
+EOF
+      Gitty::Hook.extract_meta_data(stream).should == nil
+    end
+
+    it "returns the data when there's no actual content" do
+      stream = <<-EOF
+#!/usr/bash
+#
+# description: hi
+EOF
+      Gitty::Hook.extract_meta_data(stream).should == {"description" => "hi"}
+    end
+  end
+  describe ".find_all" do
+    it "returns all available hooks" do
+      Gitty::Hook.find_all(:installed => false).map(&:name).should == %w[no_messy_whitespace submodule_updater]
+    end
+  end
+
+  describe ".find" do
+    it "returns an available hook by name" do
+      Gitty::Hook.find("submodule_updater", :installed => false).name.should == "submodule_updater"
+      Gitty::Hook.find("no_messy_whitespace", :installed => false).name.should == "no_messy_whitespace"
+    end
+
+    it "finds installed hooks" do
+    end
+  end
+
+  describe "#installed?" do
+    it "returns false if the hook is not installed" do
+      Gitty::Hook.find("submodule_updater", :installed => false).installed?.should be_false
+    end
+
+    it "returns true if the hook is installed" do
+      Gitty::Hook.find("submodule_updater", :installed => false).install(:local)
+      Gitty::Hook.find("submodule_updater", :installed => true).installed?.should == true
+    end
+  end
+
+  describe "#install_kind" do
+    it "returns :local for local hooks" do
+      installed_hook("submodule_updater", :local).install_kind.should == :local
+    end
+
+    it "returns :shared for shared hooks" do
+      installed_hook("submodule_updater", :shared).install_kind.should == :shared
+    end
+  end
+
+  describe "#meta_data" do
+    it "reads the meta_data of a given file" do
+      Gitty::Hook.find("submodule_updater", :installed => false).meta_data
+    end
+  end
+
+  describe "#install" do
+    it "copies an available hook to the install path and links it into the targets" do
+      @hook = Gitty::Hook.find("submodule_updater", :installed => false)
+      @hook.install
+      File.exist?(".git/hooks/local/hooks/submodule_updater").should be_true
+      File.executable?(".git/hooks/local/hooks/submodule_updater").should be_true
+      File.exist?(".git/hooks/local/post-checkout.d/submodule_updater").should be_true
+      File.exist?(".git/hooks/local/post-merge.d/submodule_updater").should be_true
+    end
+
+    it "installs a hook into shared" do
+      @hook = Gitty::Hook.find("submodule_updater", :installed => false)
+      @hook.install(:shared)
+      File.exist?(".git/hooks/shared/hooks/submodule_updater").should be_true
+      File.executable?(".git/hooks/shared/hooks/submodule_updater").should be_true
+      File.exist?(".git/hooks/shared/post-checkout.d/submodule_updater").should be_true
+      File.exist?(".git/hooks/shared/post-merge.d/submodule_updater").should be_true
+    end
+  end
+
+  describe "#uninstall" do
+    it "removes a hook from installed path" do
+      hook = installed_hook("submodule_updater")
+      File.exist?(".git/hooks/local/hooks/submodule_updater").should be_true
+      File.symlink?(".git/hooks/local/post-checkout.d/submodule_updater").should be_true
+      File.symlink?(".git/hooks/local/post-merge.d/submodule_updater").should be_true
+      hook.uninstall
+      File.exist?(".git/hooks/local/hooks/submodule_updater").should be_false
+      File.symlink?(".git/hooks/local/post-checkout.d/submodule_updater").should be_false
+      File.symlink?(".git/hooks/local/post-merge.d/submodule_updater").should be_false
+    end
+  end
+end

data/spec/gitty_spec.rb

@@ -21,39 +21,4 @@ describe Gitty do
     end
   end
 
-  describe ".extract_meta_data" do
-    it "extracts meta data from a stream" do
-      stream = <<-EOF
-#!/usr/bash
-
-# description: hi
-# targets: ["post-merge", "post-checkout"]
-#
-
-here's my hook
-EOF
-      Gitty.extract_meta_data(stream).should == {
-        "description" => "hi",
-        "targets" => ["post-merge", "post-checkout"]
-      }
-    end
-
-    it "returns nil when no data found" do
-      stream = <<-EOF
-#!/usr/bash
-#
-#
-EOF
-      Gitty.extract_meta_data(stream).should == nil
-    end
-
-    it "returns the data when there's no actual content" do
-      stream = <<-EOF
-#!/usr/bash
-#
-# description: hi
-EOF
-      Gitty.extract_meta_data(stream).should == {"description" => "hi"}
-    end
-  end
 end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+nested
+--diff
+--loadby
+mtime
+--drb

data/spec/spec_helper.rb

@@ -1,6 +1,29 @@
 require File.dirname(__FILE__) + "/../lib/gitty"
-SPEC_PATH = GITTY_ROOT_PATH + "spec"
 require 'rubygems'
-require 'cucumber'
+require "spec"
+SPEC_PATH = Pathname.new(File.dirname(__FILE__))
+require SPEC_PATH + "../features/support/sandbox_world.rb"
 require SPEC_PATH + "support/constants.rb"
-require "spec"
+
+
+require 'forwardable'
+Spec::Runner.configure do |config|
+  extend Forwardable
+  def sandbox
+    @sandbox ||= SandboxWorld.new
+  end
+
+  [:run, :in_dir, :current_dir, :create_file, :last_exit_status, :last_stderr, :last_stdout, :reset_sandbox!].each do |m|
+    eval "def #{m}(*args) sandbox.send(:#{m}, *args) end"
+  end
+
+  config.before(:each) do
+    reset_sandbox!
+    @_original_dir = Dir.pwd
+    Dir.chdir(current_dir)
+  end
+
+  config.after(:each) do
+    Dir.chdir(@_original_dir)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gitty
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Tim Harper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-21 00:00:00 -07:00
+date: 2010-02-24 00:00:00 -08:00
 default_executable: git-hook
 dependencies: []
 
@@ -32,27 +32,28 @@ files:
 - assets/helpers/git-trash
 - assets/helpers/git-when-introduced
 - assets/helpers/hookd_wrapper
+- assets/hooks/auto-submodules
 - assets/hooks/clean-patches
-- assets/hooks/git-post-checkout-submodules
 - assets/hooks/git-prevent-messy-rebase
-- assets/hooks/prevent-nocommit-tags
+- assets/hooks/nocommit
 - bin/git-hook
 - cucumber.yml
 - lib/ext.rb
 - lib/gitty.rb
-- lib/gitty/commands/add.rb
 - lib/gitty/commands/init.rb
+- lib/gitty/commands/install.rb
 - lib/gitty/commands/list.rb
-- lib/gitty/commands/manager.rb
 - lib/gitty/commands/publish.rb
-- lib/gitty/commands/remove.rb
 - lib/gitty/commands/shell.rb
+- lib/gitty/commands/uninstall.rb
 - lib/gitty/helpers.rb
 - lib/gitty/hook.rb
+- lib/gitty/hook_command.rb
 - lib/gitty/runner.rb
 - lib/string.rb
-- spec/gitty/commands/add_spec.rb
+- spec/gitty/hook_spec.rb
 - spec/gitty_spec.rb
+- spec/spec.opts
 - spec/spec_helper.rb
 - spec/support/constants.rb
 has_rdoc: true
@@ -84,7 +85,7 @@ signing_key:
 specification_version: 3
 summary: Unobtrusively extend git
 test_files: 
-- spec/gitty/commands/add_spec.rb
+- spec/gitty/hook_spec.rb
 - spec/gitty_spec.rb
 - spec/spec_helper.rb
 - spec/support/constants.rb

data/lib/gitty/commands/add.rb

@@ -1,26 +0,0 @@
-require GITTY_PATH + "commands/manager"
-
-class Gitty::Hook::Add < Gitty::Hook::Manager
-  include FileUtils
-
-  def run
-    cp(src_hook_file, master_hook_file)
-    chmod(0755, master_hook_file)
-    meta_data["targets"].each do |target|
-      ln_s(
-        "../hooks/#{@hookname}",
-        file_with_existing_directory!(base_directory + "#{target}.d" + @hookname)
-      )
-    end
-    (meta_data["helpers"] || []).each do |helper|
-      cp(Gitty.find_asset("helpers/#{helper}"), helpers_directory + helper)
-      chmod(0755, helpers_directory + helper)
-    end
-  end
-
-  def option_parser
-    @option_parser ||= super.tap do |opts|
-      opts.banner = "Usage: git hook add [opts] hook-name"
-    end
-  end
-end

data/lib/gitty/commands/manager.rb

@@ -1,50 +0,0 @@
-class Gitty::Hook::Manager < Gitty::Runner
-  include ::Gitty::Helpers
-  def initialize(args, stdout = STDOUT, stderr = STDERR)
-    super
-    @hookname = args.shift
-  end
-
-  def options
-    @options ||= super.update(:kind => :local)
-  end
-
-  def src_hook_file
-    Gitty.find_asset("hooks/#{@hookname}")
-  end
-
-  def master_hook_file
-    @master_hook_file ||= hooks_directory + @hookname
-  end
-
-  def meta_data
-    @meta_data ||= Gitty.extract_meta_data(File.read(src_hook_file))
-  end
-
-  def run
-    raise NotImplementedError
-  end
-
-  def target_file(hook)
-    @target_file ||= file_with_existing_directory!(base_directory + "#{hook}.d/#{@hookname}")
-  end
-
-  def base_directory
-    @base_directory ||= existing_directory!(".git/hooks/#{options[:kind]}")
-  end
-
-  def helpers_directory
-    @helpers_directory ||= existing_directory!(".git/hooks/#{options[:kind]}/helpers")
-  end
-
-  def hooks_directory
-    existing_directory!(base_directory + "hooks")
-  end
-
-  def option_parser
-    @option_parser ||= super.tap do |opts|
-      opts.on("-l", "--local", "Local hook (default)") { |l| options[:kind] = :local }
-      opts.on("-s", "--shared", "Remote hook") { |l| options[:kind] = :shared }
-    end
-  end
-end

data/lib/gitty/commands/remove.rb

@@ -1,17 +0,0 @@
-require GITTY_PATH + "commands/manager"
-class Gitty::Hook::Remove < Gitty::Hook::Manager
-  include FileUtils
-  def run
-    rm(master_hook_file)
-    meta_data["targets"].each do |target|
-      rm(target_file(target))
-    end
-    # TODO - cleanup helpers
-  end
-
-  def option_parser
-    @option_parser ||= super.tap do |opts|
-      opts.banner = "Usage: git hook remove [opts] hook-name"
-    end
-  end
-end

data/spec/gitty/commands/add_spec.rb

@@ -1,5 +0,0 @@
-require File.expand_path('../../spec_helper', File.dirname(__FILE__))
-require 'stringio'
-
-describe Gitty::Hook::Add do
-end