kamaze-project 1.0.0

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

@@ -0,0 +1,55 @@
+# 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 '../yardoc'
+require 'pathname'
+
+# Describe a "file"
+#
+# as seen from ``YARD::CLI::Yardoc#files`` and
+# ``YARD::CLI::YardocOptions#files``, as result a file can be evaluating
+# as a glob expression, else file (``filepath``)  is a fixed string.
+# Thus, file is castable to ``Array``.
+class Kamaze::Project::Tools::Yardoc::File
+  # @param [String] filepath
+  # @param [Boolean] glob
+  def initialize(filepath, glob = false)
+    @glob = !!glob
+    @filepath = filepath.to_s
+  end
+
+  # @return [Array<Pathname>]
+  def paths
+    proc do
+      if glob?
+        Dir.glob(filepath).map { |f| ::Pathname.new(f).dirname }
+      else
+        [::Pathname.new(filepath).dirname]
+      end
+    end.call.uniq.sort.map do |f|
+      ::Pathname.new(f.to_s.gsub('./', ''))
+    end
+  end
+
+  # Denote file MUST be evaluated as a glob expression
+  #
+  # @return [Boolean]
+  def glob?
+    @glob
+  end
+
+  def to_s
+    filepath
+  end
+
+  alias to_a paths
+
+  protected
+
+  attr_reader :filepath
+end

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

@@ -0,0 +1,70 @@
+# 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 '../yardoc'
+
+# rubocop:disable Style/Documentation
+
+class Kamaze::Project::Tools::Yardoc
+  module Watchable
+    class File < Kamaze::Project::Tools::Yardoc::File
+    end
+
+    private_constant :File
+  end
+end
+
+# rubocop:enable Style/Documentation
+
+# Provide watch related methods
+#
+# Yardoc (wrapper class) is used by a Watcher using tools
+# it MUST provide some methods used to:
+#
+# * initialize ``Listen``
+# * provide patterns (glob pattern matching)
+#
+# Instance of ``YARD::CLI::Yardoc`` is retrieved through ``core`` method
+module Kamaze::Project::Tools::Yardoc::Watchable
+  # Get paths
+  #
+  # @return [Array<Pathname>]
+  def paths
+    files.map do |file|
+      file.to_a.sort[0]
+    end.flatten.compact.uniq.sort
+  end
+
+  # Get patterns (usable for glob pattern matching)
+  #
+  # @return [Array<String>]
+  def patterns
+    files.map(&:to_s)
+  end
+
+  # Get files
+  #
+  # Mostly patterns,
+  # addition of ``files`` with ``options.files``
+  # SHOULD include ``README`` file, when ``.yardopts`` defined
+  #
+  # @return [Array<Kamaze::Project::Tools::Yardoc::File>]
+  def files
+    [
+      core.files.to_a.flatten.map { |f| File.new(f, true) },
+      core.options.files.to_a.map { |f| File.new(f.filename, false) }
+    ].flatten
+  end
+
+  # Ignores files matching path match (regexp)
+  #
+  # @return [Array<String>]
+  def excluded
+    core.excluded
+  end
+end

data/lib/kamaze/project/tools/yardoc/watcher.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 '../yardoc'
+
+class Kamaze::Project::Tools::Yardoc
+  class Watcher < Kamaze::Project::Tools::BaseTool
+  end
+end
+
+# Provide a watcher built on top of Yardoc
+class Kamaze::Project::Tools::Yardoc::Watcher
+  # @type [Array<String>]
+  attr_writer :paths
+
+  # @type [Hash]
+  attr_accessor :options
+
+  # @type [Array<String>]
+  attr_writer :patterns
+
+  # Watch for changes
+  #
+  # Non-blocking, unless ``wait``
+  #
+  # @param [Boolean] wait
+  # @return [self]
+  def watch(wait = false)
+    listener = ::Listen.to(*paths, options) do |mod, add, rem|
+      if trigger?(mod + add + rem)
+        yardoc.run
+      end
+    end
+
+    listener.start
+    sleep if wait
+
+    self
+  end
+
+  # @return [Array<String>]
+  def patterns
+    @patterns.map { |pattern| pattern.gsub(%r{^./+}, '') }
+  end
+
+  # @return [Array<String>]
+  def paths
+    paths = @paths.map(&:to_s)
+
+    paths.include?('.') ? ['.'] : paths
+  end
+
+  def mutable_attributes
+    [:paths, :options, :patterns]
+  end
+
+  protected
+
+  # Transform paths to relative paths
+  #
+  # @param [String|Pathname|Array<String>] paths
+  def rel(paths)
+    paths = [paths] unless paths.is_a?(Array)
+
+    paths.map do |path|
+      path.to_s.gsub(%r{^#{Dir.pwd}/+}, '')
+    end
+  end
+
+  # Denote paths trigger (require) action
+  #
+  # @param [String|Pathname|Array<String>] paths
+  # @return [Boolean]
+  def trigger?(paths)
+    paths = [paths] unless paths.is_a?(Array)
+
+    paths.map(&:to_s)
+         .map { |path| rel(path)[0] }
+         .each do |path|
+      patterns.each do |pattern|
+        return true if File.fnmatch(pattern, path, File::FNM_PATHNAME)
+      end
+    end
+
+    false
+  end
+
+  def setup
+    @paths ||= yardoc.paths
+    @patterns ||= yardoc.patterns
+    @options = {
+      only:   /\.(rb|md)$/,
+      ignore: yardoc.excluded.map { |pattern| /#{pattern}/ }
+    }.merge(@options.to_h)
+  end
+
+  # @return [Kamaze::Project::Tools::Yardoc]
+  def yardoc
+    Kamaze.project.tools.fetch('yardoc')
+  end
+end

data/lib/kamaze/project/tools_provider.rb

@@ -0,0 +1,161 @@
+# 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 '../project'
+
+class Kamaze::Project
+  class ToolsProvider
+    class Resolver
+    end
+  end
+end
+
+require_relative 'tools_provider/resolver'
+
+# Tools provider
+#
+# Tools are instantiated on demand,
+# each demand generates a fresh new tool instance, avoiding risk
+# to reuse a previous altered version of a tool.
+#
+# Sample of use:
+#
+# ```ruby
+# project.tools.fetch(:licenser).process do |licenser|
+#   process.license  = project.version.license_header
+#   process.patterns = ['bin/*', 'lib/**/**.rb']
+#   process.output   = STDOUT
+# end
+# ```
+class Kamaze::Project::ToolsProvider
+  class << self
+    # Default tools
+    #
+    # Tools default values can be ``Class`` or ``String`` (or ``Symbol``),
+    # when value is not a ``Class``, it is resolved using ``inflector``
+    #
+    # @return [Hash]
+    def defaults
+      items.freeze
+    end
+
+    protected
+
+    # Get items
+    #
+    # Items are collected from a YAML file.
+    #
+    # @return [Hash]
+    def items
+      config = "#{__dir__}/resources/config/tools.yml"
+      defaults = YAML.load_file(config)
+
+      Hash[defaults.collect { |k, v| [k.to_sym, v] }]
+    end
+  end
+
+  # @param [Hash] items
+  def initialize(items = {})
+    @items = Hash[self.class.defaults].merge(items)
+    @cache = {}
+    @resolver = Resolver.new
+  end
+
+  # @param [Hash] items
+  # @return [self]
+  def merge!(items)
+    items = Hash[items.map { |k, v| [k.to_sym, v] }]
+    @cache.delete_if { |k| items.member?(k) }
+
+    @items.merge!(items)
+
+    self
+  end
+
+  # Associates the value given by value with the given key.
+  #
+  # @param [String|Symbol] name
+  # @param [Class] value
+  def []=(name, value)
+    merge!(name => value)
+  end
+
+  # Prevents further modifications.
+  #
+  # See also ``Object#frozen?``.
+  #
+  # @return [self]
+  def freeze
+    @items.freeze
+    super
+  end
+
+  # Get a fresh instance with given name
+  #
+  # @param [Symbol|String] name
+  # @return [Object]
+  # @raise [KeyError]
+  def fetch(name)
+    raise KeyError, "key not found: :#{name}" unless member?(name)
+
+    self[name]
+  end
+
+  # Get a fresh instance with given name
+  #
+  # @param [Symbol|String] name
+  # @return [Object|nil]
+  def [](name)
+    name = name.to_sym
+
+    return nil unless member?(name)
+
+    @cache[name] ||= @items.fetch(name).yield_self do |klass|
+      resolver.classify(klass)
+    end
+
+    @cache.fetch(name).new
+  end
+
+  alias get fetch
+
+  # Get all instances at once
+  #
+  # @return [Hash]
+  def to_h
+    @items
+      .map { |k, v| [k, @cache[k] ||= resolver.classify(v)] }
+      .yield_self { |results| Hash[results] }
+      .yield_self { |items| Hash[items.collect { |k, v| [k, v.new] }] }
+  end
+
+  # Returns ``true`` if the given key is present
+  #
+  # @param [Symbol|String] name
+  # @return [Boolean]
+  def member?(name)
+    name = name.to_sym
+
+    @items.member?(name)
+  end
+
+  protected
+
+  # @return [Resolver]
+  attr_reader :resolver
+
+  # Base items, before (if needed) resolution.
+  #
+  # @return [Hash]
+  attr_reader :items
+
+  # Used to avoid classes resolution.
+  #
+  # @return [Hash]
+  attr_reader :cache
+end

data/lib/kamaze/project/tools_provider/resolver.rb

@@ -0,0 +1,42 @@
+# 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_provider'
+require_relative '../../project/concern/helper'
+
+class Kamaze::Project::ToolsProvider
+  class Resolver
+  end
+end
+
+# Provide class name resolution
+class Kamaze::Project::ToolsProvider::Resolver
+  include Kamaze::Project::Concern::Helper
+
+  def initialize
+    # @type [Kamaze::Project::Helper::Inflector]
+    @inflector = helper.get(:inflector)
+  end
+
+  # Resolve given class path
+  #
+  # @see Kamaze::Project::Helper::Inflector
+  # @param [Symbol|String] klass
+  # @return [Class]
+  def resolve(klass)
+    @inflector.resolve(klass)
+  end
+
+  # Retrieve ``Class`` if necessary with given identifier
+  #
+  # @param [String|Symbol|Class] klass
+  # @return [Class]
+  def classify(klass)
+    klass.is_a?(Class) ? klass : self.resolve(klass)
+  end
+end

data/lib/kamaze/project/version.rb

@@ -0,0 +1,104 @@
+# 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 '../project'
+
+require 'yaml'
+require 'pathname'
+require 'dry/inflector'
+
+# Describe version using a YAML file.
+#
+# @see https://github.com/jcangas/version_info
+class Kamaze::Project::Version
+  # Get filepath used to parse version (YAML file).
+  #
+  # @return [Pathname|String]
+  attr_reader :file_name
+
+  # @param [String] file_name
+  def initialize(file_name = self.class.file_name)
+    @file_name = file_name.freeze
+
+    self.load_file
+        .map { |k, v| self.attr_set(k, v) }
+        .yield_self { |loaded| @data_loaded = loaded.to_h }
+  end
+
+  # Denote version has enough (mninimal) attributes defined.
+  #
+  # @return [Boolean]
+  def valid?
+    ![:major, :minor, :patch]
+      .map { |method| public_send(method) }
+      .map { |v| v.to_s.empty? ? nil : v }
+      .include?(nil)
+  rescue NameError
+    false
+  end
+
+  # @return [String]
+  def to_s
+    [major, minor, patch].join('.')
+  end
+
+  # @return [Hash]
+  def to_h
+    data_loaded.clone.freeze
+  end
+
+  # Return the path as a String.
+  #
+  # @see https://ruby-doc.org/stdlib-2.5.0/libdoc/pathname/rdoc/Pathname.html#method-i-to_path
+  # @return [String]
+  def to_path
+    file_name.to_s
+  end
+
+  class << self
+    # Get default filename.
+    #
+    # @return [Pathname]
+    def file_name
+      Pathname.new(__dir__).join('version.yml')
+    end
+  end
+
+  protected
+
+  attr_reader :data_loaded
+
+  # @return [Hash]
+  def load_file
+    YAML.load_file(file_name).yield_self do |data|
+      data == false ? {} : data
+    end
+  rescue Errno::ENOENT
+    {}
+  end
+
+  # Define attribute (as ``ro`` attr) and set value.
+  #
+  # @param [String|Symbol] attr_name
+  # @param [Object] attr_value
+  # @return [Array]
+  def attr_set(attr_name, attr_value)
+    inflector = Dry::Inflector.new
+    attr_name = inflector.underscore(attr_name.to_s)
+
+    self.singleton_class.class_eval do
+      attr_accessor attr_name
+
+      protected "#{attr_name}="
+    end
+
+    self.__send__("#{attr_name}=", attr_value.freeze)
+
+    [attr_name, attr_value.freeze].freeze
+  end
+end