captain_hoog 1.0

data/lib/captain_hoog/dependencies.rb

@@ -0,0 +1,2 @@
+require 'colorize'
+require 'terminal-table'

data/lib/captain_hoog/env.rb

@@ -0,0 +1,17 @@
+module CaptainHoog
+  class Env < Hash
+
+    def method_missing(meth_name, *args, &block)
+      if self.has_key?(meth_name)
+        return self[meth_name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth_name, include_private = false)
+      self.has_key?(meth_name) || super
+    end
+
+  end
+end

data/lib/captain_hoog/errors/dsl_errors.rb

@@ -0,0 +1,6 @@
+module CaptainHoog
+  module Errors
+    TestResultNotValidError     = Class.new(StandardError)
+    MessageResultNotValidError  = Class.new(TestResultNotValidError)
+  end
+end

data/lib/captain_hoog/errors.rb

@@ -0,0 +1 @@
+require_relative 'errors/dsl_errors'

data/lib/captain_hoog/git.rb

@@ -0,0 +1,72 @@
+module CaptainHoog
+  class Git
+
+    attr_accessor :env
+
+    def initialize
+      @helper_table = HelperTable.new
+    end
+
+    def test(&test_block)
+      if test_block
+        @test_block = test_block
+      end
+    end
+
+    def message
+      if block_given?
+        @message = yield
+        unless @message.is_a?(String)
+          raise CaptainHoog::Errors::MessageResultNotValidError
+        end
+      end
+    end
+
+    def helper(name,&block)
+      return if @helper_table.helper_defined?(name)
+      helper_proc = {}
+      helper_proc[name] = block
+      @helper_table.set(helper_proc)
+    end
+
+    def run(&run_block)
+      @test_result = true
+      @run_block   = run_block
+    end
+
+    # Public: Renders a table.
+    #
+    # rows - An Array of row contents
+    # headings - An Array of headlines
+    #
+    # Returns the table as String.
+    def render_table(rows, headings = [])
+      table = ::Terminal::Table.new(headings: headings, rows: rows)
+
+      table.to_s
+    end
+
+    def method_missing(meth_name, *args, &block)
+      super unless @helper_table.helper_defined?(meth_name)
+      helper = @helper_table[meth_name]
+      fail ArgumentError unless helper[meth_name].arity == args.size
+      helper[meth_name].call(*args)
+    end
+
+    def respond_to_missing?(meth_name, include_private = false)
+      @helper_table.helper_defined?(meth_name) || super
+    end
+
+    def execute
+      if @test_block
+        @test_result = @test_block.call
+      else
+        # run #run
+        @run_block.call
+      end
+      unless @test_result.is_a?(FalseClass) or @test_result.is_a?(TrueClass)
+        raise CaptainHoog::Errors::TestResultNotValidError
+      end
+    end
+  end
+end

data/lib/captain_hoog/helper_table.rb

@@ -0,0 +1,23 @@
+module CaptainHoog
+  class HelperTable < ::Array
+
+    def helper_defined?(helper_name)
+      defined_helpers.include?(helper_name)
+    end
+
+    def defined_helpers
+      self.map(&:keys).flatten
+    end
+
+    def [](helper_name)
+      self.detect do |helper|
+        helper.keys.include?(helper_name)
+      end
+    end
+    alias_method :get, :[]
+
+    def set(helper)
+      self << helper
+    end
+  end
+end

data/lib/captain_hoog/plugin.rb

@@ -0,0 +1,67 @@
+module CaptainHoog
+  # Public: Class that evaluates a plugin from a given bunch of DSL code.
+  class Plugin
+    include Delegatable
+
+    attr_accessor :env
+
+    delegate_to :eigenplugin
+
+    # Public: Initializes the Plugin evaluator.
+    #
+    # code - the plugin code as String
+    # env  - An instance of CaptainHoog::Env containing some accessible
+    #        environment variables (context is limited to CaptainHoog)
+    def initialize(code,env)
+      @code  = code
+      @env   = env
+      @git   = CaptainHoog::Git.new
+    end
+
+    # Public: Yields the code given in @code.
+    def git
+      eigenplugin
+    end
+
+    # Public: Evaluates the plugin by 'reading' the dsl. Did not execute
+    # anything.
+    #
+    # Returns nothing
+    def eval_plugin
+      instance_eval(@code)
+    end
+
+    # Public: Executes a plugin and stores the results in a Hash.
+    #
+    # Returns a Hash containing the test result and the failure message.
+    def execute
+      eigenplugin.execute
+      {
+        :result  => @git.instance_variable_get(:@test_result),
+        :message => @git.instance_variable_get(:@message)
+      }
+    end
+
+    private
+
+    def eigenplugin
+      @eigenplugin ||= Class.new do
+        include Delegatable
+        attr_reader :plugin_name
+
+        delegate_to :git
+
+        def initialize(git)
+          @git = git
+        end
+
+        def describe(name)
+          @plugin_name = name
+          yield(@git) if block_given?
+        end
+
+      end.new(@git)
+    end
+
+  end
+end

data/lib/captain_hoog/plugin_list.rb

@@ -0,0 +1,29 @@
+module CaptainHoog
+  class PluginList
+
+    attr_reader :plugins
+
+    def initialize(type='pre-commit', config: {})
+      @config = config
+      @type   = type
+      build_list
+    end
+
+    def has?(plugin)
+      @plugins.include?(plugin.plugin_name)
+    end
+
+    private
+
+    def build_list
+      plugins_for_type = @config.fetch(@type, [])
+      excluded_plugins = @config.fetch('exclude', [])
+
+      plugins_for_type = [] if plugins_for_type.nil?
+      excluded_plugins = [] if excluded_plugins.nil?
+
+      @plugins = plugins_for_type - excluded_plugins
+    end
+
+  end
+end

data/lib/captain_hoog/pre_git.rb

@@ -0,0 +1,125 @@
+module CaptainHoog
+  # Public: Entry class for handling a Pre-Something with plugins.
+  class PreGit
+
+    class << self
+      attr_accessor :project_dir,
+                    :plugins_dir,
+                    :headline_on_success,
+                    :headline_on_failure,
+                    :suppress_headline
+    end
+
+    # Public: Runs the hook.
+    #
+    # Inits a new instance of self and evaluates the plugins (if found some)
+    #
+    # Returns an instance of self (CaptainHoog::PreGit)
+    def self.run(plugins_list: nil)
+      pre_git = self.new(plugins_list)
+      pre_git.plugins_eval
+      pre_git
+    end
+
+    # Public: Configures the hook by calling the class' accessors.
+    #
+    # Returns nothing.
+    def self.configure
+      yield(self) if block_given?
+    end
+
+    def initialize(plugins_list = nil)
+      env           = prepare_env
+      @plugins      = []
+      @plugins_list = plugins_list
+      if self.class.plugins_dir
+        read_plugins_from_dir(self.class.plugins_dir, env)
+      end
+      if shared_plugins_dir_present?
+        read_plugins_from_dir(shared_plugins_dir, env)
+      end
+    end
+
+    # Public: Evaluates all plugins that are found in plugins_dir.
+    #
+    # If any plugin contains a test that returns false (means it fails)
+    # it displays the plugins failure messages and exits with code 1
+    #
+    def plugins_eval
+      raw_results = available_plugins.inject([]) do |result, plugin|
+        result << plugin.execute
+      end
+      @results = raw_results.select{ |result| result.is_a?(Hash) }
+      tests    = @results.map{ |result| result[:result] }
+      if tests.any?{ |test| not test }
+        message_on_failure
+        exit 1 unless ENV["PREGIT_ENV"] == "test"
+      else
+        message_on_success
+        exit 0 unless ENV["PREGIT_ENV"] == "test"
+      end
+    end
+
+    private
+
+    def available_plugins
+      @plugins.inject([]) do |result, item|
+        item.eval_plugin
+        result << item if @plugins_list.has?(item)
+        result
+      end
+    end
+
+    def prepare_env
+      env = Env.new
+      env[:project_dir] = self.class.project_dir
+      env
+    end
+
+    def message_on_success
+      puts defined_message_on(:success).green unless self.class.suppress_headline
+    end
+
+    def message_on_failure
+      unless self.class.suppress_headline
+        puts defined_message_on(:failure).red
+        puts "\n"
+        @results.select{|result| not result[:result] }.each do |result|
+          puts result[:message].red
+        end
+      end
+    end
+
+    def defined_message_on(type)
+      if self.class.send("headline_on_#{type}")
+        self.class.send("headline_on_#{type}")
+      else
+        default_messages[type]
+      end
+    end
+
+    def default_messages
+      {
+        success: "All tests passed. No reason to prevent the commit.",
+        failure: "Commit failed. See errors below."
+      }
+    end
+
+    def shared_plugins_dir_present?
+      File.exists?(shared_plugins_dir)
+    end
+
+    def shared_plugins_dir
+      File.join(self.class.plugins_dir, "..", "shared")
+    end
+
+    def read_plugins_from_dir(dir, env)
+      Dir["#{dir}/**/**.rb"].each do |plugin|
+        code = File.read(plugin)
+        @plugins << Plugin.new(code,env)
+      end
+    end
+
+  end
+
+end

data/lib/captain_hoog/templates/hoogfile.erb

@@ -0,0 +1,39 @@
+# This file will be created after installing.
+# It only includes
+#
+# * project_dir
+# * plugin_dir
+#
+# at the beginning (if they're provided during installation).
+
+# Exclude plugins you don't want to be executed within every
+# hook type. This has no effect in v1.x
+#
+# The name is taken from the plugin's name identifier.
+# exclude:
+# - cucumber
+# - log
+
+# Specify plugins you want to have executed within a pre-commit hook.
+# If no list is specfied, all plugins are executed (if the pre-commit
+# hook is installed).
+#
+# The name is taken from the plugin's name identifier.
+# pre-commit:
+#  - pry
+#  - rspec
+
+# Specify plugins you want to have executed within a pre-push hook.
+# If no list is specfied, all plugins are executed (if the pre-push
+# hook is installed).
+#
+# The name is taken from the plugin's name identifier.
+# pre-push:
+#  - mat
+
+# path in which the hooks should be executed. It's Git root by default.
+# This is going into env.
+project_dir: "<%= config[:project_dir] %>"
+# path to plugins
+# This is going into env.
+plugins_dir: "<%= config[:plugins_dir] %>"

data/lib/captain_hoog/templates/install.erb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'captain_hoog'
+require 'yaml'
+
+# read config
+hoog_config = YAML.load_file(File.join('<%= config[:root_dir] %>',
+                                       'hoogfile.yml'))
+
+# Adjust settings
+CaptainHoog::PreGit.configure do |config|
+  config.plugins_dir      = hoog_config['plugins_dir']
+  config.project_dir      = hoog_config['project_dir']
+  #config.headline_on_success = "All is fine."
+  #config.headline_on_failure = "Oops. Something went wrong"
+end
+
+plugin_list = CaptainHoog::PluginList.new('<%=config[:type] %>',
+                                          config: hoog_config)
+
+CaptainHoog::PreGit.run(plugins_list: plugin_list)

data/lib/captain_hoog/version.rb

@@ -0,0 +1,3 @@
+module CaptainHoog
+  VERSION = "1.0"
+end

data/lib/captain_hoog.rb

@@ -0,0 +1,14 @@
+require "captain_hoog/version"
+require "captain_hoog/dependencies"
+require "captain_hoog/errors"
+require "captain_hoog/delegatable"
+require "captain_hoog/helper_table"
+require "captain_hoog/env"
+require "captain_hoog/git"
+require "captain_hoog/plugin"
+require "captain_hoog/pre_git"
+require "captain_hoog/plugin_list"
+
+module CaptainHoog
+  # Your code goes here...
+end

data/spec/fixtures/code/helper.rb

@@ -0,0 +1,13 @@
+git.describe "helper" do |pre|
+  pre.helper :my_helper do
+    12
+  end
+
+  pre.test do
+    false
+  end
+
+  pre.message do
+    "It's #{my_helper}."
+  end
+end

data/spec/fixtures/plugins/shared/passing/simple_shared.rb

@@ -0,0 +1,11 @@
+git.describe "shared" do |pre|
+
+  pre.test do
+    true
+  end
+
+  pre.message do
+    "The shared test failed. Prevent you from doing anything."
+  end
+
+end

data/spec/fixtures/plugins/test_plugins/failing/simple.rb

@@ -0,0 +1,15 @@
+git.describe "foo" do |pre|
+
+  pre.helper :test_helper do
+    env.project_dir
+  end
+
+  pre.test do
+    false
+  end
+
+  pre.message do
+    "The test failed in #{test_helper}. Prevent you from doing anything."
+  end
+
+end

data/spec/fixtures/plugins/test_plugins/passing/simple.rb

@@ -0,0 +1,11 @@
+git.describe "simple" do |pre|
+
+  pre.test do
+    true
+  end
+
+  pre.message do
+    "The test failed. Prevent you from doing anything."
+  end
+
+end

data/spec/fixtures/pre-commit-fail

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'captain_hoog'
+
+plugins_path = File.expand_path(File.join(File.dirname(__FILE__),
+                                          "plugins",
+                                          "test_plugins",
+                                          "failing"))
+
+hoog_config = {
+  'exclude' => [],
+  'plugins_dir' => plugins_path,
+  'project_dir' => 'with_git',
+  'pre-commit' => ['foo']
+}
+
+plugin_list = CaptainHoog::PluginList.new('pre-commit',
+                                          config: hoog_config)
+
+# Adjust settings
+CaptainHoog::PreGit.configure do |config|
+  config.plugins_dir      = hoog_config['plugins_dir']
+  config.project_dir      = hoog_config['project_dir']
+end
+
+CaptainHoog::PreGit.run(plugins_list: plugin_list)

data/spec/fixtures/pre-commit-pass

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'captain_hoog'
+
+plugins_path = File.expand_path(File.join(File.dirname(__FILE__),
+                                          "plugins",
+                                          "test_plugins",
+                                          "passing"))
+
+hoog_config = {
+  'exclude' => [],
+  'plugins_dir' => plugins_path,
+  'project_dir' => 'with_git',
+  'pre-commit' => ['simple']
+}
+
+plugin_list = CaptainHoog::PluginList.new('pre-commit',
+                                          config: hoog_config)
+
+# Adjust settings
+CaptainHoog::PreGit.configure do |config|
+  config.plugins_dir      = hoog_config['plugins_dir']
+  config.project_dir      = hoog_config['project_dir']
+end
+
+CaptainHoog::PreGit.run(plugins_list: plugin_list)

data/spec/lib/captain_hoog/env_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe CaptainHoog::Env do
+
+  it "is inherits from Hash" do
+    expect(subject.class).to be_subclass_of(Hash)
+  end
+
+  describe "treats keys as methods" do
+
+    let(:env){ CaptainHoog::Env.new }
+
+    before do
+      env[:foo] = "bar"
+    end
+
+    it "raises not a NoMethodError" do
+      expect { env.foo }.to_not raise_error
+    end
+
+    it "responds to the key as method" do
+      expect(env).to respond_to(:foo)
+    end
+
+    it "returns the value for the key" do
+      expect(env.foo).to eq "bar"
+    end
+
+  end
+
+end