kamaze-project 1.0.0

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

@@ -0,0 +1,178 @@
+# 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 '../packager'
+require_relative 'filesystem/operator'
+require 'pathname'
+
+# Filesystem description used during packaging
+#
+# Filesystem has an Operator, which is intended to manipulate
+# described files and directories.
+# Package has a name, see ``package_name``,
+# package name SHOULD be constitued with two (_path_) parts.
+# Package dirs are labeled, as a default, only ``:src`` is provided.
+# Labels are used to constitute the complete directory path
+# (relative to ``pwd``).
+class Kamaze::Project::Tools::Packager::Filesystem
+  # Package dir (root directory)
+  #
+  # Relative to current pwd
+  #
+  # @type [String]
+  attr_writer :package_basedir
+
+  # Working directory
+  #
+  # @type [String]
+  attr_writer :working_dir
+
+  # @type [Array<String|Pathname>]
+  attr_writer :source_files
+
+  # Name given to the package
+  #
+  # @type [String]
+  attr_accessor :package_name
+
+  # Labels for packaging stages
+  #
+  # @type [Array<Symbol>]
+  attr_writer :package_labels
+
+  # Labels for purgeables dirs (during prepare)
+  #
+  # @type [Array<Symbol>]
+  attr_writer :purgeables
+
+  # @type [Boolean]
+  attr_writer :verbose
+
+  def initialize
+    @package_basedir = 'build'
+    @package_name    = 'sample/package'
+
+    @working_dir     = Dir.pwd
+    @package_labels  = [:src]
+
+    @verbose         = true
+    @operator        = self.operator
+
+    yield self if block_given?
+
+    @source_files ||= []
+    @purgeables   ||= []
+
+    mute_attributes!(mutable_attributes)
+  end
+
+  # Get packaging dir (root directory)
+  #
+  # @return [Pathname]
+  def package_basedir
+    ::Pathname.new(@package_basedir)
+  end
+
+  # Get package dir identified by its name
+  #
+  # @return [Pathname]
+  def package_dir
+    package_basedir.join(package_name)
+  end
+
+  # Get (named) paths (as: src, tmp and bin)
+  #
+  # @return [Hash]
+  def package_dirs
+    @package_labels.map do |k|
+      [k, package_dir.join(k.to_s)]
+    end.to_h
+  end
+
+  # Get purgeable (named) paths
+  #
+  # @return [Hash]
+  def purgeable_dirs
+    @purgeables.map do |k|
+      [k, package_dirs[k]] if package_dirs[k]
+    end.to_h
+  end
+
+  # Get (original) working dir
+  #
+  # @return [Pathname]
+  def working_dir
+    ::Pathname.new(@working_dir)
+  end
+
+  alias pwd working_dir
+
+  # Get source files
+  #
+  # @return [Array<Pathname>]
+  def source_files
+    @source_files.sort.map { |path| ::Pathname.new(path) }
+  end
+
+  def method_missing(method, *args, &block)
+    if respond_to_missing?(method)
+      operator.public_send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    return true if operator.respond_to?(method, include_private)
+
+    super(method, include_private)
+  end
+
+  def mutable_attributes
+    [
+      :verbose,
+      :purgeables,
+      :working_dir,
+      :source_files,
+      :package_basedir,
+      :package_name,
+      :package_labels
+    ].sort
+  end
+
+  def mutable_attribute?(attr)
+    attr = attr.to_s.gsub(/=$?/, '').to_sym
+
+    mutable_attributes.include?(attr)
+  end
+
+  protected
+
+  # @return [Boolean]
+  attr_reader :verbose
+
+  # Get operator
+  #
+  # @return [Kamaze::Project::Tools::Packager::Filesystem::Operator]
+  def operator
+    const_class = self.class.const_get(:Operator)
+
+    const_class.new(self, verbose: verbose)
+  end
+
+  # Pass some attributes to protected
+  #
+  # @return [self]
+  def mute_attributes!(attributes)
+    attributes.each do |m|
+      self.singleton_class.class_eval { protected "#{m}=" }
+    end
+
+    self
+  end
+end

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

@@ -0,0 +1,83 @@
+# 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 'pathname'
+require_relative '../filesystem'
+require_relative 'operator/utils'
+
+# Filesystem operator (manipulator)
+#
+# This class is intended to manipulate a ``Filesystem``.
+class Kamaze::Project::Tools::Packager::Filesystem::Operator
+  include Utils
+
+  # @return [Kamaze::Project::Tools::Packager::Filesystem]
+  attr_reader :fs
+
+  # @param [Kamaze::Project::Tools::Packager::Filesystem] filesystem
+  # @param [Hash] options
+  # @see fs
+  def initialize(filesystem, options = {})
+    @fs = filesystem
+    @options = { verbose: true }.merge(options.to_h)
+
+    # Pass included methods to protected
+    utils_methods.each do |m|
+      if self.public_methods.include?(m)
+        self.singleton_class.class_eval { protected m }
+      end
+    end
+  end
+
+  # Prepare package
+  #
+  # @return [self]
+  def prepare
+    fs.package_dirs.each_value { |dir| mkdir_p(dir, options) }
+
+    self.purge_purgeables.prepare_srcdir
+  end
+
+  # Purge purgeables elements
+  #
+  # @return [self]
+  def purge_purgeables
+    fs.purgeable_dirs.each_value { |dir| purge(dir, options) }
+
+    self
+  end
+
+  # Prepare ``src`` dir
+  #
+  # Source files are refreshed (deleted and copied again)
+  #
+  # @return [self]
+  def prepare_srcdir
+    src_dir = ::Pathname.new(fs.package_dirs.fetch(:src))
+
+    purge(src_dir, options)
+    skel_dirs(src_dir, fs.source_files, options)
+
+    fs.source_files.map do |path|
+      origin = path.realpath # resolves symlinks
+
+      cp(origin, src_dir.join(path), options.merge(preserve: true))
+    end
+
+    self
+  end
+
+  def verbose?
+    options[:verbose] == true
+  end
+
+  protected
+
+  # @return [Hash]
+  attr_reader :options
+end

data/lib/kamaze/project/tools/packager/filesystem/operator/utils.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 'pathname'
+require 'fileutils'
+require 'rake/file_utils'
+
+require_relative '../operator'
+
+# Utilities related to files/paths manipulations
+module Kamaze::Project::Tools::Packager::Filesystem::Operator::Utils
+  include FileUtils
+
+  protected
+
+  # Purge a directory
+  #
+  # @param [Pathname] dir
+  # @return [Pathname]
+  def purge(dir, options = {})
+    options = { verbose: true }.merge(options)
+    dir = ::Pathname.new(dir)
+
+    if dir.exist?
+      ls(dir).each do |entry|
+        rm_rf(dir.join(entry), options)
+      end
+    end
+
+    dir
+  end
+
+  # Make dirs from given basedir using entries (filepaths)
+  #
+  # @param [String|Pathname] basedir
+  # @param [Array<>] entries
+  # @param [Hash] options
+  # @return [Pathname]
+  def skel_dirs(basedir, entries, options = {})
+    basedir = ::Pathname.new(basedir)
+
+    map_dirs(entries).each { |dir| mkdir_p(basedir.join(dir), options) }
+
+    basedir
+  end
+
+  # List entries
+  #
+  # @param [String] dir
+  # @return [Array<Pathname>]
+  def ls(dir)
+    ::Pathname.new(dir).entries
+              .map { |path| ::Pathname.new(path) }
+              .delete_if { |path| ['.', '..'].include?(path.basename.to_s) }
+  end
+
+  # Extract directories from given paths
+  #
+  # @param [Array<String>] paths
+  # @return [Array<Pathname>]
+  def map_dirs(paths)
+    paths.map { |path| ::Pathname.new(path) }
+         .map(&:dirname)
+         .delete_if { |path| ['.', '..'].include?(path.basename.to_s) }
+         .uniq.sort
+  end
+
+  # @return [Array<Symbol>]
+  def utils_methods
+    FileUtils.public_methods - self.public_methods
+  end
+end

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

@@ -0,0 +1,106 @@
+# 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 'etc'
+require 'fileutils'
+require 'pathname'
+require 'tmpdir'
+require 'process_lock'
+require 'active_support/inflector'
+
+module Kamaze::Project::Tools
+  class ProcessLocker < BaseTool
+  end
+end
+
+# Process Locker
+#
+# @see https://github.com/ianheggie/process_lock
+class Kamaze::Project::Tools::ProcessLocker < Kamaze::Project::Tools::BaseTool
+  # Manage lock on given block
+  #
+  # @return [Object]
+  def lock(lockname)
+    mklock(lockname).acquire { yield }
+  end
+
+  # Manage lock on given block
+  #
+  # @raise [Errno::EALREADY]
+  # @raise [ProcessLock::AlreadyLocked]
+  # @return [Object]
+  def lock!(lockname)
+    mklock(lockname).acquire! { yield }
+  rescue ProcessLock::AlreadyLocked
+    raise Errno::EALREADY if mklock(lockname).alive?
+    raise
+  end
+
+  # @return [Pathname]
+  def tmpdir
+    tmp = Pathname.new(Dir.tmpdir)
+    uid = Etc.getpwnam(Etc.getlogin).uid
+    dir = [inflector.underscore(self.class.name).tr('/', '-'), uid].join('.')
+
+    tmp.join(dir)
+  end
+
+  class << self
+    def method_missing(method, *args, &block)
+      if respond_to_missing?(method)
+        self.new.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      return true if self.new.respond_to?(method, include_private)
+
+      super(method, include_private)
+    end
+  end
+
+  protected
+
+  # @param [String] lockname
+  # @return [ProcessLock]
+  def mklock(lockname)
+    lockfile = mktemp(lockname)
+
+    ProcessLock.new(lockfile)
+  end
+
+  # Create a temporary file
+  #
+  # @param [String] lockname
+  # @return [Pathname]
+  def mktemp(lockname)
+    lockname = Pathname.new(lockname.to_s).basename('.*')
+
+    mktmpdir.join(lockname)
+  end
+
+  # Create ``tmpdir``
+  #
+  # @param [Hash] options
+  # @return [Pathname]
+  def mktmpdir(options = {})
+    tmpdir = self.tmpdir
+    options[:mode] ||= 0o700
+
+    FileUtils.mkdir_p(tmpdir, options)
+
+    tmpdir
+  end
+
+  def inflector
+    ActiveSupport::Inflector
+  end
+end

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

@@ -0,0 +1,115 @@
+# 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 '../concern/cli/with_exit_on_failure'
+
+# Provide wrapper based on top of ``RSpec::Core::Runner``
+#
+# Sample of use:
+#
+# ```ruby
+# tools.fetch(:rspec).tap do |rspec|
+#   rspec.tags = args[:tags].to_s.split(',').map(&:strip)
+# end.run
+# ```
+#
+# @see https://www.relishapp.com/rspec/rspec-core/docs/command-line/rake-task
+# @see https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/runner.rb
+# @see https://relishapp.com/rspec/rspec-core/v/2-4/docs/command-line/tag-option
+class Kamaze::Project::Tools::Rspec < Kamaze::Project::Tools::BaseTool
+  include Kamaze::Project::Concern::Cli::WithExitOnFailure
+
+  # Default arguments used by ``RSpec::Core::Runner``
+  #
+  # @type [Array|Arguments]
+  # @return [Arguments]
+  attr_accessor :defaults
+
+  attr_accessor :stdout
+
+  attr_accessor :stderr
+
+  # @return [Array<String>]
+  attr_accessor :tags
+
+  def mutable_attributes
+    [:defaults, :stdout, :stderr]
+  end
+
+  # @raise [SystemExit]
+  # @return [self]
+  def run
+    with_exit_on_failure do
+      options = arguments.concat(options_arguments).map(&:to_s)
+
+      self.retcode = core.run(options, stderr, stdout).to_i
+      reset
+    end
+
+    self
+  end
+
+  # Arguments used by ``CLI`` (during execution/``run``)
+  #
+  # @return [Arguments]
+  def arguments
+    @arguments = @defaults if @arguments.to_a.size.zero?
+
+    tags.to_a.each do |tag|
+      next if @arguments.slice_before('--tag').to_a.include?(['--tag', tag])
+
+      @arguments += ['--tag', tag]
+    end
+
+    {
+      true  => @arguments,
+      false => @arguments.clone.concat(options_arguments).map(&:to_s).freeze
+    }.fetch(caller_locations(1..1).first.path == __FILE__)
+  end
+
+  protected
+
+  # Reset arguments + retcode
+  #
+  # @return [self]
+  def reset
+    @arguments = nil
+    self.retcode = nil if retcode.to_i.zero?
+
+    self
+  end
+
+  def setup
+    reset
+
+    @tags = []
+    @stdout ||= $stdout
+    @stderr ||= $stderr
+    @defaults ||= []
+  end
+
+  # @return [RSpec::Core::Runner]
+  def core
+    require 'rspec/core'
+
+    RSpec::Core::Runner
+  end
+
+  # @return [Array<String>]
+  def options_arguments
+    options_files = Pathname.new(Dir.pwd).join('.rspec')
+    defaults = []
+
+    if options_files.file? and options_files.readable?
+      defaults += ['-O', '.rspec']
+    end
+
+    defaults
+  end
+end