rgithook 3.0.2

data/lib/plugins/test.rb

@@ -0,0 +1,37 @@
+module RGitHook
+  class TestSuite < Plugin
+
+    module RunnerMethods
+      def test(commit)
+        commit.properties['testing'] = true
+        commit.save_properties
+        in_temp_commit(commit) do |new_repo|
+          # Some hacks to migrate rails app if found.
+          if File.file?('./config/environment.rb')
+            commit.properties['db:migrate'] = rake('db:migrate')
+            commit.properties['db:test:prepare'] = rake('db:test:prepare')
+          end  
+          commit.properties['spec'] = test_spec(repo) if File.directory? File.join(repo.working_dir,'spec')
+          commit.properties['cucumber'] = test_cucumber(repo) if File.directory? File.join(repo.working_dir,'features')
+          commit.properties['test_unit'] = test_unit(repo) if File.directory? File.join(repo.working_dir,'test')
+        end
+        commit.properties["status"] = %w(spec cucumber test_unit).map{|t|commit.properties[t][1].exitstatus}.max
+      ensure
+        commit.properties.delete 'testing'
+        commit.save_properties
+      end
+
+      def test_spec(repo)
+        [%x(spec spec/),$?]
+      end
+
+      def test_cucumber(repo)
+        [%x(cucumber features/),$?]
+      end
+
+      def test_unit(repo)
+        [%x(testrb `find test -name '*.rb'`),$?]
+      end
+    end
+  end
+end

data/lib/plugins/twitter.rb

@@ -0,0 +1,13 @@
+
+
+class Twitter < RGitHook::Plugin
+
+   option :user, 'Username', nil, String
+   option :password, 'Password', nil, String
+
+   module RunnerMethods
+      def twitter(msg)
+         %(curl http://twitter.com -u #{options[:Twitter][:user]} -)
+      end
+   end
+end

data/lib/rgithook.rb

@@ -0,0 +1,36 @@
+$:.unshift File.dirname(__FILE__)
+
+begin
+
+   module RGitHook
+      VERSION='3.0.2'
+      PATH=File.dirname(File.expand_path(__FILE__))
+   end
+
+   require 'rubygems'
+   gem 'mojombo-grit'
+   require 'grit'
+
+   require File.join('rgithook', 'runner')
+   
+   require File.join('rgithook', 'rgithook')
+   require File.join('rgithook', 'hook')
+   RGitHook.autoload(:Plugin, File.join(RGitHook::PATH,'rgithook','plugin'))
+   RGitHook.autoload(:CommandLine, File.join(RGitHook::PATH,'rgithook','command_line'))
+
+   Dir.glob(File.join(File.dirname(__FILE__),'plugins','*.rb')).each do |plugin|
+      begin
+         require plugin
+      rescue LoadError => e
+         puts "Failed to load some plugin #{plugin}\n#{e.to_s}"
+      end
+   end
+
+
+rescue LoadError => e
+   puts 'Imposible to load some gem'
+   puts e.message
+   exit -1
+end
+
+

data/lib/rgithook/command_line.rb

@@ -0,0 +1,47 @@
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+
+module RGitHook
+   class CommandLine
+
+      # Parse command line options and execute
+      def self.execute(args)
+         options = parse_options(args)
+
+         case options.command
+         when :install,:fetch,:edit
+            ret_val = RGitHook.new(options.path).send(options.command)
+            exit 0
+         when :version
+            puts 'Version 3.0.0'
+            exit 0
+         end
+
+      rescue Grit::InvalidGitRepositoryError
+         puts "Invalid Git repository:\n#{@options.path}"
+         exit 1
+      end
+
+      private
+      def self.parse_options(args)
+         options = OpenStruct.new
+         options.command = :help
+         options.path = Dir.pwd
+
+         opts = OptionParser.new do |opts|
+            opts.banner = "Usage #{File.basename $0} [options]"
+            opts.on_head("-i","--install", "Install hooks on current dir") { options.command = :install }
+            opts.on_head("-f","--fetch", "Fetch remote origin and run hooks") { options.command = :fetch }
+            opts.on_head("-e","--edit", "Edit your hooks file with your EDITOR") { options.command = :edit }
+            opts.on("-p","--path=[path]", "Run in another path insted of current path") { |path| options.path = path }
+            opts.on_tail("--version", "Print current version and exit") {options.command = :version }
+            opts.on_tail("-h","--help", "Print help message")
+         end
+         opts.parse!(args)
+         (puts opts and exit 0) if options.command == :help
+         options
+      end
+
+   end
+end

data/lib/rgithook/hook.rb

@@ -0,0 +1,39 @@
+module RGitHook
+  # Interface from git-commands to RGitHook
+  class Hook #::nodoc::
+    def self.execute
+      puts "Executing #{File.basename($0)} hook"
+      self.send File.basename($0).tr('-','_')
+    end
+
+    def self.post_receive
+      packs = STDIN.read.split("\n")
+      ret_vals = []
+
+      rgithook = RGitHook.new repo_path
+
+      packs.each do |pack|
+        oldrev, newrev, ref = pack.split(' ')
+        ret_vals << rgithook.post_receive(oldrev,newrev,ref).first[1].to_i
+      end
+      return ret_vals.max
+    end
+
+    def self.method_missing(method_name)
+      RGitHook.new(repo_path).send(method_name)
+      0
+    rescue
+      -1
+    end
+    
+    private
+    def self.repo_path
+      if File.basename(File.expand_path(ENV['GIT_DIR']))  == '.git'
+        repo_path = File.join(ENV['GIT_DIR'],'..')
+      else
+        repo_path = ENV['GIT_DIR']
+      end
+    end
+  end
+end
+

data/lib/rgithook/plugin.rb

@@ -0,0 +1,105 @@
+
+module RGitHook
+
+   class Plugin
+      include ::RGitHook
+      class Option #::nodoc::
+         attr_reader :name,:description,:default,:type
+         def initialize(name,description,default,type)
+            @name, @description, @default, @type = name,description,default,type
+         end
+      end
+
+      class NoOptionError < Exception ; end
+
+      class OptionGroup #::nodoc::
+         # Todo: Make OptionGroup be an option of OptionGroup
+         attr_reader :name,:description
+         attr_reader :options
+         def initialize(name,description)
+            @name,@description = name,description
+            @options = []
+         end
+
+         def option(name,desc,default,type)
+            @options << Option.new(name,desc,default,type)
+         end
+
+         # Rertun a hash with default options
+         #
+         def options_to_hash
+            group_options = {}
+            @options.each do |option|
+               group_options[option.name]= option.default
+            end
+            group_options
+         end
+      end
+
+      # ::nodoc::
+      # Return raw options
+      def self.options
+         @@options
+      end
+
+      # Initialize Plugin system by including each plugin modules to the Module
+      # It also load the defaults from a yaml file.
+      # You can change the default yaml file to load another file
+      def self.load!
+         @@plugins ||=[]
+         @@plugins.each do |plugin|
+            if defined?(plugin::RunnerMethods)
+               Runner.class_eval do
+                  include plugin::RunnerMethods
+               end
+            end
+
+            if defined?(plugin::GritCommit)
+               ::Grit::Commit.class_eval do
+                  include plugin::GritCommit
+               end
+            end
+         end
+      end
+
+
+      # Return a hash with the default options
+      def self.options_to_hash
+         options = {}
+         @@options.each do |plugin,plugin_options|
+            plugin_opts = {}
+            plugin_options.each do |option|
+               plugin_opts[option.name]=option.default.is_a?(OptionGroup) ? option.default.options_to_hash : option.default
+            end
+            options[plugin]=plugin_opts
+         end
+         options
+      end
+
+      private
+
+      # Define a new option
+      def self.option(name,desc,default,type)
+         @@options[get_plugin_name(self)] << Option.new(name,desc,default,type)
+      end
+
+      def self.option_group(name,desc,&block)
+         opt_group = OptionGroup.new(name,desc)
+         yield opt_group
+         option(name,desc,opt_group,OptionGroup)
+      end
+
+      def self.inherited(base)
+         @@plugins ||=[]
+         @@plugins << base
+         @@options ||={}
+         @@options[get_plugin_name(base)]=[]
+      end
+
+      private
+      def self.get_plugin_name(kmod)
+         kmod.to_s[/(.*\::)?(.*)/,2].to_sym
+      end
+   end
+end
+

data/lib/rgithook/rgithook.rb

@@ -0,0 +1,229 @@
+module RGitHook
+   HOOKS = %w(applypatch_msg
+   commit_msg
+   post_commit
+   post_receive
+   post_update
+   pre_applypatch
+   pre_commit
+   pre_rebase
+   prepare_commit_msg
+   update)
+
+   class RGitHook
+      attr_reader :repo
+
+      # Install RGitHook in the given repo/path
+      # if confirmation_needed it will ask to overwrite the existing hooks
+      def self.install(path_or_repo, verbose=true)
+         repo = parse_path path_or_repo
+
+         if verbose
+            puts "Welcome to RGitHook.
+
+            These will install rgithook for the next Git Repo
+            /Users/guillermo/Sites/
+
+            These will overwrite all the current hooks and
+            create .git/hooks/rgithook.rb file.
+
+            In that file you will define your hooks in ruby.
+            ".gsub(/^        /,'')
+            return -1 unless prompt('Continue?')
+         end
+         hooks_dir = File.join(repo.path,'hooks')
+         FileUtils.mkdir hooks_dir unless File.exist? hooks_dir
+
+         install_template(repo,'rgithook.rb')
+
+         HOOKS.each do |hook_name|
+            install_template(repo,'hook.rb',hook_name.tr('_','-'),0555)
+         end
+
+         if verbose
+            puts "RGitHook Installed.
+            Now you can:
+            * Edit the hooks file by running
+            rgithook --edit
+
+            * Install the hooks file inside the repo. So all
+            contributors can run hooks.
+            mv .git/hooks/rgithook.rb ./config/rgithook.rb && \
+            ln -s ./config/rgithook.rb
+
+            or
+
+            mv .git/hooks/rgithook.rb ./config/rgithook.rb && \
+            ln -s ./.rgithook.rb
+
+            * Fetch changes from origin
+            rgithook --fetch
+            ".gsub(/^        /,'')
+         end
+      end
+
+      # Install RGitHook in the given repo/path
+      # if confirmation_needed it will ask to overwrite the existing hooks
+      def install(confirmation_needed = true)
+         self.class.install(@repo,confirmation_needed)
+      end
+
+      # Return true if rgithook is installed in the given repo
+      def self.installed? (path_or_repo)
+         File.file?(hooks_file(path_or_repo))
+      end
+
+      # Return true if rgithook is installed
+      def installed?
+         self.class.installed?(@repo)
+      end
+
+      #Extract the projects name
+      def project_name
+         if @repo.bare
+            File.basename(@repo.path) =~ /(.*).git/
+            $1 || @repo.bare
+         else
+            File.basename(@repo.working_dir)
+         end
+      end
+
+      # Returns the path of the current repo
+      def path
+         @repo.path
+      end
+
+      # Returns the path of the working dir or nil if it is a bare repo
+      def working_path
+         @repo.working_dir
+      end
+
+      # Returns true on bare repo.
+      def bare?
+         @repo.bare
+      end
+
+      # Open the editor with the config file
+      def self.call_editor(path_or_repo)
+         repo = parse_path path_or_repo
+         system(ENV['EDITOR'] || 'vi',conf_file)
+      end
+
+      # Open the editor with the config file
+      def call_editor
+         self.class.call_editor(@repo)
+      end
+
+      # Get the config file of the current repo or path
+      def self.conf_file(path_or_repo)
+         repo = parse_path path_or_repo
+         File.join(repo.path,'hooks','rgithook.rb')
+      end
+
+      # Get the config file of the current repo or path
+      def conf_file
+         self.class.conf_file(@repo)
+      end
+
+      #TODO: Make a reload method, to reload conf_file and hooks_file
+
+      HOOKS.each do |hook_name|
+         start_line = __LINE__
+      hook_methods =<<-EOHM
+      def self.#{hook_name}(path_or_repo,*args)
+        RGitHook.new(path_or_repo).#{hook_name}(*args)
+      end
+      
+      def #{hook_name}(*args)
+        @runner.run_hooks(:#{hook_name.to_sym},*args)
+      end
+      
+         EOHM
+         eval(hook_methods,binding,__FILE__,start_line+2)
+      end
+
+
+      # Call post_receive hooks
+      def self.post_receive(path_or_repo,oldrev,newrev,ref)
+         r = RGitHook.new(path_or_repo)
+         r.post_receive(oldrev,newrev,ref)
+      end
+
+      # Call post_receive hooks
+      def post_receive(oldrev,newrev,ref)
+         @runner.run_hooks(:post_receive,oldrev,newrev,ref)
+      end
+
+      def save_plugin_options
+         File.open(plugin_conf_file,'w') {|f| f.write @runner.options.to_yaml }
+      end
+
+      # Run some code in the runner binding
+      def run(code,file=nil,line=nil)
+         @runner.run(code,file,line)
+      end
+
+      def self.hooks_file(repo_or_path)
+         File.join(parse_path(repo_or_path).path,'hooks','rgithook.rb')
+      end
+
+      def hooks_file
+         self.class.hooks_file(@repo)
+      end
+
+      def self.plugin_conf_file(repo_or_path)
+         File.join(parse_path(repo_or_path).path,'hooks','rgithook.yaml')
+      end
+
+      def plugin_conf_file
+         self.class.plugin_conf_file(@repo)
+      end
+
+
+      private
+
+      def self.prompt(message)
+         while true
+            puts message+' [yn]'
+            return 'yY'.include?($1) ? true : false if $stdin.gets.strip =~ /([yYnN])/
+         end
+      end
+
+
+      def self.parse_path(path)
+         case path
+         when ::Grit::Repo
+            path
+         when String
+            ::Grit::Repo.new(path)
+         end
+      rescue Grit::InvalidGitRepositoryError
+         raise ArgumentError, 'path is not a valid git repo'
+      end
+
+
+      # Contains the current runner with the hooks
+      attr_reader :runner
+
+
+      def self.install_template(path_or_repo, from,to=nil,mode = 0600)
+         to = from if to.nil?
+         repo = parse_path(path_or_repo)
+
+         from = File.join(PATH,'rgithook','templates',from)
+         to   = File.join(repo.path,'hooks',to)
+         FileUtils.install(from,to, :mode => mode)
+      end
+
+      # Initialize a new instance of rgithook in the given repo or path
+      def initialize(repo_or_path)
+         @repo = self.class.parse_path(repo_or_path)
+         Plugin.load!
+         @runner    = Runner.new(@repo)
+         @runner.load_options(plugin_conf_file)
+         @runner.load(hooks_file)
+      end
+
+
+   end
+end