kamaze-project 1.0.0

data/lib/kamaze/project/tools/git/hooks.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../git'
+require_relative 'hooks/base_hook'
+require 'kamaze/project/concern/helper'
+
+# Provide hooks
+#
+# Kind of factory registering and building hooks
+class Kamaze::Project::Tools::Git::Hooks
+  class << self
+    include Kamaze::Project::Concern::Helper
+
+    attr_reader :registered_hooks
+
+    def register(name, klass = nil)
+      klass ||= proc do
+        cname = helper.get(:inflector).classify(name.to_s)
+
+        require_relative "hooks/#{name}"
+
+        helper.get(:inflector).constantize("#{self.name}::#{cname}")
+      end.call
+
+      @registered_hooks ||= {}
+      @registered_hooks[name] = klass
+      self
+    end
+  end
+
+  @registered_hooks = {}
+
+  # @param [Kamaze::Project::Tools::Git] repository
+  def initialize(repository)
+    @hooks = {}
+    @repository = repository
+
+    [:pre_commit].each { |n| self.class.register(n) }
+
+    self.class
+        .registered_hooks
+        .each { |name, klass| @hooks[name] = klass.new(repository) }
+  end
+
+  # @return [Hash]
+  def to_h
+    @hooks.freeze
+  end
+
+  # @param [Symbol] key
+  # @return [nil|Array<Hook>]
+  def [](key)
+    to_h[key]
+  end
+
+  protected
+
+  # @return [Kamaze::Project::Tools::Git]
+  attr_reader :repository
+end

data/lib/kamaze/project/tools/git/hooks/base_hook.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../hooks'
+require_relative '../../../concern/cli/with_exit_on_failure'
+
+# rubocop:disable Style/Documentation
+
+class Kamaze::Project::Tools::Git::Hooks
+  class BaseHook
+    include Kamaze::Project::Concern::Cli::WithExitOnFailure
+  end
+end
+
+# rubocop:enable Style/Documentation
+
+# Base Hook
+class Kamaze::Project::Tools::Git::Hooks::BaseHook
+  # @param [Kamaze::Project::Tools::Git] repository
+  def initialize(repository)
+    @repository = repository
+  end
+
+  protected
+
+  # @return [Kamaze::Project::Tools::Git]
+  attr_reader :repository
+end

data/lib/kamaze/project/tools/git/hooks/pre_commit.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../hooks'
+require_relative 'base_hook'
+
+class Kamaze::Project::Tools::Git::Hooks
+  class PreCommit < BaseHook
+  end
+end
+
+# PreCommit hook
+#
+# Provide helper methods intended to write hooks relating to pre-commit
+#
+# Sample of use:
+#
+# ```ruby
+# retcode = tools.fetch(:git).hooks[:pre_commit].process_index do |files|
+#   tools.fetch(:rubocop).prepare do |c|
+#     c.patterns = files.reject(&:deleted?).map(&:to_s)
+#   end.run
+#
+#   exit(retcode) unless retcode.zero?
+# end
+# ```
+class Kamaze::Project::Tools::Git::Hooks::PreCommit
+  # Process index (files)
+  #
+  # Exits with a status code, raising ``SystemExit``.
+  #
+  # | code    | constant              | reason          |
+  # |---------|-----------------------|-----------------|
+  # | ``125`` | ``Errno::ECANCELED``  | Index is empty  |
+  # | ``95``  | ``Errno::EOPNOTSUPP`` | Index is unsafe |
+  # | ``0``   | ``Errno::NOERROR``    | Success         |
+  #
+  # @param [Hash] options
+  # @option options [Boolean] :allow_unsafe
+  #     Unsafe index is processed (``false``)
+  # @option options [Boolean] :allow_empty
+  #     Empty index is processed (``false``)
+  # @yield [Array<Kamaze::Project::Tools::Git::Status::File>]
+  # @yieldreturn [Fixnum]
+  # @raise [SystemExit]
+  #
+  # ``:allow_empty`` and ``:allow_unsafe`` options are available,
+  # to continue processing even if ``empty`` or ``unsafe``.
+  def process_index(options = {})
+    index = _process_index(repository.status.index, options)
+    self.retcode = Errno::NOERROR::Errno
+
+    yield(index.to_a.freeze) if block_given?
+  end
+
+  protected
+
+  # @param [Kamaze::Project::Tools::Git::Status::Index] index
+  # @param [Hash] options
+  # @raise [SystemExit]
+  #
+  # @return [Kamaze::Project::Tools::Git::Status::Index]
+  def _process_index(index, options = {})
+    { empty: Errno::ECANCELED, unsafe: Errno::EOPNOTSUPP }.each do |type, v|
+      with_exit_on_failure do
+        key = "allow_#{type}".to_sym
+        options[key] = options.keys.include?(key) ? !!options[key] : false
+
+        next if options[key]
+        self.retcode = v.const_get(:Errno) if index.public_send("#{type}?")
+      end
+    end
+
+    index
+  end
+end

data/lib/kamaze/project/tools/git/status.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../git'
+require_relative 'status/file'
+require_relative 'status/index'
+require_relative 'status/worktree'
+require_relative 'status/decorator'
+require 'pathname'
+
+# Provide status
+#
+# Status can provide different kind of file lists, as seen by ``libgit``.
+#
+# ``index`` and ``worktree`` are directly provided throuh ``status``,
+# but files can also been easily discriminated by status.
+#
+# @see Kamaze::Project::Tools::Git::Status::File
+class Kamaze::Project::Tools::Git::Status
+  # @return [Pathname]
+  attr_reader :base_dir
+
+  # @param [Hash{String => Array<Symbol>}] status
+  # @param [String] base_dir
+  def initialize(status, base_dir = Dir.pwd)
+    @base_dir = ::Pathname.new(base_dir)
+    @status = status.clone
+    @cached = nil
+  end
+
+  # @return [Decorator]
+  def decorate
+    Decorator.new(self)
+  end
+
+  # @return [String]
+  def to_s
+    decorate.to_s
+  end
+
+  # Empty cache
+  #
+  # @return [self]
+  def refresh!
+    @cached = nil
+
+    self
+  end
+
+  # Get index
+  #
+  # @return [Index]
+  def index
+    Index.new(self.to_a)
+  end
+
+  # Get worktree
+  #
+  # @return [Worktree]
+  def worktree
+    Worktree.new(self.to_a)
+  end
+
+  # @return [Array<File>]
+  def to_a
+    cached.to_a.map { |v| File.new(v.fetch(0), v.fetch(1), base_dir) }
+  end
+
+  protected
+
+  # Get cached filepaths
+  #
+  # @return [Hash]
+  def cached
+    @cached ||= prepared
+
+    @cached
+  end
+
+  # Get prepared filepaths with symbols (states)
+  #
+  # @return [Hash{String => Hash{Symbol => Symbol}}]
+  def prepared
+    output = {}
+    @status.each do |file, status_data|
+      status_data.each do |status|
+        status = status.to_s.split('_').map(&:to_sym)
+        flags = { status[0] => status[1] || status[0] }
+
+        output[file] = (output[file] || {}).merge(flags)
+      end
+    end
+
+    output
+  end
+end

data/lib/kamaze/project/tools/git/status/decorator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../status'
+
+# Provide decoration for status
+#
+# Result of ``to_s``, SHOULD be similar to result obtained with:
+#
+# ```sh
+# git status -z | sed "s/\x0/\n/g"
+# ```
+class Kamaze::Project::Tools::Git::Status::Decorator
+  # @param [Kamaze::Project::Tools::Git::Status] status
+  def initialize(status)
+    @status = status
+  end
+
+  def files
+    files = [status.index.to_a, status.worktree.to_a].flatten.sort_by(&:to_s)
+
+    files.reject(&:untracked?)
+         .concat(files.keep_if(&:untracked?))
+  end
+
+  def to_s
+    files.map { |file| "#{file.status} #{file}" }.uniq.join("\n")
+  end
+
+  protected
+
+  # @return [Kamaze::Project::Tools::Git::Status]
+  attr_reader :status
+end

data/lib/kamaze/project/tools/git/status/file.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../status'
+require 'pathname'
+
+# Status file
+#
+# Describe a file as seen in status,
+# file is described by path and flags, and is immutable by design.
+#
+# @see http://www.rubydoc.info/github/libgit2/rugged/Rugged%2FRepository%3Astatus
+class Kamaze::Project::Tools::Git::Status::File
+  # @return [Pathname]
+  attr_reader :base_dir
+
+  # @return [Pathname]
+  attr_reader :path
+
+  # @return [String]
+  attr_reader :flags
+
+  # @param [Pathname|String] path
+  # @param [Hash] flags
+  # @param [Pathname|String] base_dir
+  def initialize(path, flags, base_dir = Dir.pwd)
+    @base_dir = ::Pathname.new(base_dir).freeze
+    @path = ::Pathname.new(path).freeze
+    @flags = flags.freeze
+  end
+
+  # @return [String]
+  def to_s
+    path.to_s
+  end
+
+  # Get a status string, composed of two chars
+  #
+  # @see https://git-scm.com/docs/git-status
+  # @return [String]
+  def status
+    return '??' if untracked?
+    states = [' ', ' ']
+    mapping = { new: 'A', modified: 'M', deleted: 'D' }
+    { index: 0, worktree: 1 }.each do |from, index|
+      next unless self.public_send("#{from}?")
+
+      mapping.each do |flag, s|
+        states[index] = s if self.public_send("#{from}_#{flag}?")
+      end
+    end
+
+    states.join
+  end
+
+  # @return [Boolean]
+  def ==(other)
+    return false unless comparable_with?(other)
+
+    [[self.path.to_s, other.path.to_s],
+     [self.base_dir.to_s, other.base_dir.to_s],
+     [self.flags.sort, other.flags.sort]].each do |c|
+      return false unless c[0] == c[1]
+    end
+
+    true
+  end
+
+  # Denote instance is comparable with another object
+  #
+  # @param [Object] other
+  # @return [Boolean]
+  def comparable_to?(other)
+    [:flags, :path, :base_dir]
+      .map { |m| other.respond_to?(m) }.uniq == [true]
+  end
+
+  # Get absolute path
+  #
+  # @return [Pathname]
+  def absolute_path
+    base_dir.join(path)
+  end
+
+  # Denote ignored
+  #
+  # @return [Boolean]
+  def ignored?
+    flags.keys.include?(:ignored)
+  end
+
+  # Denote worktree
+  #
+  # @return [Boolean]
+  def worktree?
+    flags.keys.include?(:worktree)
+  end
+
+  # Denote index
+  #
+  # @return [Boolean]
+  def index?
+    flags.keys.include?(:index)
+  end
+
+  # Denote new
+  #
+  # @return [Boolean]
+  def new?
+    flags.values.include?(:new)
+  end
+
+  # Denote modified
+  #
+  # @return [Boolean]
+  def modified?
+    flags.values.include?(:modified)
+  end
+
+  # Denote deleted
+  #
+  # @return [Boolean]
+  def deleted?
+    flags.values.include?(:deleted)
+  end
+
+  # Denote untracked
+  #
+  # @return [Boolean]
+  def untracked?
+    worktree? and new? and !index?
+  end
+
+  # Denote new in index
+  #
+  # @return [Boolean]
+  def index_new?
+    index? and new?
+  end
+
+  # Denote modified in index
+  #
+  # @return [Boolean]
+  def index_modified?
+    index? and modified?
+  end
+
+  # Denote deleted in index
+  #
+  # @return [Boolean]
+  def index_deleted?
+    index? and deleted?
+  end
+
+  # Denote new in worktree
+  #
+  # @return [Boolean]
+  def worktree_new?
+    worktree? and new?
+  end
+
+  # Denote modified in worktree
+  #
+  # @return [Boolean]
+  def worktree_modified?
+    worktree? and modified?
+  end
+
+  # Denote deleted in worktree
+  #
+  # @return [Boolean]
+  def worktree_deleted?
+    worktree? and deleted?
+  end
+end