kamaze-project 1.0.0

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

@@ -0,0 +1,128 @@
+# 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'
+require 'pathname'
+require 'rubocop'
+
+# rubocop:disable Style/Documentation
+
+module Kamaze::Project::Tools
+  class Rubocop < BaseTool
+    class Arguments < Array
+      require_relative 'rubocop/arguments'
+    end
+
+    class Config
+      require_relative 'rubocop/config'
+    end
+  end
+end
+
+# rubocop:enable Style/Documentation
+
+# Tool to run ``Rubocop::CLI``
+#
+# Sample of use:
+#
+# ```ruby
+# Rubocop.new.prepare do |c|
+#   c.patterns = ["#{Dir.pwd}/test/cs.rb"]
+#   c.options = ['--fail-level', 'E']
+# end.run
+# ```
+class Kamaze::Project::Tools::Rubocop
+  include Kamaze::Project::Concern::Cli::WithExitOnFailure
+
+  # Default arguments used by ``Rubocop::CLI``
+  #
+  # @type [Array|Arguments]
+  # @return [Arguments]
+  attr_accessor :defaults
+
+  def mutable_attributes
+    [:defaults]
+  end
+
+  def prepare
+    reset
+
+    if block_given?
+      config = Config.new
+      yield(config)
+      arguments.concat(config.freeze.to_a)
+    end
+
+    arguments.freeze
+
+    self
+  end
+
+  # Arguments used by ``CLI`` (during execution/``run``)
+  #
+  # @return [Arguments]
+  def arguments
+    @arguments = defaults.clone if @arguments.to_a.size.zero?
+
+    if caller_locations(1..1).first.path == __FILE__
+      @arguments
+    else
+      @arguments.clone.freeze
+    end
+  end
+
+  # Denote runnable
+  #
+  # When last argument is ``--`` we suppose there is no files
+  #
+  # @return [Boolean]
+  def runnable?
+    '--' != arguments.last
+  end
+
+  # @raise [SystemExit]
+  # @return [self]
+  def run
+    prepare if arguments.to_a.empty?
+
+    if runnable?
+      with_exit_on_failure do
+        core.run(arguments.to_a).yield_self do |retcode|
+          self.retcode = retcode
+          reset
+        end
+      end
+    end
+
+    self
+  end
+
+  protected
+
+  attr_writer :arguments
+
+  def setup
+    @defaults = Arguments.new(@defaults.to_a)
+  end
+
+  # Reset arguments + retcode
+  #
+  # @return [self]
+  def reset
+    @arguments = nil
+    self.retcode = nil if retcode.to_i.zero?
+
+    self
+  end
+
+  # @return [YARD::CLI::Yardoc]
+  def core
+    RuboCop::CLI.new
+  end
+end

data/lib/kamaze/project/tools/rubocop/arguments.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 '../rubocop'
+
+# Arguments
+#
+# Almost a basic ``Array``
+class Kamaze::Project::Tools::Rubocop::Arguments < Array
+  # @return [Array<String>]
+  def to_a
+    super.map(&:to_s)
+  end
+end

data/lib/kamaze/project/tools/rubocop/config.rb

@@ -0,0 +1,43 @@
+# 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 '../rubocop'
+
+# Config used during prepare method
+#
+# Config is defined by ``options`` and ``patterns``
+class Kamaze::Project::Tools::Rubocop::Config
+  # Patterns used to match files
+  #
+  # @type [Array]
+  # @return [Array]
+  attr_accessor :patterns
+
+  # Command options
+  #
+  # @type [Array]
+  # @return [Array]
+  attr_accessor :options
+
+  # @return [Array<String>]
+  def to_a
+    filepaths = match_patterns(patterns)
+
+    self.options.to_a.clone.concat(['--'] + filepaths)
+  end
+
+  protected
+
+  # Match against given patterns
+  #
+  # @param [Array<String>] patterns
+  # @return [Array<String>]
+  def match_patterns(patterns)
+    Dir.glob(patterns)
+  end
+end

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

@@ -0,0 +1,85 @@
+# 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'
+
+# Provide a REPL (based on ``Pry``)
+class Kamaze::Project::Tools::Shell < Kamaze::Project::Tools::BaseTool
+  # REPL provider
+  #
+  # Allowing to replace ``Pry`` by ``IRB``, or any REPL
+  # class or instance responding to a `start`` method.
+  #
+  # @type [Pry|Class|Object]
+  attr_writer :provider
+
+  # Console used for outputs (``stderr`` and ``stdout``)
+  #
+  # @type [Kamaze::Project::Tools::Console]
+  attr_writer :console
+
+  # @type [String]
+  attr_writer :banner
+
+  # Get banner
+  #
+  # @return [String]
+  def banner
+    return @banner if @banner
+
+    patch = defined?(RUBY_PATCHLEVEL) ? "p#{RUBY_PATCHLEVEL}" : nil
+    # almost like RUBY_DESCRIPTION
+    descr = ["#{RUBY_ENGINE} #{RUBY_VERSION}#{patch}".rstrip,
+             "(#{RUBY_RELEASE_DATE})",
+             "[#{RUBY_PLATFORM}]"].join(' ')
+
+    "{{green:#{descr}}}"
+  end
+
+  def setup
+    @console ||= Kamaze.project.tools.fetch(:console)
+    @provider ||= require_any(:pry) ? Pry : nil
+    @banner ||= nil
+  end
+
+  # Start REPL session
+  def start
+    require_any(:interesting_methods)
+    console.stdout.puts(banner)
+    provider.start
+  end
+
+  protected
+
+  # Get console
+  #
+  # @return [Kamaze::Project::Tools::Console]
+  attr_reader :console
+
+  # Get provider
+  #
+  # @return [Pry|Class|Object]
+  attr_reader :provider
+
+  # Require any gem based on ``Gem::Specification``
+  #
+  # @param [String|Symbol] gem_name
+  # @param [String|Symbol] req_name
+  # @return [Boolean]
+  def require_any(gem_name, req_name = nil)
+    gem_name = gem_name.to_s
+    req_name ||= gem_name
+    spec = Gem::Specification
+
+    return false unless spec.find_all_by_name(gem_name).any?
+
+    require req_name
+
+    true
+  end
+end

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

@@ -0,0 +1,182 @@
+# 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'
+require 'base64'
+require 'pathname'
+
+# rubocop:disable Style/Documentation
+
+module Kamaze::Project::Tools
+  class Vagrant < BaseTool
+  end
+
+  [:composer, :shell, :writer, :remote].each do |req|
+    require_relative "vagrant/#{req}"
+  end
+end
+
+# rubocop:enable Style/Documentation
+
+# Vagrant based,
+# this class provides a easy and ready to use wrapper around ``vagrant``
+# executable. VM configuration is easyfied by the use of YAML files.
+#
+# VM configurations are stored in a single directory (default: ``vagrant``)
+# and can be overriden by an ``.override.yml`` file.
+# A ``Vagrantfile`` is generated upon configurations.
+#
+# Sample use in Rake task:
+#
+# ```ruby
+# vagrant = project.tools.fetch(:vagrant)
+#
+# if vagrant.boxes? and vagrant.executable?
+#    file vagrant.vagrantfile => vagrant.sources do
+#        vagrant.install
+#    end
+# end
+# ```
+#
+# This class is almost a facade based on:
+#
+# * Composer
+# * Writer
+# * Shell
+# * Remote
+#
+# @see http://yaml.org/YAML_for_ruby.html
+# @see https://friendsofvagrant.github.io/v1/docs/boxes.html
+class Kamaze::Project::Tools::Vagrant
+  # Template file (used for code generation)
+  #
+  # @return [String]
+  attr_accessor :template
+
+  # Absolute path to the vagrant executable
+  #
+  # @return [String|nil]
+  attr_accessor :executable
+
+  # Get path to actual ``Vagrantfile``
+  #
+  # @return [Pathname]
+  attr_accessor :vagrantfile
+
+  # Path to files describing boxes (directory)
+  #
+  # defaults to ``./vagrant``
+  #
+  # @return [String]
+  attr_accessor :path
+
+  def mutable_attributes
+    [:path, :executable, :template, :vagrantfile]
+  end
+
+  # Get working dir
+  #
+  # @return [Pathname]
+  def pwd
+    Pathname.new(Dir.pwd).realpath
+  end
+
+  # Denote ``vagrant`` executable is present
+  #
+  # @return [Boolean]
+  def executable?
+    shell.executable?
+  end
+
+  # Run the vagrant command with given ``args``.
+  #
+  # @see https://github.com/ruby/rake/blob/master/lib/rake/file_utils.rb
+  def execute(*args, &block)
+    shell.execute(*args, &block)
+  end
+
+  # Run a command remotely on box identified by ``box_id``
+  #
+  # Sample of use:
+  #
+  # ```ruby
+  # vagrant.ssh('freebsd', 'rake clobber')
+  # ```
+  def ssh(*args, &block)
+    remote.execute(*args, &block)
+  end
+
+  # Install a new Vagrantfile
+  #
+  # Vagrant file is installed with additionnal YAML file,
+  # defining ``boxes``
+  #
+  # @return [self]
+  def install
+    writer.write(boxes)
+
+    self
+  end
+
+  def method_missing(method, *args, &block)
+    if respond_to_missing?(method)
+      composer.public_send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    return true if composer.respond_to?(method, include_private)
+
+    super
+  end
+
+  protected
+
+  # Get composer, responsible to read and combine files describing boxes
+  #
+  # @return [Composer]
+  attr_reader :composer
+
+  # Get a shell, to execute ``vagrant`` commands
+  #
+  # @return [Shell]
+  attr_reader :shell
+
+  # Get writer, reponsible of ``Vagrantfile`` generation
+  #
+  # @return [Writer]
+  attr_reader :writer
+
+  def setup
+    @template ||= Pathname.new(__dir__).join('..', 'resources').to_s
+    @vagrantfile ||= ::Pathname.new(@vagrantfile || pwd.join('Vagrantfile'))
+    @executable ||= :vagrant
+    @path ||= pwd.join('vagrant').to_s
+
+    setup_compose
+  end
+
+  # Initialize most of the tools used internally
+  def setup_compose
+    @composer = Composer.new(@path)
+    @shell = Shell.new(executable: executable)
+    @writer = Writer.new(@template, vagrantfile)
+
+    self
+  end
+
+  # Get remote shell provider
+  #
+  # @return [Remote]
+  def remote
+    Remote.new(boxes, executable: executable)
+  end
+end