grouik 1.0.0

data/src/lib/grouik/loader.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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 'benchmark'
+require 'pathname'
+require 'ostruct'
+
+require 'grouik/concerns'
+
+# Main class loader
+#
+# loads files during ``Grouik::Loader#load_all``
+class Grouik::Loader
+  attr_accessor :basedir
+  attr_accessor :ignores
+  attr_reader   :paths
+
+  attr_reader   :attempts
+  attr_reader   :errors
+  attr_reader   :stats
+
+  include Grouik::Concerns::Helpable
+
+  def initialize
+    self.basedir = '.'
+    self.ignores = []
+
+    @loadeds   = []
+    @errors    = {}
+    @loadables = []
+    @attempts  = 0
+    @stats     = nil
+
+    return self unless block_given?
+
+    yield self
+    register
+  end
+
+  # @param [Array<String|Regexp>] ignores
+  def ignores=(ignores)
+    @ignores = helpers.get(:loader).make_ignores(ignores)
+  end
+
+  # @param [Array<String>] paths
+  def paths=(paths)
+    @paths = paths.to_a.map { |path| Pathname.new(path.to_s) }
+  end
+
+  # @return [Array<Pathname>]
+  def paths
+    (@paths || (@paths.empty? ? ['.'] : @paths)).clone
+  end
+
+  # Register paths
+  #
+  # @return [self]
+  def register
+    helpers.get(:loader).register_paths(basedir, @paths)
+
+    self
+  end
+
+  # Get loadables
+  #
+  # @return [Array<Grouik::Loadable>]
+  def loadables
+    if @loadables.empty?
+      self.basedir do
+        @loadables = helpers.get(:loader)
+                            .collect_loadables(paths)
+                            .ignores(ignores)
+      end
+    end
+
+    @loadables.clone
+  end
+
+  # @return [Pathname]
+  def basedir
+    Dir.chdir(helpers.get(:loader).pwd.join(basedir)) { yield } if block_given?
+
+    Pathname.new(@basedir)
+  end
+
+  # @return [self]
+  def load_all
+    return @loadeds.clone unless @loadeds.empty?
+
+    loadables = self.loadables
+    @loadeds  = []
+    @errors   = {}
+
+    @stats = Benchmark.measure do
+      loop do
+        loadables = process_loadables(loadables)
+        break if loadables.nil? or (loadables and loadables.empty?)
+      end
+    end
+    @loadeds.compact
+    self
+  end
+
+  # Format using a formatter
+  #
+  # @param [Hash] options
+  # @return [String]
+  def format(options = {})
+    Grouik.get(:formatter).format(load_all.loadables, options).to_s
+  end
+
+  def loaded?
+    self.loadables.size == @loadeds.size
+  end
+
+  # @return [Fixnum]
+  def attempts_maxcount
+    (self.loadables.size**2) + 1
+  end
+
+  protected
+
+  def process_loadables(processables)
+    processables.each_with_index do |loadable, index|
+      return [] if attempts >= attempts_maxcount or processables.empty?
+
+      @attempts += 1
+      loaded = nil
+      begin
+        loaded = loadable.load(helpers.get(:loader).pwd.join(basedir))
+      rescue StandardError => e
+        unless @errors[loadable.to_s]
+          @errors[loadable.to_s] = OpenStruct.new(
+            source: loadable.to_s,
+            message: e.message.lines[0].strip.freeze,
+            line: e.backtrace[0].split(':')[1],
+            error: e
+          ).freeze
+        end
+        next
+      end
+
+      next if loaded.nil?
+
+      @loadeds.push(processables.delete_at(index))
+      # when loadable is loaded, then error is removed
+      @errors.delete(loadable.to_s)
+    end
+    processables
+  end
+end

data/src/lib/grouik/output/message.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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.
+
+# Describe a message (sent on a IO as STDOUT/STDERR)
+class Grouik::Output::Message
+  attr_accessor :content
+  attr_accessor :type
+  attr_accessor :stream
+
+  def initialize
+    yield self if block_given?
+  end
+
+  # @param content [String]
+  def content=(content)
+    @content = content.to_s.empty? ? nil : content.to_s
+  end
+
+  # @param stream [IO]
+  def stream=(stream)
+    @stream = stream.clone
+  end
+
+  # @return [IO]
+  def stream
+    @stream || STDOUT.clone
+  end
+
+  # @raise [RuntimeError]
+  # @return [self]
+  def send
+    attrs = [:stream, :content, :type]
+    attrs.each do |attr|
+      raise 'attributes %s must be set' % attrs if public_send(attr).nil?
+    end
+
+    messager_class.new(stream, content.to_s).output(type)
+    self
+  end
+
+  protected
+
+  # @return [Grouik::Output::Messager]
+  def messager_class
+    require '%s/messager' % __dir__
+
+    Grouik::Output::Messager
+  end
+end

data/src/lib/grouik/output/messager.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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.
+
+# Provide a wrapper over ``Rainbow``
+class Grouik::Output::Messager
+  attr_accessor :stream
+  attr_accessor :content
+
+  def initialize(stream = STDOUT, content = nil)
+    @stream = stream
+    self.content = content
+  end
+
+  def content=(content)
+    @content = content.to_s
+  end
+
+  # @todo Catch ``NoMethodError`` or similar error
+  # @return [self]
+  def output(type)
+    stream.puts self.format_as(type)
+
+    self
+  end
+
+  class << self
+    # @return [self]
+    def output(stream, type)
+      self.new(stream, content).output(type)
+    end
+
+    # Defines available formats
+    #
+    # @return [Hash]
+    def formats
+      {
+        status_success: {
+          background: :green,
+          color: :black,
+        },
+        status_failure: {
+          background: :red,
+          color: :black,
+        },
+        error: {
+          color: :red,
+        }
+      }
+    end
+  end
+
+  # @param type [Symbol|String]
+  # @return [Rainbow::Presenter, Rainbow::NullPresenter]
+  def format_as(type)
+    colorize(self.class.formats[type.to_sym])
+  end
+
+  # Denote output is colorizable (``tty?``)
+  def colorizable?
+    stream.tty?
+  end
+
+  protected
+
+  # Get a colorizable (almost a wrapper over ``Rainbow``) content instance
+  #
+  # @return [Rainbow::Presenter, Rainbow::NullPresenter]
+  def colorizable
+    require 'rainbow'
+
+    Rainbow.enabled = colorizable?
+    Rainbow::Wrapper.new(colorizable?).wrap(content)
+  end
+
+  def colorize(format = {})
+    colorizable = self.colorizable.clone
+    format.to_h.each { |k, v| colorizable = colorizable.public_send(k, v) }
+
+    colorizable
+  end
+end

data/src/lib/grouik/output.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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.
+
+module Grouik::Output
+  [:message].each do |req|
+    require '%s/output/%s' % [__dir__, req]
+  end
+end

data/src/lib/grouik/process.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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 'grouik/concerns'
+
+# Intended to wrap ``Grouik::Loader``
+#
+# Easify reusability through ``Grouik::Cli``
+# or as standalone (for example in a Rake task)
+#
+# Sample of use:
+#
+# ~~~~
+# task 'src/ceres.rb' do
+#  require 'grouik'
+#
+#  Grouik.process do |process|
+#    process.verbose  = false
+#    process.paths    = ['lib']
+#    process.basedir  = 'src'
+#    process.output   = 'src/ceres.rb'
+#    process.template = 'src/ceres.tpl'
+#  end.on_failure { exit Errno::ECANCELED::Errno }
+# end
+# ~~~~
+class Grouik::Process
+  attr_accessor :template
+  attr_accessor :bootstrap
+  attr_accessor :verbose
+  attr_reader   :output
+
+  include Grouik::Concerns::Helpable
+
+  def initialize
+    @output    = nil
+    @template  = nil
+    @bootstrap = nil
+    @verbose   = false
+
+    @loader = Grouik::Loader.new
+    yield self if block_given?
+    @loader.register
+  end
+
+  def verbose?
+    !!@verbose
+  end
+
+  # @param [Pathname|String] output
+  # @return [Object]
+  def output=(output)
+    @output = output.is_a?(String) ? Pathname.new(output) : output
+  end
+
+  # @return [self]
+  # @todo Do not suppress exceptions
+  def process
+    @output.write('') if @output.respond_to?(:file?) and !@output.exist?
+    if bootstrap
+      begin
+        require bootstrap if bootstrap
+      rescue NameError
+      rescue LoadError
+      end
+    end
+
+    output = @loader.format(template: @template)
+    display_errors
+    # avoid to break previouly written file in case of failure
+    @output.write(output) if success?
+
+    self
+  end
+
+  # @param [Hash] options
+  def format(options = {})
+    @loader.format(options)
+  end
+
+  # Errors encountered during process
+  #
+  # @return [Hash]
+  def errors
+    loader.errors
+  end
+
+  # Denote errors encountered
+  #
+  # @return [Boolean]
+  def errors?
+    errors.empty? ? false : true
+  end
+
+  # Display encountered errors
+  #
+  # @return [self]
+  def display_errors
+    helpers.get(:process).display_errors(self)
+
+    self
+  end
+
+  # Display status
+  #
+  # @return [self]
+  def display_status
+    helpers.get(:process).display_status(self)
+
+    self
+  end
+
+  # Denote process is a success
+  #
+  # @return [Boolean]
+  def success?
+    loader.loaded? and !errors?
+  end
+
+  # Denote process is a failure
+  #
+  # @return [Boolean]
+  def failure?
+    !success?
+  end
+
+  # Block executed on failure
+  #
+  # @yield [self] Block executed when errors have been encountered
+  # @return [self]
+  def on_failure
+    yield(self) if failure?
+
+    self
+  end
+
+  # Block executed on success
+  #
+  # @yield [self] Block executed when process is a success
+  # @return [self]
+  def on_success
+    yield(self) if success?
+
+    self
+  end
+
+  # Provides access to public accessors
+  def method_missing(method, *args, &block)
+    if respond_to_missing?(method)
+      @loader.public_send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    result = loader_accessors.include?(method.to_sym)
+    unless result
+      return super if include_private
+    end
+
+    result
+  end
+
+  # Get loader
+  #
+  # @return [Grouik::Loader]
+  def loader
+    @loader.clone.freeze
+  end
+
+  protected
+
+  # Get loader public attributes
+  #
+  # @return [Array]
+  def loader_attributes
+    loader.public_methods
+          .grep(/^\w+=$/)
+          .map { |m| m.to_s.gsub(/=$/, '').to_sym }
+  end
+
+  # Get loader public accessors
+  #
+  # @return [Array]
+  def loader_accessors
+    loader_attributes + loader_attributes.map { |m| ('%s=' % m).to_sym }
+  end
+end

data/src/lib/grouik/types.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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.
+
+# Special types in use
+module Grouik::Types
+end
+
+# Get filtered loadables, using ignores regexp
+#
+# @return [Array<Grouik::Loadable>]
+class Grouik::Types::Loadables < Array
+  # Removes ignored patterns (regexps)
+  #
+  # @param [Array<Regexp>] regexps
+  # @return [self]
+  def ignores(regexps)
+    filter = lambda do |loadable, regexps|
+      regexps.each do |regexp|
+        return true if loadable and regexp.match(loadable.to_s)
+      end
+
+      false
+    end
+
+    self.clone.delete_if do |loadable|
+      filter.call(loadable, regexps)
+    end
+  end
+
+  # @return [self]
+  def add_file(file, basedir = nil)
+    self.push(make_loadable(basedir, file))
+
+    self
+  end
+
+  # @return [Grouik::Loadable]
+  def make_loadable(*args)
+    Grouik.get(:loadable_factory).call(*args)
+  end
+end

data/src/lib/grouik/version_info.yml

@@ -0,0 +1,16 @@
+---
+major: 1
+minor: 0
+patch: 0
+authors: ['Dimitri Arrigoni']
+email: 'dimitri@arrigoni.me'
+date: '2017-03-28'
+summary: 'Grouik!'
+description: 'Simple require file generator'
+licenses: ['GPL-3.0']
+license: 'Copyright (C) 2017 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.'
+homepage: 'https://github.com/SwagDevOps/ruby-grouik'

data/src/lib/grouik.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017 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 'active_support/inflector'
+require 'version_info'
+
+$LOAD_PATH.unshift Pathname.new(__dir__)
+
+# Produce a ``require`` file, resolving classes dependencies
+#
+# Sample of use:
+#
+# ~~~~
+# Grouik.process do |process|
+#      process.basedir   = './path/to/my/project'
+#      process.paths     = ['lib']
+#      process.ignores   = []
+#      process.output    = '/dev/stdout'
+#      process.template  = 'lib/main'
+#      process.bootstrap = nil
+#      process.verbose   = true
+# end.success? ? 0 : 1
+# ~~~~
+#
+# or using command line.
+module Grouik
+  require 'grouik/helpers'
+
+  class << self
+    # @return [Hash]
+    def version_info
+      unless self.const_defined?(:VERSION)
+        include VersionInfo
+
+        VersionInfo.file_format = :yaml
+        VERSION.file_name = self.version_filepath
+        VERSION.load
+      end
+
+      VERSION.to_hash.freeze
+    end
+
+    protected
+
+    # Get path to the ``version`` file
+    #
+    # @return [Pathname]
+    def version_filepath
+      name = ActiveSupport::Inflector.underscore(self.name)
+
+      Pathname.new(__dir__).join(name, 'version_info.yml')
+    end
+  end
+
+  # registers version_info
+  self.version_info
+  # loads sub(modules|classes)
+  [:loader, :loadable, :formatter, :process, :output].each do |r|
+    require '%s/%s' % [ActiveSupport::Inflector.underscore(name), r]
+  end
+
+  @components = {
+    process_class: Process,
+    formatter: Formatter,
+    helpers: Grouik::Helpers,
+    inflector: ActiveSupport::Inflector,
+    messager_factory: ->(&block) { Output::Message.new(&block) },
+    loadable_factory: ->(base, path) { Loadable.new(base, path) },
+  }
+
+  class << self
+    attr_accessor :components
+
+    # Access to components
+    #
+    # @param name [String, Symbol] name of component
+    # @return [Object]
+    # @see Grouik.components
+    def get(name)
+      components.fetch(name.to_sym)
+    end
+
+    # Initialize a Process and process it
+    #
+    # @return [Grouik::Process]
+    def process(&block)
+      self.get(:process_class).new(&block).process
+    end
+
+    def message(&block)
+      self.get(:messager_factory).call(&block).send
+      self
+    end
+  end
+end