kamaze-project 1.0.0

data/lib/kamaze/project/tools/git/status/files_array.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'
+
+# Initialized using an Array representation of status
+#
+# A memento is kept.
+# Given files are filtered by type.
+#
+# @abstract
+class Kamaze::Project::Tools::Git::Status::FilesArray < Array
+  class << self
+    # Get type
+    #
+    # @return [Symbol]
+    attr_reader :type
+  end
+
+  # Initialize using given status array representation
+  #
+  # @param [Array] status
+  def initialize(status)
+    super status.clone
+                .keep_if { |file| file.public_send("#{self.class.type}?") }
+
+    @memento = status.clone.map(&:freeze).freeze
+  end
+
+  protected
+
+  # @return [Array]
+  attr_reader :memento
+end

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

@@ -0,0 +1,77 @@
+# 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 'files_array'
+require_relative 'worktree'
+
+# rubocop:disable Style/Documentation
+
+class Kamaze::Project::Tools::Git::Status
+  class Index < FilesArray
+    @type = :index
+  end
+end
+
+# rubocop:enable Style/Documentation
+
+# Represent index status
+class Kamaze::Project::Tools::Git::Status::Index
+  # Denote index is safe
+  #
+  # Unsafe index shares modifications with the worktree,
+  # thus, files SHOULD NOT be naively analyzed,
+  # for example, by running a static code analysis.
+  # Running a static code analysis on unsafe index files
+  # COULD lead to inconsistent results.
+  #
+  # @return [Boolean]
+  def safe?
+    unsafe_files.empty?
+  end
+
+  # @return [Boolean]
+  def unsafe?
+    !safe?
+  end
+
+  # Get present files in intersection between index and worktree
+  #
+  # @return [Array<File>]
+  def unsafe_files
+    c = [self, worktree].map do |a|
+      a.map { |f| f.absolute_path.to_s }
+    end.freeze
+
+    self.to_a.keep_if do |f|
+      (c[0] & c[1]).include?(f.absolute_path.to_s)
+    end
+  end
+
+  # Get files present in index and considered as safe
+  #
+  # Safe files SHOULD NOT present divergent modifications
+  # between index and worktree. As seen in ``unsafe_files`` only
+  # the modified state is considered.
+  def safe_files
+    unsafe = self.unsafe_files.map { |f| f.absolute_path.to_s }
+
+    self.to_a
+        .reject { |f| unsafe.include?(f.absolute_path.to_s) }
+  end
+
+  protected
+
+  # Get a fresh (not frozen) copy of worktree as seen on initialization
+  #
+  # @return [Kamaze::Project::Tools::Git::Status::Worktree]
+  def worktree
+    memo = Array.new(memento)
+
+    Kamaze::Project::Tools::Git::Status::Worktree.new(memo)
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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 'files_array'
+
+class Kamaze::Project::Tools::Git::Status
+  class Worktree < FilesArray
+  end
+end
+
+# Represent worktree status
+class Kamaze::Project::Tools::Git::Status::Worktree
+  @type = :worktree
+end

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

@@ -0,0 +1,35 @@
+# 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'
+
+# Provide base class for utils based on git
+#
+# Provide access to the repository
+# @see http://www.rubydoc.info/github/libgit2/rugged/Rugged/Repository
+#
+# @abstract
+class Kamaze::Project::Tools::Git::Util
+  attr_reader :repository
+
+  # @param [Rugged::Repository] repository
+  def initialize(repository)
+    @repository = repository
+
+    setup
+  end
+
+  protected
+
+  # Setup
+  #
+  # Almost used for inheritance
+  def setup
+    nil
+  end
+end

data/lib/kamaze/project/tools/licenser.rb

@@ -0,0 +1,197 @@
+# 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 '../tools'
+
+# Apply provided license on project files
+#
+# Samples of use:
+#
+# ```ruby
+# Licenser.process do |pr|
+#    pr.license  = project.version.license_header
+#    pr.patterns = ['bin/*', 'lib/**/**.rb']
+# end
+# ```
+#
+# ```ruby
+# Licenser.process do |pr|
+#     pr.files += Dir.glob('bin/*')
+# end
+# ```
+#
+# Sample of use (with DSL):
+#
+# ```ruby
+# require 'kamaze/project/dsl'
+# require 'kamaze/project/tools/licenser'
+#
+# project do |c|
+#   c.working_dir = "#{__dir__}/.."
+#   c.subject = Kamaze::Project
+#   c.name = 'kamaze-project'
+#   c.tasks = []
+# end
+#
+# version = project.subject.const_get('VERSION')
+# licenser = Kamaze::Project::Tools::Licenser.process do |process|
+#   process.working_dir = project.working_dir
+#   process.license     = project.version.license_header
+#   process.patterns    = ['bin/*', 'lib/**/**.rb']
+#   process.output      = STDOUT
+# end
+# ```
+class Kamaze::Project::Tools::Licenser < Kamaze::Project::Tools::BaseTool
+  # License chapter/header
+  #
+  # @return [String]
+  attr_writer :license
+
+  # Files to be licensed
+  #
+  # @type [Array<String|Pathname>]
+  # @return [Array<Pathname>]
+  attr_writer :files
+
+  # Patterns used to match files
+  #
+  # @return [Array<String>]
+  attr_reader   :patterns
+
+  # Where (default is current opened file) to write output
+  #
+  # @return [Pathname|IO|nil]
+  attr_accessor :output
+
+  # @type [String|Pathname]
+  # @return [Pathname]
+  attr_writer :working_dir
+
+  class << self
+    def process(&block)
+      self.new.process(&block)
+    end
+  end
+
+  def initialize
+    yield self if block_given?
+
+    @working_dir ||= Dir.pwd
+    @patterns    ||= []
+    @files       ||= []
+    @license     ||= '' # project.version.license_header
+  end
+
+  # Get working-dir
+  #
+  # @return [Pathname]
+  def working_dir
+    Pathname.new(@working_dir || Dir.pwd).freeze
+  end
+
+  # Set patterns
+  #
+  # @param [Array<String>] patterns
+  def patterns=(patterns)
+    @files    ||= []
+    @patterns ||= []
+
+    patterns.each do |pattern|
+      @files += Dir.glob(working_dir.join(pattern))
+    end
+
+    @patterns += patterns
+  end
+
+  # Get files
+  #
+  # @return [Array<Pathname>]
+  def files
+    @files.map { |file| Pathname.new(file) }
+          .delete_if { |file| !file.file? }
+          .delete_if { |file| file.basename.to_s[0] == '.' }
+          .sort.uniq
+          .map(&:realpath)
+  end
+
+  # Get license, formatted (using comments)
+  #
+  # @return [String]
+  def license
+    @license.to_s.gsub(/\n{3}/mi, "\n\n").lines.map do |line|
+      line.chomp!
+      "# #{line}" if line and line[0] != '#'
+    end.join("\n")
+  end
+
+  # Get license regexp
+  #
+  # @return [Regexp]
+  def license_regexp
+    /#{Regexp.quote(license)}/mi
+  end
+
+  # Apply license on processable files
+  #
+  # @return [self]
+  def process
+    yield self if block_given?
+
+    files.each { |file| apply_license(file) }
+
+    self
+  end
+
+  protected
+
+  # Get an index, skipping comments
+  #
+  # @param [Array<String>] lines
+  # @return [Fixnum]
+  def index_lines(lines)
+    index = 0
+    loop do
+      break unless lines[index] and lines[index][0] == '#'
+
+      index += 1
+    end
+
+    index
+  end
+
+  # Apply license on a file
+  #
+  # @param [Pathname] file
+  # @return [Pathname] file
+  def apply_license(file)
+    content    = file.read
+    licensable = !content.scan(license_regexp)[0] and !license.strip.empty?
+    output     = self.output || file
+
+    if licensable
+      content = license_lines(content.lines).join('')
+
+      output.write(content)
+    end
+
+    file
+  end
+
+  # Apply license on lines
+  #
+  # @param [Array<String>] lines
+  # @return [Array<String>] with license applied
+  def license_lines(lines)
+    index = index_lines(lines)
+    lines = lines.clone
+
+    return lines if index <= 0
+
+    lines[0..index] + license.lines + ["\n"] + lines[index..-1]
+  end
+end

data/lib/kamaze/project/tools/packager.rb

@@ -0,0 +1,86 @@
+# 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 '../tools'
+require_relative 'base_tool'
+
+# rubocop:disable Style/Documentation
+
+module Kamaze::Project::Tools
+  class Packager < BaseTool
+    class Filesystem
+      class Operator
+        module Utils
+        end
+      end
+    end
+
+    require_relative 'packager/filesystem'
+    require_relative 'packager/filesystem/operator'
+    require_relative 'packager/filesystem/operator/utils'
+  end
+end
+
+# rubocop:enable Style/Documentation
+
+# Provides a packager
+#
+# Packager is intended to provide basic packaging operations
+# @abstract
+class Kamaze::Project::Tools::Packager
+  # Get filesystem
+  #
+  # @return [Kamaze::Project::Tools::Packager::Filesystem]
+  attr_reader :fs
+
+  def initialize
+    @initialized = false
+    # fs mutable attributes are accessibles during initialization
+    # @see method_missing
+    @fs = Filesystem.new
+
+    yield self if block_given?
+
+    super
+
+    @initialized = true
+  end
+
+  # Denote class is initialized
+  #
+  # @return [Boolean]
+  def initialized?
+    @initialized
+  end
+
+  def method_missing(method, *args, &block)
+    if respond_to_missing?(method)
+      unless initialized?
+        mutable = fs.mutable_attribute?(method)
+
+        return fs.__send__(method, *args, &block) if mutable
+      end
+
+      return fs.public_send(method, *args, &block)
+    end
+
+    super
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    if method.to_s[-1] == '='
+      unless initialized?
+        return true if fs.mutable_attribute?(method)
+      end
+    end
+
+    return true if fs.respond_to?(method, include_private)
+
+    super(method, include_private)
+  end
+end