ghundle 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd51259b0ad3f91bf4ac2a51ee626477b325c19f
+  data.tar.gz: ccf45d5d461a0911f5b00a64de1b0a3bd7555a41
+SHA512:
+  metadata.gz: 4ad0bcfadce7edbcf088b0f0914fe26cdcb95873210f585662cec2750eb2f9ecbd6f0ef837d638af1ce2ca735b74c83144fe0df528d05954fa4ed0c1f12ab3f5
+  data.tar.gz: d4d9b6d863969ef095188bbf221bf7fd9928a16723115bd28509e444f97e3646813047338456d22ccfbdad8ad159fd4995347ed22333cb1cb1cd6bd54ebf1a09

data/LICENSE

@@ -0,0 +1,5 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+*This project is not completely done yet and the API is still in flux.*
+
+## Usage
+
+Fetch a hook from the local filesystem, useful for testing (see below for
+directory format):
+
+    $ ghundle fetch ~/projects/hooks/ctags
+    >> Copying hook to ~/.ghundle/ctags...
+
+Fetch a hook from a remote github repo:
+
+    $ ghundle fetch github.com/AndrewRadev/my-hooks-repo/ctags
+    >> Copying hook to ~/.ghundle/ctags...
+
+List all available hooks:
+
+    $ ghundle list-all
+
+    ctags
+      - types:       post-checkout
+      - description: Regenerates a project's tag files whenever a `git checkout` is run.
+
+    ruby-bundler
+      - types:       post-merge, post-rewrite
+      - description: Runs a `bundle install` on every merge (this includes pulls).
+
+    <hook-name>
+      - type:        <type>
+      - description: <description>
+
+List all hooks, installed in the project:
+
+    $ ghundle list-installed
+
+    ctags
+      - types:       post-checkout
+      - description: Regenerates a project's tag files whenever a `git checkout` is run.
+
+Install a new hook in the project from the ghundle storage in `~/.ghundle`
+(this automatically fetches if given a fetch-compatible url):
+
+    $ ghundle install ruby-bundler
+    $ ghundle install <hook-name>
+
+    $ ghundle install github.com/AndrewRadev/my-hooks-repo/ctags
+    $ ghundle install <anything that `ghundle fetch` accepts>
+
+Uninstall a hook:
+
+    $ ghundle uninstall ruby-bundler
+    $ ghundle uninstall <hook-name>
+
+Run a hook manually (it would need some arguments to work, see `man ghundle`):
+
+    $ ghundle run rails-migrations <args>
+
+## Internals
+
+The format of the source of a ghundle hook is a directory with the following
+structure:
+
+    hook-name/
+      meta.yml
+      run
+
+After running `ghundle fetch hook-name`, the `run` file and the metadata in
+`meta.yml` will be processed and stored in `~/.ghundle`. The `run` file is the
+actual script to run and it can be written any way you like. The `meta.yml`
+file contains metadata and should have the form:
+
+``` yaml
+---
+types: [<hook-type1>, <hook-type2>, ...]
+version: <major>.<minor>.<patch>
+description: <description of the hook's effect>
+```
+
+Each hook is written to the relevant `.git/hooks/*` file. For example, with the
+abovementioned `ruby-bundler` and `rails-migrations`
+would result in the `.git/hooks/post-merge` file looking like this:
+
+    ## Start of ghundle scripts
+    ghundle run ruby-bundler $*
+    ghundle run rails-migrations $*
+    ## End of ghundle scripts

data/bin/ghundle

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'ghundle/main'
+require 'ghundle/options_parser'
+
+options_parser = Ghundle::OptionsParser.new(ARGV)
+_options = options_parser.parse
+
+if ARGV.length < 1
+  puts options_parser.usage
+  exit 1
+end
+
+begin
+  Ghundle::Main.exec(*ARGV.dup)
+rescue Ghundle::AppError => e
+  puts e.message
+  exit 1
+end

data/lib/ghundle/app_error.rb

@@ -0,0 +1,7 @@
+module Ghundle
+  class AppError < RuntimeError
+    def usage
+      ''
+    end
+  end
+end

data/lib/ghundle/command/common.rb

@@ -0,0 +1,70 @@
+require 'ghundle/config'
+require 'rainbow'
+
+module Ghundle
+  module Command
+    # Provides the basic interface of a Ghundle command. Includes some helper
+    # methods that are available in all command objects.
+    #
+    # Inheritors are expected to override the #call instance method, and they
+    # will have access to the command-line arguments through the #args method.
+    #
+    class Common
+      attr_reader :args
+
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(*args)
+        @args = args
+      end
+
+      private
+
+      def hook_description(hook)
+        [
+          hook.name.foreground(:yellow),
+          "  - version:     #{hook.metadata.version}",
+          "  - types:       #{hook.metadata.types.join(', ')}",
+          "  - description: #{hook.metadata.description}",
+        ].join("\n")
+      end
+
+      def say(message)
+        print '>> '.foreground(:green).bright
+        puts message.foreground(:green)
+      end
+
+      def error(*args)
+        raise AppError.new(*args)
+      end
+
+      def config
+        @config ||= Config
+      end
+
+      def possible_hook_types
+        %w{
+          applypatch-msg
+          commit-msg
+          post-applypatch
+          post-checkout
+          post-commit
+          post-merge
+          post-receive
+          post-rewrite
+          post-update
+          pre-applypatch
+          pre-auto-gc
+          pre-commit
+          pre-push
+          pre-rebase
+          pre-receive
+          prepare-commit-msg
+          update
+        }
+      end
+    end
+  end
+end

data/lib/ghundle/command/fetch.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+require 'ghundle/command'
+require 'ghundle/source'
+require 'ghundle/hook'
+
+module Ghundle
+  module Command
+    # Tries to figure out what kind of a source the given identifier represents
+    # and fetches the hook locally.
+    #
+    class Fetch < Common
+      def call
+        args.each do |identifier|
+          if identifier =~ /^github.com/
+            source = Source::Github.new(identifier)
+          elsif File.directory?(identifier)
+            source = Source::Directory.new(identifier)
+          elsif File.directory?(config.hook_path(identifier))
+            # already fetched, do nothing
+            return
+          else
+            error "Can't identify hook source from identifier: #{identifier}"
+          end
+
+          hook_name = source.hook_name
+
+          say "Fetching hook #{source.hook_name}..."
+          source.fetch(config.hook_path(source.hook_name))
+        end
+      end
+    end
+  end
+end

data/lib/ghundle/command/install.rb

@@ -0,0 +1,93 @@
+require 'ghundle/command'
+
+module Ghundle
+  module Command
+    # Installs the given hook in the local repository. If there is no local
+    # hook by the given name, delegates to the the Fetch command to get the
+    # hook first.
+    #
+    class Install < Common
+      def call
+        args.each do |hook_name|
+          local_source = Source::Local.new(config.hook_path(hook_name))
+
+          if not local_source.exists?
+            # try to fetch it instead
+            Fetch.call(*args)
+            real_hook_name = File.basename(hook_name)
+            local_source   = Source::Local.new(config.hook_path(real_hook_name))
+          end
+
+          hook = Hook.new(local_source)
+
+          prepare_git_hook(hook)
+          install_git_hook(hook)
+        end
+      end
+
+      def prepare_git_hook(hook)
+        validate_git_repo
+
+        hook_types = hook.metadata.types
+        hook_types.each do |hook_type|
+          validate_hook_type(hook_type)
+        end
+
+        hook_types.each do |hook_type|
+          git_hook_file = ".git/hooks/#{hook_type}"
+
+          if not File.exists?(git_hook_file)
+            File.open(git_hook_file, 'w') do |f|
+              f.puts '#! /bin/sh'
+              f.puts ''
+            end
+            File.chmod(0755, git_hook_file)
+          end
+        end
+      end
+
+      def install_git_hook(hook)
+        hook.metadata.types.each do |hook_type|
+          git_hook_file   = ".git/hooks/#{hook_type}"
+          hook_invocation = "ghundle run #{hook.name} $*"
+
+          lines         = File.readlines(git_hook_file).map(&:rstrip)
+          existing_hook = lines.find { |l| l.include?(hook_invocation) }
+
+          if existing_hook
+            say "Hook already installed for #{hook_type}"
+            return
+          end
+
+          say "Installing hook #{hook} for #{hook_type}"
+          end_line_index = lines.rindex { |l| l =~ /^# End of ghundle scripts/ }
+
+          if end_line_index
+            lines.insert(end_line_index, hook_invocation)
+          else
+            lines << '# Start of ghundle scripts'
+            lines << hook_invocation
+            lines << '# End of ghundle scripts'
+          end
+
+          File.open(git_hook_file, 'w') do |f|
+            f.write(lines.join("\n"))
+          end
+        end
+      end
+
+      def validate_git_repo
+        if not File.directory?('.git/hooks')
+          error "Can't find `.git/hooks` directory, are you in a git repository?"
+        end
+      end
+
+      # TODO (2013-06-30) Move validations to Metadata?
+      def validate_hook_type(type)
+        if not possible_hook_types.include?(type)
+          error "The type of the script needs to be one of: #{possible_hook_types.join(', ')}."
+        end
+      end
+    end
+  end
+end

data/lib/ghundle/command/list_all.rb

@@ -0,0 +1,22 @@
+require 'ghundle/command'
+
+module Ghundle
+  module Command
+    # Lists all available hooks stored in the hook home directory.
+    #
+    class ListAll < Common
+      def call
+        puts output.strip
+      end
+
+      def output
+        Dir[config.hooks_root.join('*')].map do |path|
+          next if not File.directory?(path)
+
+          hook = Hook.new(Source::Local.new(path))
+          hook_description(hook)
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/ghundle/command/list_installed.rb

@@ -0,0 +1,38 @@
+require 'set'
+require 'ghundle/command'
+
+module Ghundle
+  module Command
+    # Lists all hooks installed in the current repo.
+    #
+    class ListInstalled < Common
+      def call
+        puts output.strip
+      end
+
+      def output
+        hook_names = Set.new
+
+        Dir['.git/hooks/*'].each do |filename|
+          File.open(filename) do |f|
+            f.each_line do |line|
+              if line =~ /^ghundle run (.*) \$\*/
+                hook_names << $1.strip
+              end
+            end
+          end
+        end
+
+        hook_names.sort.map do |hook_name|
+          source = Source::Local.new(config.hook_path(hook_name))
+
+          if source.exists?
+            hook_description(Hook.new(source))
+          else
+            "Warning: Hook `#{hook_name}` does not exist".foreground(:red)
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/ghundle/command/run.rb

@@ -0,0 +1,20 @@
+require 'ghundle/command'
+require 'ghundle/app_error'
+
+module Ghundle
+  module Command
+    # Runs the given hook, providing it with the rest of the positional
+    # arguments on the command-line.
+    #
+    class Run < Common
+      def call
+        name      = args.first
+        hook_path = config.hook_path(name)
+        hook      = Hook.new(Source::Local.new(hook_path))
+
+        say "Running hook #{hook.name}"
+        hook.run(*args[1 .. -1])
+      end
+    end
+  end
+end

data/lib/ghundle/command/uninstall.rb

@@ -0,0 +1,29 @@
+require 'ghundle/command'
+
+module Ghundle
+  module Command
+    # Uninstalls the given hook from the local repository.
+    #
+    class Uninstall < Common
+      def call
+        hook_name       = args.first
+        hook_invocation = "ghundle run #{hook_name} $*\n"
+
+        containing_hooks = Dir['.git/hooks/*'].map do |filename|
+          contents = IO.read(filename)
+          [filename, contents] if contents.include? hook_invocation
+        end.compact
+
+        if containing_hooks.empty?
+          say "Hook #{hook_name} not installed"
+        end
+
+        containing_hooks.each do |filename, contents|
+          say "Deleting from hook file `#{filename}`..."
+          contents.gsub!(hook_invocation, '')
+          File.open(filename, 'w') { |f| f.write(contents) }
+        end
+      end
+    end
+  end
+end

data/lib/ghundle/command.rb

@@ -0,0 +1,7 @@
+require 'ghundle/command/common'
+require 'ghundle/command/fetch'
+require 'ghundle/command/install'
+require 'ghundle/command/list_all'
+require 'ghundle/command/list_installed'
+require 'ghundle/command/run'
+require 'ghundle/command/uninstall'

data/lib/ghundle/config.rb

@@ -0,0 +1,19 @@
+module Ghundle
+  module Config
+    extend self
+
+    attr_accessor :hooks_root
+
+    def hooks_root
+      @hooks_root || Pathname.new(File.expand_path('~/.ghundle/'))
+    end
+
+    def hook_path(hook_name)
+      if not hooks_root.directory?
+        FileUtils.mkdir_p(hooks_root)
+      end
+
+      hooks_root.join(hook_name)
+    end
+  end
+end

data/lib/ghundle/hook.rb

@@ -0,0 +1,28 @@
+require 'ghundle/config'
+
+module Ghundle
+  class Hook
+    attr_reader :source
+
+    def initialize(source)
+      @source = source
+    end
+
+    def name
+      source.name
+    end
+
+    def metadata
+      source.metadata
+    end
+
+    def run(*args)
+      source.validate
+      system source.script_path.to_s, *args
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/ghundle/hook_version.rb

@@ -0,0 +1,23 @@
+module Ghundle
+  class HookVersion
+    attr_reader :major, :minor, :patch
+
+    def initialize(string)
+      @major, @minor, @patch = string.split('.').map(&:to_i)
+    end
+
+    def to_s
+      "#{major}.#{minor}.#{patch}"
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+  end
+end

data/lib/ghundle/main.rb

@@ -0,0 +1,27 @@
+require 'ghundle/command'
+
+module Ghundle
+  class Main
+    def self.exec(*args)
+      new(*args).exec
+    end
+
+    def initialize(*args)
+      @command = args.shift
+      @args    = args
+    end
+
+    def exec
+      case @command
+      when 'fetch'          then Command::Fetch.call(*@args)
+      when 'install'        then Command::Install.call(*@args)
+      when 'list-all'       then Command::ListAll.call(*@args)
+      when 'list-installed' then Command::ListInstalled.call(*@args)
+      when 'run'            then Command::Run.call(*@args)
+      when 'uninstall'      then Command::Uninstall.call(*@args)
+      else
+        raise AppError.new("Unknown command: #{@command}")
+      end
+    end
+  end
+end

data/lib/ghundle/metadata.rb

@@ -0,0 +1,25 @@
+require 'ghundle/hook_version'
+
+module Ghundle
+  class Metadata
+    attr_reader :types, :version, :description
+
+    def self.from_yaml(filename)
+      new(YAML.load_file(filename))
+    end
+
+    def initialize(data = {})
+      @version     = HookVersion.new(data['version'])
+      @types       = data['types']
+      @description = data['description']
+    end
+
+    def to_h
+      {
+        'types'       => types,
+        'version'     => version.to_s,
+        'description' => description,
+      }
+    end
+  end
+end

data/lib/ghundle/options_parser.rb

@@ -0,0 +1,54 @@
+require 'optparse'
+require 'ostruct'
+require 'ghundle/version'
+
+module Ghundle
+  # Contains the logic for extracting command-line options. Relies on
+  # 'optparse' from the standard library.
+  class OptionsParser
+    def initialize(args)
+      @args = args
+    end
+
+    def usage
+      [
+        '',
+        'Usage: ghundle <command> [options...]',
+        '',
+        'Commands:',
+        '',
+        '  ghundle list-all',
+        '  ghundle run <hook-name>',
+        '  ghundle fetch github.com/<username>/<repo>/<path/to/hook/dir>',
+        '  ghundle install <hook-name>',
+        '  ghundle install github.com/<username>/<repo>/<path/to/hook/dir>',
+        '  ghundle list-installed',
+        '  ghundle uninstall <hook-name>',
+        '',
+        'Options:',
+        '',
+      ].join("\n")
+    end
+
+    def parse
+      options = OpenStruct.new
+
+      parser = OptionParser.new do |o|
+        o.banner = usage
+
+        o.on_tail("-h", "--help", "Show this message") do
+          puts o
+          exit
+        end
+
+        o.on_tail("--version", "Show version") do
+          puts VERSION
+          exit
+        end
+      end
+
+      parser.parse!(@args)
+      options
+    end
+  end
+end

data/lib/ghundle/source/common.rb

@@ -0,0 +1,30 @@
+module Ghundle
+  module Source
+    # A descendant of Source::Common is a source that can be used to fetch a
+    # hook from a remote location into a local path. Look at the various
+    # children of this class to understand its usage better.
+    #
+    class Common
+      # Gets the name of the hook based on the url/path it's given
+      def hook_name
+        raise NotImplementedError
+      end
+
+      # Returns this source's metadata object.
+      def metadata
+        raise NotImplementedError
+      end
+
+      # Fetches the source into the local path, making it ready for execution.
+      # Returns a Source::Local that can be used to access its data.
+      def fetch(destination_path)
+        raise NotImplementedError
+      end
+
+      # Checks if the source was already extracted to the given path.
+      def fetched?(destination_path)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ghundle/source/directory.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+require 'pathname'
+require 'ghundle/metadata'
+require 'ghundle/source/common'
+
+module Ghundle
+  module Source
+    # Represents a directory on the filesystem that has a hook-compatible
+    # directory structure. It needs to be fetched to the local hook root in
+    # order to use the hook.
+    #
+    class Directory < Common
+      attr_reader :source_path
+
+      def initialize(path)
+        @source_path = Pathname.new(path)
+      end
+
+      def hook_name
+        @source_path.basename
+      end
+
+      def metadata
+        @metadata ||=
+          begin
+            validate
+            Metadata.new(YAML.load_file(source_path.join("meta.yml")))
+          end
+      end
+
+      def fetch(destination_path)
+        validate
+        destination_path = Pathname.new(destination_path)
+
+        local_source = Local.new(destination_path)
+        return local_source if local_source.exists?
+
+        FileUtils.mkdir_p(destination_path)
+        FileUtils.cp source_path.join("meta.yml"), destination_path.join("meta.yml")
+        FileUtils.cp source_path.join("run"), destination_path.join("run")
+
+        local_source
+      end
+
+      def validate
+        source_script_path   = source_path.join('run')
+        source_metadata_path = source_path.join('meta.yml')
+
+        if not source_script_path.file?
+          raise AppError.new("Script not found: #{source_script_path}")
+        end
+
+        if not source_script_path.executable?
+          raise AppError.new("Script not executable: #{source_script_path}")
+        end
+
+        if not source_metadata_path.file?
+          raise AppError.new("Metadata file not found: #{metadata_source_path}")
+        end
+      end
+
+      def to_s
+        source_path
+      end
+    end
+  end
+end

data/lib/ghundle/source/github.rb

@@ -0,0 +1,99 @@
+require 'net/http'
+require 'ghundle/metadata'
+require 'ghundle/source/common'
+
+module Ghundle
+  module Source
+    # Represents a remote hook on github.com. The description is of the format:
+    #
+    #   github.com/<username>/<repo>/<path/to/hook>
+    #
+    # Example:
+    #
+    #   github.com/AndrewRadev/hooks/ctags
+    #
+    # It needs to be fetched to the local hook root in order to use the hook.
+    #
+    class Github < Common
+      attr_reader :username, :repo, :path
+      attr_reader :script_name
+
+      def initialize(description)
+        @description            = description
+        @username, @repo, @path = parse_description(@description)
+        @path                   = Pathname.new(@path)
+        @script_name            = path.basename
+      end
+
+      def hook_name
+        path.basename
+      end
+
+      def metadata
+        @metadata ||=
+          begin
+            url          = raw_github_url(@path.join('meta.yml'))
+            status, yaml = http_get(url)
+
+            if status != 200
+              raise AppError.new("Couldn't fetch metadata file from #{url}, got response status: #{status}")
+            end
+
+            Metadata.new(YAML.load(yaml))
+          end
+      end
+
+      def fetch(destination_path)
+        destination_path = Pathname.new(destination_path)
+
+        local_source = Local.new(destination_path)
+        return local_source if local_source.exists?
+
+        FileUtils.mkdir_p(destination_path)
+
+        status, script = http_get(raw_github_url(@path.join('run')))
+        if status != 200
+          raise AppError.new("Couldn't fetch script file from #{url}, got response status: #{status}")
+        end
+
+        destination_path.join('run').open('w') do |f|
+          f.write(script)
+        end
+
+        destination_path.join('meta.yml').open('w') do |f|
+          f.write(YAML.dump(metadata.to_h))
+        end
+
+        File.chmod(0755, destination_path.join('run'))
+
+        local_source
+      end
+
+      def to_s
+        @path
+      end
+
+      private
+
+      def http_get(url_string)
+        uri      = URI(url_string)
+        response = Net::HTTP.get_response(uri)
+
+        [response.code.to_i, response.body]
+      end
+
+      def parse_description(description)
+        components = description.split('/')
+        username   = components[1]
+        repo       = components[2]
+        path       = components[3..-1].join('/')
+
+        [username, repo, path]
+      end
+
+      def raw_github_url(path)
+        "https://raw.github.com/#{@username}/#{@repo}/master/#{path}"
+      end
+    end
+  end
+end

data/lib/ghundle/source/local.rb

@@ -0,0 +1,58 @@
+require 'pathname'
+require 'ghundle/metadata'
+require 'ghundle/source/common'
+
+module Ghundle
+  module Source
+    # Represents the local source of a hook. This means that the hook has
+    # already been fetched to a local directory where it can easily be
+    # installed in a repository.
+    #
+    class Local < Common
+      def initialize(local_path)
+        @local_path = Pathname.new(local_path)
+      end
+
+      def name
+        @local_path.basename.to_s
+      end
+
+      def validate
+        return if exists?
+
+        if not script_path.file?
+          raise AppError.new("Script not found: #{script_path}")
+        end
+
+        if not script_path.executable?
+          raise AppError.new("Script not executable: #{script_path}")
+        end
+
+        if not metadata_path.file?
+          raise AppError.new("Metadata file not found: #{metadata_path}")
+        end
+      end
+
+      def exists?
+        script_path.executable? and metadata_path.file?
+      end
+
+      def metadata
+        validate
+        Metadata.from_yaml(metadata_path)
+      end
+
+      def fetch
+        self
+      end
+
+      def script_path
+        @local_path.join('run')
+      end
+
+      def metadata_path
+        @local_path.join('meta.yml')
+      end
+    end
+  end
+end

data/lib/ghundle/source.rb

@@ -0,0 +1,3 @@
+require 'ghundle/source/directory'
+require 'ghundle/source/github'
+require 'ghundle/source/local'

data/lib/ghundle/version.rb

@@ -0,0 +1,3 @@
+module Ghundle
+  VERSION = '0.0.2'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: ghundle
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andrew Radev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      Lets you manage git hooks in your project and install them from remote
+      locations.
+email:
+- andrey.radev@gmail.com
+executables:
+- ghundle
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ghundle.rb
+- lib/ghundle/command/common.rb
+- lib/ghundle/command/run.rb
+- lib/ghundle/command/install.rb
+- lib/ghundle/command/list_installed.rb
+- lib/ghundle/command/list_all.rb
+- lib/ghundle/command/fetch.rb
+- lib/ghundle/command/uninstall.rb
+- lib/ghundle/hook_version.rb
+- lib/ghundle/app_error.rb
+- lib/ghundle/main.rb
+- lib/ghundle/hook.rb
+- lib/ghundle/command.rb
+- lib/ghundle/source.rb
+- lib/ghundle/config.rb
+- lib/ghundle/options_parser.rb
+- lib/ghundle/source/local.rb
+- lib/ghundle/source/common.rb
+- lib/ghundle/source/directory.rb
+- lib/ghundle/source/github.rb
+- lib/ghundle/version.rb
+- lib/ghundle/metadata.rb
+- bin/ghundle
+- LICENSE
+- README.md
+homepage: http://github.com/AndrewRadev/ghundle
+licenses: []
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A package manager for git hooks
+test_files: []