pre-commit 0.12.0 → 0.13.0

data/lib/pre-commit/checks/plugin.rb

@@ -0,0 +1,13 @@
+module PreCommit
+  module Checks
+    class Plugin
+      attr_accessor :pluginator, :config
+
+      def initialize(pluginator, config, list)
+        @pluginator = pluginator
+        @config     = config
+        @list       = list
+      end
+    end
+  end
+end

data/lib/pre-commit/cli.rb

@@ -1,4 +1,7 @@
 require 'fileutils'
+require 'pre-commit/configuration'
+require 'pre-commit/installer'
+require 'pre-commit/list_evaluator'
 
 module PreCommit
 
@@ -6,36 +9,60 @@ module PreCommit
 
   class Cli
 
-    PRE_COMMIT_HOOK_PATH = '.git/hooks/pre-commit'
-    TEMPLATE_DIR = File.expand_path("../support/templates/", __FILE__)
+    def initialize(*args)
+      @args = args
+    end
 
-    attr_reader :templates
+    def execute()
+      action_name = @args.shift or 'help'
+      action = "execute_#{action_name}".to_sym
+      if respond_to?(action)
+      then send(action, *@args)
+      else execute_help(action_name, *@args)
+      end
+    end
 
-    def initialize
-      @templates = load_templates
+    def execute_help(*args)
+      warn "Unknown parameters: #{args * " "}" unless args.empty?
+      warn "Usage: pre-commit install"
+      warn "Usage: pre-commit list"
+      warn "Usage: pre-commit plugins"
+      warn "Usage: pre-commit <enable|disbale> <git|yaml> <checks|warnings> check1 [check2...]"
+      args.empty? # return status, it's ok if user requested help
     end
 
-    def install(key = nil)
-      key ||= "default"
-      hook = templates[key.sub(/^--/, "")]
+    def execute_install(key = nil, *args)
+      PreCommit::Installer.new(key).install
+    end
 
-      raise TemplateNotFound.new("Could not find template #{key}") unless hook
+    def execute_list(*args)
+      puts list_evaluator.list
+      true
+    end
 
-      FileUtils.cp(hook, PRE_COMMIT_HOOK_PATH)
-      FileUtils.chmod(0755, PRE_COMMIT_HOOK_PATH)
+    def execute_plugins(*args)
+      puts list_evaluator.plugins
+      true
     end
 
-    private
+    def execute_enable(*args)
+      config.enable(*args)
+    rescue ArgumentError
+      execute_help('enable', *args)
+    end
 
-    def load_templates
-      pattern = File.join(TEMPLATE_DIR, "*_hook")
+    def execute_disable(*args)
+      config.disable(*args)
+    rescue ArgumentError
+      execute_help('disable', *args)
+    end
 
-      Dir.glob(pattern).inject({}) do |hash, file|
-        key = file.match(/\/([^\/]+?)_hook$/)[1]
-        hash[key] = file
+    def config
+      @config ||= PreCommit::Configuration.new(PreCommit.pluginator)
+    end
 
-        hash
-      end
+    def list_evaluator
+      @list_evaluator ||= PreCommit::ListEvaluator.new(config)
     end
 
   end

data/lib/pre-commit/configuration.rb

@@ -0,0 +1,54 @@
+require 'pluginator'
+require 'pre-commit/configuration/providers'
+require 'pre-commit/plugins_list'
+
+module PreCommit
+  class Configuration
+    attr_reader :pluginator, :providers
+
+    def initialize(pluginator, providers = nil)
+      @pluginator = (pluginator or PreCommit.pluginator)
+      @providers  = (providers  or Providers.new(@pluginator))
+    end
+
+    def get(name)
+      @providers[name.to_sym]
+    end
+
+    def get_arr(name)
+      value = get(name)
+      case value
+      when nil   then []
+      when Array then value
+      else raise PreCommit::NotAnArray.new
+      end
+    end
+
+    def get_combined(name)
+      get_arr(name) + get_arr("#{name}_add")
+    end
+
+    def enable(plugin_name, type, check1, *checks)
+      checks.unshift(check1) # check1 is ArgumentError triger
+      checks.map!(&:to_sym)
+      @providers.update( plugin_name, "#{type}_remove", :-, checks )
+      @providers.update( plugin_name, "#{type}_add",    :+, (checks or []) - (@providers.default(type) or []) )
+      true
+    rescue PreCommit::PluginNotFound => e
+      $stderr.puts e
+      false
+    end
+
+    def disable(plugin_name, type, check1, *checks)
+      checks.unshift(check1) # check1 is ArgumentError triger
+      checks.map!(&:to_sym)
+      @providers.update( plugin_name, "#{type}_add",    :-, checks )
+      @providers.update( plugin_name, "#{type}_remove", :+, checks )
+      true
+    rescue PreCommit::PluginNotFound => e
+      warn e
+      false
+    end
+
+  end
+end

data/lib/pre-commit/configuration/providers.rb

@@ -0,0 +1,53 @@
+require 'plugins/pluginator/extensions/conversions'
+
+module PreCommit
+  class NotAnArray < StandardError
+  end
+
+  class PluginNotFound < StandardError
+  end
+
+  class Configuration
+    class Providers
+      include Pluginator::Extensions::Conversions
+
+      def initialize(pluginator, plugins = nil)
+        @pluginator = pluginator
+        @plugins    = plugins
+      end
+
+      def [](name)
+        plugins.map{|plugin| plugin[name] }.compact.last
+      end
+
+      def default(name)
+        plugins[0][name]
+      end
+
+      def update(plugin_name, name, operation, list)
+        plugin = find_update_plugin(plugin_name)
+        name   = name.to_sym
+        value = plugin[name] || []
+        raise PreCommit::NotAnArray.new unless Array === value
+        value = value.send(operation, list)
+        plugin.update(name, value)
+      end
+
+      def list
+        plugins.map{|plugin| "#{class2string(class2name(plugin.class))}(#{plugin.class.priority})" }
+      end
+
+    private
+      def plugins
+        @plugins ||= @pluginator['configuration/providers'].sort_by(&:priority).map(&:new)
+      end
+
+      def find_update_plugin(plugin_name)
+        plugin = plugins.detect{|plugin| class2string(class2name(plugin.class)) == plugin_name.to_s}
+        raise PluginNotFound.new("Plugin not found for #{plugin_name}.") unless plugin
+        plugin
+      end
+
+    end
+  end
+end

data/lib/pre-commit/installer.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require 'pre-commit/configuration'
+
+module PreCommit
+
+  class Installer
+
+    TARGET_HOOK_PATH = '.git/hooks/pre-commit'
+    TEMPLATE_DIR = File.expand_path("../../../templates/hooks/", __FILE__)
+
+    attr_reader :key
+
+    def initialize(key = nil)
+      @key = key || "default"
+    end
+
+    def hook
+      templates[key.sub(/^--/, "")]
+    end
+
+    def target
+      TARGET_HOOK_PATH
+    end
+
+    def install
+      if
+        hook
+      then
+        FileUtils.cp(hook, target)
+        FileUtils.chmod(0755, target)
+        puts "Installed #{hook} to #{target}"
+        true
+      else
+        warn "Could not find template #{key}"
+        false
+      end
+    end
+
+  private
+
+    def templates
+      return @templates if @templates
+      pattern = File.join(TEMPLATE_DIR, "*")
+
+      @templates =
+      Dir.glob(pattern).inject({}) do |hash, file|
+        key = file.match(/\/([^\/]+?)$/)[1]
+        hash[key] = file
+        hash
+      end
+    end
+
+  end
+end

data/lib/pre-commit/list_evaluator.rb

@@ -0,0 +1,85 @@
+require 'pluginator'
+require 'pre-commit/configuration'
+require 'plugins/pluginator/extensions/conversions'
+require 'pre-commit/plugins_list'
+
+module PreCommit
+  class ListEvaluator
+    include Pluginator::Extensions::Conversions
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def list
+      <<-DATA
+Available providers: #{config.providers.list.join(" ")}
+Available checks   : #{plugin_names.join(" ")}
+Default   checks   : #{config.get_arr(:checks).join(" ")}
+Enabled   checks   : #{checks_config.join(" ")}
+Evaluated checks   : #{checks_evaluated.join(" ")}
+Default   warnings : #{config.get_arr(:warnings).join(" ")}
+Enabled   warnings : #{warnings_config.join(" ")}
+Evaluated warnings : #{warnings_evaluated.join(" ")}
+DATA
+    end
+
+    def plugins
+      list = config.pluginator['checks'].map{|plugin| [class2string(class2name(plugin)), plugin] }.sort
+      separator = list.map{|name, plugin| name.length }.max
+      list.map{ |name, plugin| format_plugin(name, separator, plugin) }.flatten
+    end
+
+    def checks_config
+      get_combined_checks - get_arr_checks_remove
+    end
+
+    def checks_evaluated(type = :evaluated_names)
+      PreCommit::PluginsList.new(get_combined_checks, get_arr_checks_remove) do |name|
+        config.pluginator.find_check(name)
+      end.send(type)
+    end
+
+    def warnings_config
+      get_combined_warnings - get_arr_warnings_remove
+    end
+
+    def warnings_evaluated(type = :evaluated_names)
+      PreCommit::PluginsList.new(get_combined_warnings, get_arr_warnings_remove) do |name|
+        config.pluginator.find_check(name)
+      end.send(type)
+    end
+
+  private
+
+    def plugin_names
+      config.pluginator['checks'].map{|plugin| class2string(class2name(plugin)) }.sort
+    end
+
+    def format_plugin(name, separator, plugin)
+      line = [sprintf("%#{separator}s : %s", name, plugin.description)]
+      line << sprintf("%#{separator}s - includes: %s", "", plugin.includes.join(" ")) if plugin.respond_to?(:includes)
+      line << sprintf("%#{separator}s - excludes: %s", "", plugin.excludes.join(" ")) if plugin.respond_to?(:excludes)
+      line
+    end
+
+    def get_combined_checks
+      @get_combined_checks     ||= config.get_combined(:checks)
+    end
+
+    def get_arr_checks_remove
+      @get_arr_checks_remove   ||= config.get_arr("checks_remove")
+    end
+
+    def get_combined_warnings
+      @get_combined_warnings   ||= config.get_combined(:warnings)
+    end
+
+    def get_arr_warnings_remove
+      @get_arr_warnings_remove ||= config.get_arr("warnings_remove")
+    end
+
+  end
+end

data/lib/pre-commit/plugins_list.rb

@@ -0,0 +1,87 @@
+module PreCommit
+
+  def self.pluginator
+    Pluginator.find('pre_commit', :extends => [:find_check])
+  end
+
+  class PluginsList
+    attr_reader :configured_names, :configured_remove
+
+    def initialize(configured_names, configured_remove, &block)
+      @configured_names  = configured_names
+      @configured_remove = configured_remove
+      @class_finder      = block
+    end
+
+    def evaluated_names
+      evaluated_names_(evaluated_names_pairs).flatten.compact
+    end
+
+    def list_to_run
+      list_to_run_(evaluated_names_pairs).flatten.compact
+    end
+
+  private
+
+    def evaluated_names_(list)
+      list.map{|name, klass, includes| [name] + evaluated_names_(includes||[]) }
+    end
+
+    def list_to_run_(list)
+      list.map{|name, klass, includes| [klass] + list_to_run_(includes||[]) }
+    end
+
+    def evaluated_names_pairs
+      list = find_classes_and_includes(configured_names)
+      excludes = excludes(list).flatten.compact
+      list = filter_excludes(list, excludes)
+      list = filter_excludes(list, configured_remove_aliases)
+      list = filter_callable(list)
+      list
+    end
+
+    def find_classes_and_includes(list)
+      find_classes(list).map{ |name, klass| class_and_includes(name, klass) }
+    end
+
+    def find_class(name)
+      @class_finder.call(name)
+    end
+
+    def find_classes(list)
+      list.map{|name| [name, find_class(name)] }.reject{|name, klass| klass.nil? }
+    end
+
+    def class_and_includes(name, klass)
+      [ name, klass, klass.respond_to?(:includes) ? find_classes_and_includes(klass.includes) : [] ]
+    end
+
+    def excludes(list)
+      list.map{|name, klass, includes| class_excludes(klass) + excludes(includes) }
+    end
+
+    def class_excludes(klass)
+      klass.respond_to?(:excludes) ? klass.excludes : []
+    end
+
+    def filter_excludes(list, excludes)
+      list.map{|name, klass, includes| excludes.include?(name) ? nil : [name, klass, filter_excludes(includes, excludes)] }.compact
+    end
+
+    def filter_callable(list)
+      list.map{|name, klass, includes|
+        (klass.instance_methods.include?(:call) ? [name, klass] : [nil, nil]) << filter_callable(includes)
+      }.compact
+    end
+
+    def configured_remove_aliases
+      @configured_remove_aliases ||= configured_remove.map{|remove|
+        list = [remove]
+        klass = find_class(remove)
+        list += klass.aliases if klass.respond_to?(:aliases)
+        list
+      }.flatten.compact
+    end
+
+  end
+end

data/lib/pre-commit/runner.rb

@@ -1,20 +1,65 @@
+require 'pluginator'
+require 'pre-commit/utils/staged_files'
+require 'pre-commit/configuration'
+require 'pre-commit/list_evaluator'
+
 module PreCommit
   class Runner
+    include PreCommit::Utils::StagedFiles
 
-    def run
-      checks_to_run = PreCommit.checks_to_run
+    attr_reader :pluginator, :config
 
-      all_passed = checks_to_run.inject(true) do |current_status, check|
-        passed = check.call
+    def initialize(stderr = nil, staged_files = nil, config = nil, pluginator = nil)
+      @stderr       = (stderr       or $stderr)
+      @pluginator   = (pluginator   or PreCommit.pluginator)
+      @config       = (config       or PreCommit::Configuration.new(@pluginator))
+      @staged_files = staged_files
+    end
 
-        if !passed && check.respond_to?(:error_message)
-          puts check.error_message
-        end
+    def run
+      run_single(:warnings)
+      run_single(:checks  ) or return false
+      true
+    end
 
-        check && current_status
+    def run_single(name)
+      show_output(name, execute(list_to_run(name)))
+    end
+
+    def show_output(name, list)
+      if list.any?
+        @stderr.puts send(name, list)
+        return false
       end
+      true
+    end
+
+    def execute(list)
+      list.map{|cmd| cmd.new(pluginator, config, list).call(staged_files.dup) }.compact
+    end
+
+    def list_to_run(name)
+      list_evaluator.send(:"#{name}_evaluated", :list_to_run)
+    end
+
+    def list_evaluator
+      @list_evaluator ||= PreCommit::ListEvaluator.new(config)
+    end
+
+    def warnings(list)
+      <<-WARNINGS
+pre-commit: Some warnings were raised. These will not stop commit:
+#{list.join("\n")}
+WARNINGS
+    end
+
+    def checks(list)
+      <<-ERRORS
+pre-commit: Stopping commit because of errors.
+#{list.join("\n")}
+pre-commit: You can bypass this check using `git commit -n`
 
-      exit(all_passed ? 0 : 1)
+ERRORS
     end
 
   end