kamaze-project 1.0.0

data/lib/kamaze/project/tools/vagrant/composer.rb

@@ -0,0 +1,88 @@
+# 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 '../vagrant'
+require 'pathname'
+require 'yaml'
+
+# rubocop:disable Style/Documentation
+
+class Kamaze::Project::Tools::Vagrant
+  class Composer
+  end
+  require_relative 'composer/file'
+end
+
+# rubocop:enable Style/Documentation
+
+# Compose ``boxes`` data structure from files
+class Kamaze::Project::Tools::Vagrant::Composer
+  # Path to files describing boxes
+  #
+  # defaults to ``./vagrant``
+  #
+  # @return [Pathname]
+  attr_reader :path
+
+  # Initialize from given path
+  #
+  # @param [String] path
+  def initialize(path)
+    @path = ::Pathname.new(path)
+  end
+
+  # Dump (boxes) config
+  #
+  # @return [String]
+  def dump
+    ::YAML.dump(boxes)
+  end
+
+  # Denote existence of configured boxes
+  #
+  # @return [Boolean]
+  def boxes?
+    !boxes.empty?
+  end
+
+  # Get boxes
+  #
+  # @return [Hash]
+  def boxes
+    results = {}
+    files.each { |file| results[file.name] = file.load }
+
+    results
+  end
+
+  # Get files used to generate ``boxes``
+  #
+  # Files are indexed by ``name``.
+  # Overrides and non-loablde files are excluded during listing.
+  #
+  # @return [Array<File>]
+  def files
+    Dir.glob("#{path}/*.yml")
+       .delete_if { |file| /\.override.yml$/ =~ file }
+       .map { |file| File.new(file) }
+       .keep_if(&:loadable?)
+       .freeze
+  end
+
+  # Get files related to "box files"
+  #
+  # Almost all files stored in ``path`` are considered as ``source``
+  #
+  # @return [Array<Pathname>]
+  def sources
+    Dir.glob("#{path}/**/**")
+       .map { |path| ::Pathname.new(path) }
+       .keep_if(&:file?)
+       .sort_by(&:to_s).freeze
+  end
+end

data/lib/kamaze/project/tools/vagrant/composer/file.rb

@@ -0,0 +1,79 @@
+# 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 '../composer'
+require 'pathname'
+
+class Kamaze::Project::Tools::Vagrant::Composer
+  class File < ::Pathname
+  end
+end
+
+# Describe a file
+#
+# File can be overriden (``.override.yml``). A file has a name.
+# It is loadable.
+class Kamaze::Project::Tools::Vagrant::Composer::File
+  # @return [String]
+  def name
+    self.basename('.yml').to_s
+  end
+
+  # Get path to potential override
+  def override
+    self.dirname.join("#{name}.override.yml")
+  end
+
+  # Denote file is empty
+  #
+  # Return ``true`` when content is empty
+  #
+  # @return [Boolean]
+  def empty?
+    self.read.empty?
+  end
+
+  # Denote file is loadable
+  #
+  # This test is based on filesystem and emptyness
+  #
+  # @return [Boolean]
+  def loadable?
+    self.file? and self.readable? and !self.empty?
+  end
+
+  # Denote file is overriden
+  #
+  # @return [Booolean]
+  def overriden?
+    override.file? and override.readable?
+  end
+
+  # Load file
+  #
+  # @return [Hash]
+  def load
+    return nil unless self.loadable?
+
+    data = yaml_read(self)
+    data.merge!(yaml_read(override)) if overriden?
+
+    data
+  end
+
+  protected
+
+  # Read a file (by given path)
+  #
+  # Use ``safe_load`` on file content
+  #
+  # @param [Pathname] path
+  def yaml_read(path)
+    YAML.safe_load(path.read, [Symbol])
+  end
+end

data/lib/kamaze/project/tools/vagrant/remote.rb

@@ -0,0 +1,79 @@
+# 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 '../vagrant'
+require 'pathname'
+
+class Kamaze::Project::Tools::Vagrant
+  class Remote < Shell
+  end
+end
+
+# Provide remote command execution (ssh)
+#
+# Commands can use aliases through configuration: ``box_id.ssh.aliases``;
+# where ``box_id`` is the box identifier.
+class Kamaze::Project::Tools::Vagrant::Remote
+  # @return [Hash]
+  attr_reader :boxes
+
+  # Initialize remote shell with given boxes and options
+  #
+  # @param [Hash] boxes
+  # @param [Hash] options
+  def initialize(boxes, options = {})
+    @boxes = boxes
+
+    super(options)
+  end
+
+  # @return [Array]
+  def to_a
+    super.push('ssh')
+  end
+
+  # Run a command remotely on box identified by ``box_id``
+  #
+  # Sample of use:
+  #
+  # ```ruby
+  # remote.execute(:freebsd)
+  # remote.execute(:freebsd, 'rake clobber')
+  # ```
+  #
+  # At least, one argument is required.
+  def execute(*params, &block)
+    box_id  = params.fetch(0)
+    command = apply_alias(box_id, params[1]) # remote command
+    params  = command ? [box_id, '-c', command] : [box_id]
+
+    super(*params, &block)
+  end
+
+  protected
+
+  # Apply alias on command for given ``box_id``
+  #
+  # @param [String] box_id
+  # @param [String|nil] command
+  # @return [String|nil]
+  def apply_alias(box_id, command)
+    return unless command
+
+    conf = boxes.fetch(box_id.to_s) # fetch related config
+    args = Shellwords.split(command) # command split into words
+    exeb = conf['ssh']['aliases'][args[0]] # executable
+    if exeb
+      command = Shellwords.split(exeb)
+                          .concat(args.drop(1))
+                          .yield_self { |c| Shellwords.shelljoin(c) }
+    end
+
+    command
+  end
+end

data/lib/kamaze/project/tools/vagrant/shell.rb

@@ -0,0 +1,102 @@
+# 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 '../vagrant'
+require_relative '../../concern/cli/with_exit_on_failure'
+require_relative '../../concern/sh'
+require 'pathname'
+require 'shellwords'
+
+class Kamaze::Project::Tools::Vagrant
+  class Shell
+  end
+end
+
+# Execute commands using ``executable``
+#
+# Options are passed to ``Rake::FileUtilsExt.sh()``.
+# Executable can be defined through ``options``.
+class Kamaze::Project::Tools::Vagrant::Shell
+  include Kamaze::Project::Concern::Cli::WithExitOnFailure
+  include Kamaze::Project::Concern::Sh
+
+  # @return [Hash]
+  attr_reader :options
+
+  # Initialize a shell with given options
+  #
+  # @param [Hash] options
+  def initialize(options = {})
+    @options = options
+    # Executable used by command
+    @executable = options.delete(:executable) || :vagrant
+
+    # default ``sh`` options
+    @options[:verbose] = false unless options.key?(:verbose)
+  end
+
+  # @return [Boolean]
+  def executable?
+    executable
+  end
+
+  # Get (absolute) path to executable
+  #
+  # Return ``nil`` when executable CAN NOT be detected.
+  #
+  # @return [String|nil]
+  def executable
+    Cliver.detect(@executable)&.freeze
+  end
+
+  # @return [Array]
+  def to_a
+    [executable]
+  end
+
+  # @return [String]
+  def to_s
+    executable.to_s
+  end
+
+  # Run given arguments as system command using ``executable``.
+  def execute(*params, &block)
+    env = preserved_env
+
+    Bundler.with_clean_env do
+      with_exit_on_failure do
+        [env].concat(to_a.concat(params)).push(options).yield_self do |cmd|
+          sh(*cmd, &block)
+
+          self.retcode = self.shell_runner_last_status.exitstatus
+        end
+      end
+    end
+  end
+
+  protected
+
+  # Get preserved env (from given env)
+  #
+  # @param [ENV|Hash] from
+  # @return [Hash]
+  #
+  # @todo refactor
+  def preserved_env(from = ENV)
+    env = {}
+    from = from.to_h
+
+    ['SILENCE_DUPLICATE_DIRECTORY_ERRORS'].each do |key|
+      next unless from.key?(key)
+
+      env[key] = from.fetch(key)
+    end
+
+    env
+  end
+end

data/lib/kamaze/project/tools/vagrant/writer.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 '../vagrant'
+require 'pathname'
+require 'yaml'
+
+class Kamaze::Project::Tools::Vagrant
+  class Writer
+  end
+end
+
+# Responsible to write a ``Vagrantfile``
+#
+# ``Vagrantfile`` is written as a standalone, i. e. ``boxes`` variable
+# is set as a base64 string. ``Vagrantfile`` defines the necessary methods
+# to setup VMs from ``boxes``.
+class Kamaze::Project::Tools::Vagrant::Writer
+  # Template used to generate ``Vagrantfile``
+  #
+  # @return [::Pathname]
+  attr_reader :template
+
+  # Path to Vagrantfile
+  #
+  # @return [Pathname]
+  attr_reader :output_file
+
+  # @param [String] template
+  # @param [String] output_file
+  def initialize(template, output_file = 'Vagrantfile')
+    template = ::Pathname.new(template)
+
+    @template = template
+    @template = template.join('Vagrantfile') if template.directory?
+    @output_file = output_file
+  end
+
+  # Write ``Vagrantfile`` based on given ``boxes``
+  #
+  # @param [Hash] boxes
+  def write(boxes)
+    ::YAML.dump(boxes)
+          .yield_self { |yaml| templatize(yaml) }
+          .yield_self { |content| output_file.write(content) }
+  end
+
+  protected
+
+  # Make content (used to write ``Vagrantfile``)
+  #
+  # @param [String] yaml
+  # @return [String]
+  def templatize(yaml)
+    boxes64 = Base64.strict_encode64(yaml).yield_self do |text|
+      word_wrap(text, 70).map { |s| "\s\s'#{s}'\\" }.join("\n").chomp('\\')
+    end
+
+    ['# frozen_string_literal: true',
+     '# vim: ai ts=2 sts=2 et sw=2 ft=ruby', nil,
+     '[:base64, :yaml, :pp].each { |req| require req.to_s }', nil,
+     "cnf64 = \\\n#{boxes64}", nil,
+     'boxes = YAML.safe_load(Base64.strict_decode64(cnf64), [Symbol])', nil,
+     template.read.gsub(/^#.*\n/, '')]
+      .map(&:to_s).join("\n").gsub(/\n\n+/, "\n\n")
+  end
+
+  # Wrap text into small chunks
+  #
+  # @param [String] text
+  # @param [Fixnum] width
+  # @return [Array<String>]
+  def word_wrap(text, width = 80)
+    text.each_char.each_slice(width).to_a.map(&:join)
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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 'pathname'
+require 'yard'
+
+# rubocop:disable Style/Documentation
+
+module Kamaze::Project::Tools
+  class Yardoc < BaseTool
+  end
+
+  require_relative 'yardoc/file'
+  require_relative 'yardoc/watchable'
+end
+
+# rubocop:enable Style/Documentation
+
+# Tool to run ``CLI::Yardoc`` and generate documentation
+#
+# @see https://github.com/lsegal/yard/blob/49d885f29075cfef4cb954bb9247b6fbc8318cac/lib/yard/rake/yardoc_task.rb
+class Kamaze::Project::Tools::Yardoc
+  include Watchable
+
+  # Options used by ``YARD::CLI::Yardoc``
+  #
+  # @type [Hash]
+  # @return [Hash]
+  attr_accessor :options
+
+  # @return [Fixnum]
+  def run
+    retcode = core.run
+    retcode = retcode ? 0 : 1 if [true, false].include?(retcode)
+
+    retcode
+  end
+
+  # Get output directory (default SHOULD be ``doc``)
+  #
+  # @return [Pathname]
+  def output_dir
+    core.options
+        .yield_self(&:serializer)
+        .yield_self(&:basepath).gsub(%r{^\./+}, '')
+        .yield_self { |path| ::Pathname.new(path) }
+  end
+
+  alias call run
+
+  def mutable_attributes
+    [:options]
+  end
+
+  protected
+
+  def setup
+    @options ||= {}
+  end
+
+  # @return [YARD::CLI::Yardoc]
+  def core
+    YARD::CLI::Yardoc.new.tap do |yard|
+      yard.parse_arguments([])
+
+      options.to_h.each { |k, v| yard.options[k.to_sym] = v }
+    end
+  end
+end