git-hooks 0.0.2 → 0.1.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 587587daeb1f31d5403c88ee666acb9daab9b61e
-  data.tar.gz: 6a6a8fec7c3b4e5521714cbb60a4a39c6affbdc4
+  metadata.gz: e0e5a81167e56d3073667b763323fc77a08e59a0
+  data.tar.gz: 5118f531854a6eff62bbf7223241ff923398c749
 SHA512:
-  metadata.gz: ad395057c328251a5405bbda59c3e820e36719dde4ab97439d39ab659af13463bebeb840e68e46d91b8d825324b431c8dbbab41f73d4d1a8b0fc781a99971ba2
-  data.tar.gz: e5f914bf2a87e60e9575761f1439ae59f8846f81ddf4c0bdd45453c49468550a37dc597e5d8a8f0908e0b2f4204290cd32b342cf01d7f4a405dcbaaecfb4f84b
+  metadata.gz: d0583731adca1bda4f29862ab14134576e3ffbdc999eed66e7f9b6117186f73fe65d5d0329bcb78bffc0a73959120a2a6ed6b898d7273deb96144f8761383819
+  data.tar.gz: e4a7455fa439e266b8949477633b2f7676c271359979939579225a2ab00c18565f15183c8c3dce55ade26d2da5ce811c0d6781d63beaddb8d74189415ff2fc4d

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/README.md

@@ -17,42 +17,38 @@ Or install it yourself as:
     $ gem install git-hooks
 
 ## Usage
+### Install git_hooks on project.
 
-By now you will find only some simple hooks to:
-
- - Prevent commit on master.
- - Prevent commit with rubocop offences.
- - prevent commit with broken rspec tests.
-
-In the future, some validations will be
-added, such as:
+```
+$ git_hooks install pre-commit
+```
 
- - ensure hooks exists on ```.git/hooks```
+### Create configuration file
 
-By now, if you want all this validations, you should include a
-```.git/hooks/pre-commit``` with:
+Create a ```.git_hooks.yml``` on project root.
 
+```bash
+$ git_hooks configure
 ```
-#!/usr/bin/env ruby
-require 'git-hooks'
 
-GitHooks::PreCommit.validate
-```
 
-If you want specific validation include:
-```
-GitHooks::PreCommit::PreventMaster.new.validate
-```
+By now you will find only some simple hooks to:
 
-```
-GitHooks::PreCommit::Rspec.new.validate
-```
+ - Prevent commit on master.
+ - Prevent commit with rubocop offences.
+ - prevent commit with broken rspec tests.
 
-or
+### Ensure hooks existence
 
+To ensure that hooks exists on ```.git/hooks```, include on your application
+start up (probably  ```config/environments/development.rb``` or
+```config/environments/test.rb```)
+
+```ruby
+GitHooks.validate_hooks!
 ```
-GitHooks::PreCommit::Rubocop.new.validate
-```
+
+This will force ```git_hooks``` installation before your application start.
 
 ## Contributing
 

data/bin/git_hooks

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/git_hooks/cli'
+
+GitHooks::CLI.start

data/git-hooks.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = GitHooks::VERSION
   spec.authors       = ['Rafael da Silva Almeida']
   spec.email         = ['eusou@rafaelalmeida.net']
-  spec.summary       = %q(Help to keep git hooks organized.)
-  spec.description   = %q(It stores git hooks and force git hooks installation.)
+  spec.summary       = 'Help to keep git hooks organized.'
+  spec.description   = 'It stores git hooks and force git hooks installation.'
   spec.homepage      = 'http://github.com/stupied4ever/ruby-git-hooks'
   spec.license       = 'DWTF'
 
@@ -19,6 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'rubocop', '~> 0.23'
+  spec.add_dependency 'thor', '~> 0.19'
+  spec.add_dependency 'git', '~> 1.2'
+  spec.add_dependency 'equalizer', '~> 0.0.9'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

data/git_hooks.yml.example

@@ -0,0 +1,5 @@
+---
+pre_commits:
+- GitHooks::PreCommit::PreventMaster
+- GitHooks::PreCommit::Rubocop
+- GitHooks::PreCommit::Rspec

data/hook.sample

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'git-hooks'
+
+GitHooks.execute_pre_commits

data/lib/git-hooks.rb

@@ -1 +1,63 @@
+require 'equalizer'
+require 'yaml'
+
+require 'git'
+
+require_relative 'git_hooks/configurations'
+require_relative 'git_hooks/git'
+require_relative 'git_hooks/config_file'
+require_relative 'git_hooks/rspec_executor'
+require_relative 'git_hooks/rubocop_validator'
+
+require_relative 'git_hooks/exceptions'
 require_relative 'git_hooks/pre_commit'
+
+module GitHooks
+  HOOK_SAMPLE_FILE = 'hook.sample'
+  HOOKS = [PRE_COMMIT = 'pre-commit']
+
+  class << self
+    attr_writer :configurations
+
+    def execute_pre_commits
+      configurations.pre_commits.each do |pre_commit|
+        GitHooks::PreCommit.const_get(pre_commit).validate
+      end
+    end
+
+    def configurations
+      @configurations ||= Configurations.new
+    end
+
+    def base_path
+      File.absolute_path(File.join(File.expand_path(__FILE__), '..', '..'))
+    end
+
+    def hook_installed?(hook)
+      hook_file = File.join(Dir.pwd, '.git', 'hooks', hook)
+      real_hook_file = File.join(base_path, HOOK_SAMPLE_FILE)
+
+      return false unless File.symlink?(hook_file)
+      File.realpath(hook_file) == real_hook_file
+    end
+
+    def install_hook(hook)
+      File.symlink(real_hook_template_path, ".git/hooks/#{hook}")
+    end
+
+    def validate_hooks!
+      fail Exceptions::MissingHook, PRE_COMMIT unless valid_pre_commit_hook?
+    end
+
+    private
+
+    def valid_pre_commit_hook?
+      return true if configurations.pre_commits.empty?
+      hook_installed?(PRE_COMMIT)
+    end
+
+    def real_hook_template_path
+      File.join(base_path, HOOK_SAMPLE_FILE)
+    end
+  end
+end

data/lib/git_hooks/cli.rb

@@ -0,0 +1,31 @@
+require 'thor'
+
+require_relative '../git-hooks'
+
+module GitHooks
+  class CLI < Thor
+    desc 'install HOOK', 'Install some hook'
+    long_desc <<-LONGDESC
+      Install some hook:
+
+      > $ git_hooks install pre-commit
+    LONGDESC
+    def install(hook)
+      GitHooks.install_hook(hook)
+    end
+
+    desc 'Create configuration file', 'Create a configuration file'
+    long_desc <<-LONGDESC
+      Create a configuration file base on git_hooks.yml.examle
+
+      > $ git_hooks configure
+    LONGDESC
+    def configure
+      example_file = File.expand_path(
+        '../../../git_hooks.yml.example', __FILE__
+      )
+      destination_path = File.expand_path('.git_hooks.yml', Dir.pwd)
+      FileUtils.cp(example_file, destination_path)
+    end
+  end
+end

data/lib/git_hooks/config_file.rb

@@ -0,0 +1,17 @@
+module GitHooks
+  class ConfigFile
+    def initialize(path)
+      @content = YAML.load_file(path)
+    rescue Errno::ENOENT
+      @content = {}
+    end
+
+    def pre_commits
+      content['pre_commits'] || []
+    end
+
+    def content
+      @content || { 'pre_commits' => [] }
+    end
+  end
+end

data/lib/git_hooks/configurations.rb

@@ -0,0 +1,20 @@
+require 'forwardable'
+
+module GitHooks
+  class Configurations
+    include Equalizer.new(:config_file, :git_repository)
+    extend Forwardable
+
+    attr_reader :config_file, :git_repository
+
+    def_delegator :config_file, :pre_commits
+
+    def initialize(
+      config_file: ConfigFile.new('.git_hooks.yml'),
+      git_repository: Git.new('.')
+    )
+      @config_file = config_file
+      @git_repository = git_repository
+    end
+  end
+end

data/lib/git_hooks/exceptions.rb

@@ -0,0 +1 @@
+require_relative 'exceptions/missing_hooks'

data/lib/git_hooks/exceptions/missing_hooks.rb

@@ -0,0 +1,9 @@
+module GitHooks
+  module Exceptions
+    class MissingHook < RuntimeError
+      def initialize(hook)
+        super "Please install #{hook} hook."
+      end
+    end
+  end
+end

data/lib/git_hooks/git.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+
+module GitHooks
+  class Git
+    extend Forwardable
+
+    attr_reader :working_folder
+
+    def_delegator :repository, :current_branch
+
+    def initialize(working_folder)
+      @working_folder = working_folder
+    end
+
+    def repository
+      ::Git.open(working_folder)
+    end
+
+    def added_or_modified
+      added = repository.status.added
+      modified = repository.status.changed
+
+      added.merge(modified).keys
+    end
+
+    def clean?
+      (added_files + modified_files + deleted_files + untracked_files).empty?
+    end
+
+    private
+
+    def added_files
+      repository.status.added.keys
+    end
+
+    def modified_files
+      repository.status.changed.keys
+    end
+
+    def deleted_files
+      repository.status.deleted.keys
+    end
+
+    def untracked_files
+      repository.status.untracked.keys
+    end
+  end
+end

data/lib/git_hooks/pre_commit.rb

@@ -4,10 +4,5 @@ require_relative 'pre_commit/rubocop'
 
 module GitHooks
   module PreCommit
-    def self.validate
-      PreventMaster.new.validate
-      Rubocop.new.validate
-      Rspec.new.validate
-    end
   end
 end

data/lib/git_hooks/pre_commit/prevent_master.rb

@@ -1,10 +1,26 @@
 module GitHooks
   module PreCommit
     class PreventMaster
+      attr_reader :git_repository
+
+      def self.validate
+        new(GitHooks.configurations.git_repository).validate
+      end
+
+      def initialize(git_repository)
+        @git_repository = git_repository
+      end
+
       def validate
-        return unless `git rev-parse --abbrev-ref HEAD`.strip == 'master'
+        abort 'Prevented to commit on master' if on_master?
+      end
+
+      private
+
+      BRANCH_MASTER = 'master'
 
-        abort 'Prevented to commit on master'
+      def on_master?
+        git_repository.current_branch == BRANCH_MASTER
       end
     end
   end

data/lib/git_hooks/pre_commit/rspec.rb

@@ -1,10 +1,22 @@
 module GitHooks
   module PreCommit
     class Rspec
+      attr_reader :git_repository, :rspec_executor
+
+      def self.validate
+        new(
+          GitHooks.configurations.git_repository, RspecExecutor.new
+        ).validate
+      end
+
+      def initialize(git_repository, rspec_executor)
+        @git_repository, @rspec_executor = git_repository, rspec_executor
+      end
+
       def validate
-        return if system('bundle exec rspec --format=progress')
+        return if git_repository.clean?
 
-        abort 'Prevented broken commit'
+        abort 'Prevented broken commit' if rspec_executor.errors?
       end
     end
   end

data/lib/git_hooks/pre_commit/rubocop.rb

@@ -1,28 +1,32 @@
 module GitHooks
   module PreCommit
     class Rubocop
+      attr_reader :git_repository, :rubocop_validator
+
+      def self.validate
+        new(
+          GitHooks.configurations.git_repository, RubocopValidator.new
+        ).validate
+      end
+
+      def initialize(git_repository, rubocop_validator)
+        @git_repository, @rubocop_validator = git_repository, rubocop_validator
+      end
+
       def validate
-        abort 'Check rubocop offences' unless run_rubocop
+        abort 'Check rubocop offences' if offences?
       end
 
       private
 
-      ADDED_OR_MODIFIED = /A|AM|^M/.freeze
-
-      def changed_ruby_files
-        `git status --porcelain`.split(/\n/)
-          .select { |file| file =~ ADDED_OR_MODIFIED }
-          .map    { |file| file.split(' ')[1]        }
+      def changed_files
+        git_repository
+          .added_or_modified
           .select { |file| File.extname(file) == '.rb' }
       end
 
-      def run_rubocop
-        files = changed_ruby_files
-        if files.any?
-          system("rubocop #{files.join(' ')} --force-exclusion")
-        else
-          true
-        end
+      def offences?
+        rubocop_validator.errors?(changed_files)
       end
     end
   end

data/lib/git_hooks/rspec_executor.rb

@@ -0,0 +1,13 @@
+module GitHooks
+  class RspecExecutor
+    def errors?
+      !system(rspec_command)
+    end
+
+    private
+
+    def rspec_command
+      'bundle exec rspec --format=progress'
+    end
+  end
+end

data/lib/git_hooks/rubocop_validator.rb

@@ -0,0 +1,9 @@
+module GitHooks
+  class RubocopValidator
+    def errors?(files)
+      return false if files.empty?
+
+      system("rubocop #{files.join(' ')} --force-exclusion") == false
+    end
+  end
+end

data/lib/git_hooks/version.rb

@@ -1,3 +1,3 @@
 module GitHooks
-  VERSION = '0.0.2'
+  VERSION = '0.1.0.pre1'
 end

data/spec/git_hooks/config_file_spec.rb

@@ -0,0 +1,29 @@
+module GitHooks
+  describe ConfigFile do
+    subject(:config) { described_class.new(path) }
+
+    let(:path) { '' }
+    let(:content) { { 'pre_commits' => pre_commits } }
+    let(:pre_commits) { %w(foo bar) }
+
+    context 'when the given file does not exists' do
+      subject(:config) { -> { described_class.new(path) } }
+
+      let(:path) { 'some-not-existent-file' }
+
+      it { is_expected.to_not raise_error }
+    end
+
+    describe '#pre_commits' do
+      subject { config.pre_commits }
+
+      before do
+        allow(YAML).to receive(:load_file).and_return(content)
+      end
+
+      it 'has the pre commits specified on hook file' do
+        is_expected.to eq(%w(foo bar))
+      end
+    end
+  end
+end

data/spec/git_hooks/configurations_spec.rb

@@ -0,0 +1,82 @@
+module GitHooks
+  describe Configurations do
+    subject(:configurations) { described_class.new }
+
+    before do
+      allow(ConfigFile).to receive(:new).and_return(file)
+      allow(Git).to receive(:new).and_return(repository)
+    end
+
+    let(:file) { instance_double(ConfigFile) }
+    let(:repository) { instance_double(Git) }
+
+    describe '#pre_commits' do
+      subject { configurations.pre_commits }
+
+      let(:configurations) { described_class.new(config_file: config_file) }
+      let(:pre_commits) { %w(foo, bar) }
+
+      let(:config_file) do
+        instance_double(ConfigFile, pre_commits: pre_commits)
+      end
+
+      it { is_expected.to eq(pre_commits) }
+    end
+
+    describe '#config_file' do
+      subject(:config_file) { configurations.config_file }
+
+      let(:config_path) { '.git_hooks.yml' }
+
+      it { is_expected.to eq(file) }
+
+      it 'creates a config file with config_path' do
+        expect(ConfigFile).to receive(:new).with(config_path)
+
+        configurations
+      end
+
+      context 'with a config_path set' do
+        let(:configurations) do
+          described_class.new(config_file: file)
+        end
+
+        it 'does not creates a config file' do
+          expect(ConfigFile).to_not receive(:new)
+
+          configurations
+        end
+
+        it { is_expected.to eq(file) }
+      end
+    end
+
+    describe '#git_repository' do
+      subject(:git_repository) { configurations.git_repository }
+
+      let(:git_folder) { '.' }
+
+      it { is_expected.to eq(repository) }
+
+      it 'creates git repository with git folder' do
+        expect(Git).to receive(:new).with(git_folder)
+
+        git_repository
+      end
+
+      context 'with a git_repository set' do
+        let(:git_repository) do
+          described_class.new(git_repository: repository)
+        end
+
+        it 'does not creates a git repository' do
+          expect(Git).to_not receive(:new)
+
+          git_repository
+        end
+
+        it { is_expected.to eq(repository) }
+      end
+    end
+  end
+end

data/spec/git_hooks/git_spec.rb

@@ -0,0 +1,115 @@
+module GitHooks
+  describe Git do
+    subject(:git) { described_class.new(working_folder) }
+
+    let(:working_folder) { 'some folder' }
+
+    describe '#working_folder' do
+      subject { git.working_folder }
+
+      it { is_expected.to eq(working_folder) }
+    end
+
+    describe '#repository' do
+      subject(:opened_repository) { git.repository }
+
+      let(:repository) { instance_double(::Git::Base) }
+
+      before do
+        allow(::Git).to receive(:open).and_return(repository)
+      end
+
+      it 'open git repository' do
+        expect(::Git).to receive(:open).with(working_folder)
+        opened_repository
+      end
+
+      it { is_expected.to eq(repository) }
+    end
+
+    describe '#added_or_modified' do
+      subject(:added_or_modified) { git.added_or_modified }
+
+      let(:repository) { instance_double(::Git::Base, status: status) }
+
+      let(:status) do
+        instance_double(::Git::Status, added: added, changed: changed)
+      end
+
+      let(:added) { { foo: 'bar' } }
+      let(:changed) { { bar: 'foo' } }
+
+      before do
+        allow(::Git).to receive(:open).and_return(repository)
+      end
+
+      it 'merges added and modified' do
+        is_expected.to eq(%i(foo bar))
+      end
+    end
+
+    describe '#clean?' do
+      subject(:clean?) { git.clean? }
+
+      let(:repository) { instance_double(::Git::Base, status: status) }
+
+      let(:status) do
+        instance_double(
+          ::Git::Status,
+          added: added, changed: changed, deleted: deleted, untracked: untracked
+        )
+      end
+
+      let(:added) { Hash.new }
+      let(:changed) { Hash.new }
+      let(:deleted) { Hash.new }
+      let(:untracked) { Hash.new }
+
+      before do
+        allow(::Git).to receive(:open).and_return(repository)
+      end
+
+      it { is_expected.to be_truthy }
+
+      context 'with some added file' do
+        let(:added) { { foo: 'bar' } }
+
+        it { is_expected.to be_falsy }
+      end
+
+      context 'with some changed file' do
+        let(:changed) { { foo: 'bar' } }
+
+        it { is_expected.to be_falsy }
+      end
+
+      context 'with some deleted file' do
+        let(:deleted) { { foo: 'bar' } }
+
+        it { is_expected.to be_falsy }
+      end
+
+      context 'with some untracked file' do
+        let(:untracked) { { foo: 'bar' } }
+
+        it { is_expected.to be_falsy }
+      end
+    end
+
+    describe '#current_branch' do
+      subject { git.current_branch }
+
+      let(:repository) { instance_double(::Git::Base, current_branch: branch) }
+      let(:branch) { 'some-branch' }
+
+      before do
+        allow(::Git).to receive(:open).and_return(repository)
+        allow(git).to receive(:current_branch).and_return(branch)
+      end
+
+      it 'returns the current branch' do
+        is_expected.to eq('some-branch')
+      end
+    end
+  end
+end

data/spec/git_hooks/pre_commit/prevent_master_spec.rb

@@ -0,0 +1,57 @@
+module GitHooks
+  module PreCommit
+    describe PreventMaster do
+      subject(:prevent_master) { described_class.new git_repository }
+
+      let(:git_repository) do
+        instance_double(GitHooks::Git, current_branch: branch)
+      end
+
+      let(:branch) { 'some-branch' }
+
+      describe '#validate' do
+        subject(:validate) { -> { prevent_master.validate } }
+
+        it { is_expected.to_not raise_error }
+
+        context 'when current_branch is master' do
+          let(:branch) { 'master' }
+
+          before do
+            allow($stderr).to receive(:write).and_return('')
+          end
+          it { is_expected.to raise_error(SystemExit) }
+        end
+      end
+
+      describe '.validate' do
+        subject(:validate) { described_class.validate }
+
+        let(:prevent_master) { instance_double(PreventMaster) }
+        let(:git) { instance_double(GitHooks::Git) }
+
+        let(:configurations) do
+          instance_double(Configurations, git_repository: git)
+        end
+
+        before do
+          allow(GitHooks).to receive(:configurations).and_return(configurations)
+          allow(described_class).to receive(:new).and_return(prevent_master)
+          allow(prevent_master).to receive(:validate).and_return(nil)
+        end
+
+        it 'creates object with GitHooks.git_repository' do
+          expect(PreventMaster).to receive(:new).with(git)
+
+          validate
+        end
+
+        it 'validates' do
+          expect(prevent_master).to receive(:validate)
+
+          validate
+        end
+      end
+    end
+  end
+end

data/spec/git_hooks/pre_commit/rspec_spec.rb

@@ -0,0 +1,78 @@
+module GitHooks
+  module PreCommit
+    describe Rspec do
+      subject(:rspec) { described_class.new git_repository, rspec_executor }
+
+      let(:git_repository) do
+        instance_double(GitHooks::Git, clean?: clean?)
+      end
+
+      let(:rspec_executor) do
+        instance_double(GitHooks::RspecExecutor, errors?: errors?)
+      end
+
+      let(:errors?) { false }
+
+      describe '#validate' do
+        subject(:validate) { -> { rspec.validate } }
+
+        let(:clean?) { true }
+
+        it { is_expected.to_not raise_error }
+
+        context 'with modified files' do
+          let(:rspec_executor) do
+            instance_double(GitHooks::RspecExecutor, errors?: errors?)
+          end
+
+          let(:clean?) { false }
+          let(:errors?) { false }
+
+          it { is_expected.to_not raise_error }
+
+          context 'and some broken test' do
+            let(:errors?) { true }
+
+            before do
+              allow($stderr).to receive(:write).and_return('')
+            end
+
+            it { is_expected.to raise_error(SystemExit) }
+          end
+        end
+      end
+
+      describe '.validate' do
+        subject(:validate) { described_class.validate }
+
+        let(:rspec) { instance_double(Rspec) }
+        let(:rspec_executor) { instance_double(RspecExecutor) }
+        let(:git) { instance_double(GitHooks::Git) }
+
+        let(:configurations) do
+          instance_double(Configurations, git_repository: git)
+        end
+
+        before do
+          allow(described_class).to receive(:new).and_return(rspec)
+          allow(rspec).to receive(:validate).and_return(nil)
+
+          allow(GitHooks).to receive(:configurations).and_return(configurations)
+          allow(RspecExecutor).to receive(:new).and_return(rspec_executor)
+        end
+
+        it 'creates object with GitHooks.git_repository' do
+          expect(Rspec).to receive(:new).with(git, rspec_executor)
+
+          validate
+        end
+
+        it 'validates' do
+          expect(rspec).to receive(:validate)
+
+          validate
+        end
+      end
+    end
+  end
+end

data/spec/git_hooks/pre_commit/rubocop_spec.rb

@@ -0,0 +1,83 @@
+module GitHooks
+  module PreCommit
+    describe Rubocop do
+      subject(:rubocop) do
+        described_class.new(git_repository, rubocop_validator)
+      end
+
+      let(:git_repository) do
+        instance_double(GitHooks::Git, added_or_modified: added_or_modified)
+      end
+
+      let(:rubocop_validator) do
+        instance_double(GitHooks::RubocopValidator, errors?: errors?)
+      end
+
+      let(:added_or_modified) { [] }
+      let(:errors?) { false }
+
+      describe '#validate' do
+        subject(:validate) { rubocop.validate  }
+
+        let(:added_or_modified) { [ruby_file, 'foo.txt'] }
+        let(:ruby_file) { 'foo.rb' }
+
+        it 'only validates ruby files' do
+          expect(rubocop_validator)
+            .to receive(:errors?)
+            .with([ruby_file])
+          validate
+        end
+
+        context 'with errors' do
+          let(:errors?) { true }
+
+          before do
+            allow($stderr).to receive(:write).and_return('')
+          end
+
+          it { expect(-> { validate }).to raise_error(SystemExit) }
+        end
+
+        context 'without errors' do
+          let(:errors?) { false }
+
+          it { expect(-> { validate }).to_not raise_error }
+        end
+      end
+
+      describe '.validate' do
+        subject(:validate) { described_class.validate }
+
+        let(:rubocop) { instance_double(Rubocop) }
+        let(:rubocop_validator) { instance_double(RubocopValidator) }
+
+        let(:git) { instance_double(GitHooks::Git) }
+
+        let(:configurations) do
+          instance_double(Configurations, git_repository: git)
+        end
+
+        before do
+          allow(described_class).to receive(:new).and_return(rubocop)
+          allow(rubocop).to receive(:validate).and_return(nil)
+
+          allow(GitHooks).to receive(:configurations).and_return(configurations)
+          allow(RubocopValidator).to receive(:new).and_return(rubocop_validator)
+        end
+
+        it 'creates object with GitHooks.git_repository' do
+          expect(Rubocop).to receive(:new).with(git, rubocop_validator)
+
+          validate
+        end
+
+        it 'validates' do
+          expect(rubocop).to receive(:validate)
+
+          validate
+        end
+      end
+    end
+  end
+end

data/spec/git_hooks/rspec_executor_spec.rb

@@ -0,0 +1,36 @@
+module GitHooks
+  describe RspecExecutor do
+    subject(:rspec_executor) { described_class.new }
+
+    describe '#errors?' do
+      subject(:errors?) { rspec_executor.errors? }
+
+      let(:rspec_command) { 'bundle exec rspec --format=progress' }
+
+      before do
+        allow(rspec_executor).to receive(:system).and_return(true)
+      end
+
+      it 'call rubocop on system' do
+        expect(rspec_executor).to receive(:system).with(rspec_command)
+        errors?
+      end
+
+      context 'with broken test' do
+        before do
+          allow(rspec_executor).to receive(:system).and_return(false)
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'when files has no offences' do
+        before do
+          allow(rspec_executor).to receive(:system).and_return(true)
+        end
+
+        it { is_expected.to be_falsy }
+      end
+    end
+  end
+end

data/spec/git_hooks/rubocop_validator_spec.rb

@@ -0,0 +1,48 @@
+module GitHooks
+  describe RubocopValidator do
+    subject(:rubocop_validator) { described_class.new }
+
+    describe '#errors?' do
+      subject(:errors?) { rubocop_validator.errors?(files) }
+
+      context 'with files' do
+        let(:files) { %w(a.rb b.rb) }
+
+        let(:rubocop_command) do
+          "rubocop #{files.join(' ')} --force-exclusion"
+        end
+
+        before do
+          allow(rubocop_validator).to receive(:system).and_return(true)
+        end
+
+        it 'call rubocop on system' do
+          expect(rubocop_validator).to receive(:system).with(rubocop_command)
+          errors?
+        end
+
+        context 'when some file has offences' do
+          before do
+            allow(rubocop_validator).to receive(:system).and_return(false)
+          end
+
+          it { is_expected.to be_truthy }
+        end
+
+        context 'when files has no offences' do
+          before do
+            allow(rubocop_validator).to receive(:system).and_return(true)
+          end
+
+          it { is_expected.to be_falsy }
+        end
+      end
+
+      context 'with empty files array' do
+        let(:files) { [] }
+
+        it { is_expected.to be_falsy }
+      end
+    end
+  end
+end

data/spec/git_hooks_spec.rb

@@ -0,0 +1,140 @@
+describe GitHooks do
+  describe '#validate_hooks!' do
+    subject { -> { described_class.validate_hooks! } }
+
+    before { GitHooks.configurations = configs }
+
+    let(:configs) do
+      instance_double(GitHooks::Configurations, pre_commits: pre_commits)
+    end
+
+    let(:pre_commits) { [] }
+
+    it { is_expected.to_not raise_error }
+
+    context 'with pre-commit hooks configured' do
+      let(:pre_commits) { %w(foo bar) }
+      let(:hook_installed?) { true }
+
+      before do
+        allow(GitHooks).to receive(:hook_installed?).and_return(hook_installed?)
+      end
+
+      it { is_expected.to_not raise_error }
+
+      context 'but without pre-commit installed' do
+        let(:hook_installed?) { false }
+
+        let(:message) { 'Please install pre-commit hook.' }
+
+        it do
+          is_expected.to raise_error(GitHooks::Exceptions::MissingHook, message)
+        end
+      end
+    end
+  end
+
+  describe '.base_path' do
+    subject { described_class.base_path }
+
+    it "has gem's root path" do
+      is_expected.to eq(
+        File.absolute_path(
+          File.join(File.expand_path(__FILE__), '..', '..')
+        )
+      )
+    end
+  end
+
+  describe '.configurations' do
+    subject(:configurations) { described_class.configurations }
+
+    before do
+      GitHooks.configurations = nil
+      allow(GitHooks::Configurations).to receive(:new).and_return(configs)
+    end
+
+    let(:configs) { instance_double(GitHooks::Configurations) }
+
+    it 'creates with default params' do
+      expect(GitHooks::Configurations).to receive(:new).with(no_args)
+
+      is_expected.to eq(configs)
+    end
+  end
+
+  describe 'configurations=' do
+    subject(:set_configurations) { described_class.configurations = configs }
+
+    let(:configs) { instance_double(GitHooks::Configurations) }
+
+    before do
+      allow(GitHooks::Configurations).to receive(:new).and_return(nil)
+    end
+
+    it 'updates configurations' do
+      expect { set_configurations }.to change {
+        GitHooks.configurations
+      }.to(configs)
+
+      is_expected.to eq(configs)
+    end
+  end
+
+  describe '.install_hook' do
+    subject(:install_hook) { described_class.install_hook(hook) }
+
+    let(:hook) { 'pre-commit' }
+    let(:hook_real_path) { File.join(GitHooks.base_path, 'hook.sample') }
+    let(:git_hook_path) { ".git/hooks/#{hook}" }
+
+    before do
+      allow(File).to receive(:symlink).and_return(true)
+    end
+
+    it 'creates symlink' do
+      expect(File)
+        .to receive(:symlink)
+        .with(hook_real_path, git_hook_path)
+      install_hook
+    end
+
+    it { is_expected.to be_truthy }
+  end
+
+  describe '.hook_installed?' do
+    subject(:installed?) { described_class.hook_installed?(hook) }
+
+    let(:hook) { 'pre-commit' }
+    let(:hook_real_path) { File.join(GitHooks.base_path, 'hook.sample') }
+    let(:symlink?) { true }
+
+    let(:absolute_path) { File.join(GitHooks.base_path, '.git', 'hooks', hook) }
+
+    before do
+      allow(File).to receive(:symlink?).and_return(symlink?)
+      allow(File).to receive(:realpath).and_return(hook_real_path)
+    end
+
+    it 'validates file is a symlink' do
+      expect(File).to receive(:symlink?).with(absolute_path)
+      installed?
+    end
+
+    it { is_expected.to be_truthy }
+
+    context 'when file is not a symlink' do
+      let(:symlink?) { false }
+
+      it { is_expected.to be_falsy }
+    end
+
+    context 'when is not the GitHooks file' do
+      before do
+        allow(File).to receive(:realpath).and_return('/tmp/foo')
+      end
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/git-hooks'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: git-hooks
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0.pre1
 platform: ruby
 authors:
 - Rafael da Silva Almeida
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-24 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -24,6 +24,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,26 +80,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: It stores git hooks and force git hooks installation.
 email:
 - eusou@rafaelalmeida.net
-executables: []
+executables:
+- git_hooks
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - Gemfile
 - README.md
+- bin/git_hooks
 - git-hooks.gemspec
+- git_hooks.yml.example
+- hook.sample
 - lib/git-hooks.rb
+- lib/git_hooks/cli.rb
+- lib/git_hooks/config_file.rb
+- lib/git_hooks/configurations.rb
+- lib/git_hooks/exceptions.rb
+- lib/git_hooks/exceptions/missing_hooks.rb
+- lib/git_hooks/git.rb
 - lib/git_hooks/pre_commit.rb
 - lib/git_hooks/pre_commit/prevent_master.rb
 - lib/git_hooks/pre_commit/rspec.rb
 - lib/git_hooks/pre_commit/rubocop.rb
+- lib/git_hooks/rspec_executor.rb
+- lib/git_hooks/rubocop_validator.rb
 - lib/git_hooks/version.rb
-- lib/ruby-git-hooks.rb
+- spec/git_hooks/config_file_spec.rb
+- spec/git_hooks/configurations_spec.rb
+- spec/git_hooks/git_spec.rb
+- spec/git_hooks/pre_commit/prevent_master_spec.rb
+- spec/git_hooks/pre_commit/rspec_spec.rb
+- spec/git_hooks/pre_commit/rubocop_spec.rb
+- spec/git_hooks/rspec_executor_spec.rb
+- spec/git_hooks/rubocop_validator_spec.rb
+- spec/git_hooks_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/stupied4ever/ruby-git-hooks
 licenses:
 - DWTF
@@ -73,14 +151,24 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Help to keep git hooks organized.
-test_files: []
+test_files:
+- spec/git_hooks/config_file_spec.rb
+- spec/git_hooks/configurations_spec.rb
+- spec/git_hooks/git_spec.rb
+- spec/git_hooks/pre_commit/prevent_master_spec.rb
+- spec/git_hooks/pre_commit/rspec_spec.rb
+- spec/git_hooks/pre_commit/rubocop_spec.rb
+- spec/git_hooks/rspec_executor_spec.rb
+- spec/git_hooks/rubocop_validator_spec.rb
+- spec/git_hooks_spec.rb
+- spec/spec_helper.rb
 has_rdoc: 

data/lib/ruby-git-hooks.rb

@@ -1 +0,0 @@
-require_relative 'git_hooks/pre_commit'