grouik 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83f25d1bc75415d52ac220b352808fc496eedbf1
+  data.tar.gz: 8315a3d896b9556d0b716a27855c8d2fd87c0ab8
+SHA512:
+  metadata.gz: b775cb7d82ec784f43d903ad6a36a98daa7de4db8ff343a83833cda9baff530c72d2a73639e51dd95dafa864f40e0033d603da89b10566ac60e1a95df7a60b2c
+  data.tar.gz: cc9ceee6b5db5d7c98083ccfe7fb954f61f70a73a4a81d1e706402c9a9caa44ec5df9d3b5d4f292c84e5a821d7e16c6840d8f4a55e789ed5acc9dcb16d6b03fe

data/src/bin/grouik

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# 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'
+$0 = Pathname.new(__FILE__).basename.to_s
+
+# run bundled in a development context -------------------------------
+if Pathname.new(__dir__).join('..', '..', '%s.gemspec' % $PROGRAM_NAME).file?
+  require 'rubygems'
+  require 'bundler'
+  Bundler.setup(:default)
+end
+
+# require lib requirements -------------------------------------------
+[nil, :cli].each do |r|
+  req = r ? "#{$PROGRAM_NAME}/#{r}" : $PROGRAM_NAME
+  begin
+    require Pathname.new(__dir__).join('..', 'lib', '%s' % req)
+  rescue LoadError
+    begin
+      require req
+    rescue LoadError
+      require 'rubygems'
+      require req
+    end
+  end
+end
+
+# process command line options and run -------------------------------
+exit Grouik::Cli.run

data/src/lib/grouik/cli.rb

@@ -0,0 +1,172 @@
+# 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 'optparse'
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+
+require 'grouik' unless defined?(Grouik)
+require 'grouik/concerns'
+
+# Grouik command line interface
+#
+# Provides a ready to use program, based on ``Grouik`` library
+class Grouik::Cli
+  attr_reader :argv
+  attr_reader :options
+  attr_reader :arguments
+
+  include Grouik::Concerns::Helpable
+
+  class << self
+    # Program name
+    #
+    # @return [String]
+    def program_name
+      Pathname.new($PROGRAM_NAME).basename('.rb').to_s
+    end
+
+    # Run
+    #
+    # @param [Array] argv
+    def run(argv = ARGV)
+      self.new(argv).run
+    end
+
+    # default options
+    def defaults
+      {
+        stats: true,
+        paths: ['.'],
+        basedir: '.',
+        output: STDOUT,
+        ignores: [],
+        require: nil,
+        template: nil,
+      }
+    end
+  end
+
+  # @return [String]
+  def program_name
+    self.class.program_name
+  end
+
+  # Constructor
+  #
+  # @param [Array] argv
+  def initialize(argv = ARGV)
+    @argv = argv.clone
+    @options = self.class.defaults
+    # @options = config unless config.empty?
+    @arguments = []
+  end
+
+  # Provide an ``OptionParser``
+  #
+  # @return [OptionParser]
+  def parser
+    parser = helpers.get(:cli).make_parser(@options)
+    parser.banner = 'Usage: %s [OPTION]... [FILE]...' % program_name
+
+    parser
+  end
+
+  # Parse command line options
+  #
+  # Abort process (error code SHOULD BE ``22``) on invalid option
+  #
+  # @return [self]
+  def parse!
+    argv = self.argv.clone
+    begin
+      parser.parse!(argv)
+    rescue OptionParser::InvalidOption
+      STDERR.puts(parser)
+      exit(Errno::EINVAL::Errno)
+    end
+    @arguments = argv
+    # @options = prepare_options(@options)
+    self
+  end
+
+  # Get processable items (based on command arguments), used during execution
+  #
+  # @return [Array<OpenStruct>]
+  def processables
+    processables = []
+    if arguments.empty?
+      processables[0] = OpenStruct.new(
+        path: Pathname.new(Dir.pwd),
+        options: options,
+        'file?' => false
+      )
+    else
+      arguments.each do |filepath|
+        config = helpers.get(:cli).read_config(filepath)
+
+        processables << OpenStruct.new(
+          path: Pathname.new(filepath).dirname,
+          file: Pathname.new(filepath),
+          options: config,
+          'file?' => true
+        )
+      end
+    end
+
+    processables.map(&:freeze)
+  end
+
+  # Execute CLI and return exit code
+  #
+  # @return [Fixnum]
+  def run
+    parse!
+
+    if options[:version]
+      STDOUT.puts helpers.get(:cli).version_chapter
+      return 0
+    end
+
+    processables.each do |processable|
+      Dir.chdir(processable.path) do
+        process(processable.options)
+      end
+    end
+    0
+  end
+
+  protected
+
+  # Initiate and run a new ``Process`` from options
+  #
+  # @param [Hash] options
+  # @return [Grouik::Process]
+  def process(options)
+    options = helpers.get(:cli).prepare_options(options)
+
+    process = Grouik.process do |process|
+      process.basedir   = options.fetch(:basedir)
+      process.paths     = options.fetch(:paths)
+      process.ignores   = options[:ignores]
+      process.output    = options.fetch(:output)
+      process.template  = options[:template]
+      process.bootstrap = options[:require]
+    end
+
+    process.on_success do |process|
+      process.display_status if options[:stats]
+    end.on_failure do |process|
+      process.display_status if options[:stats]
+      exit Errno::ECANCELED::Errno
+    end
+
+    process
+  end
+end

data/src/lib/grouik/concerns/helpable.rb

@@ -0,0 +1,19 @@
+# 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 ``helpers`` method
+module Grouik::Concerns::Helpable
+  extend ActiveSupport::Concern
+
+  # Loads helper
+  #
+  # @return [Grouik::Helpers]
+  def helpers
+    Grouik.get(:helpers)
+  end
+end

data/src/lib/grouik/concerns.rb

@@ -0,0 +1,16 @@
+# 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.
+
+# Concerns in use
+module Grouik::Concerns
+  require 'active_support/concern'
+
+  [:helpable].each do |concern|
+    require 'grouik/concerns/%s' % concern
+  end
+end

data/src/lib/grouik/formatter.rb

@@ -0,0 +1,67 @@
+# 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 'tenjin'
+
+# Formatter used to render loadables
+class Grouik::Formatter
+  attr_reader :options
+  attr_reader :loadables
+  attr_reader :template
+
+  def initialize(loadables, options = {})
+    @loadables = loadables
+    @options   = options
+    @formatted = nil
+    @engine    = Tenjin::Engine.new(cache: false)
+    @template  = options[:template]
+  end
+
+  # @return [Pathname|nil]
+  def template
+    @template ? Pathname.new(@template).realpath : nil
+  end
+
+  def to_s
+    formatted
+  end
+
+  def format
+    @formatted = @formatted.nil? ? output : @formatted
+
+    return self
+  end
+
+  def formatted
+    format
+    @formatted.clone
+  end
+
+  class << self
+    def format(loadables, options = {})
+      self.new(loadables, options).format
+    end
+  end
+
+  protected
+
+  def output
+    items = loadables.to_a.map { |i| "require '#{i}'" }
+
+    return items.join("\n") + "\n" unless template
+
+    context = {
+      requirement: lambda do |indent = nil|
+        items.map { |i| '%s%s' % [indent, i] }.join("\n")
+      end
+    }
+
+    @engine.render(template.to_s, context)
+  end
+end

data/src/lib/grouik/helpers/cli.rb

@@ -0,0 +1,102 @@
+# 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 'optparse'
+
+# Cli helper, see ``Grouik::Cli``
+class Grouik::Helpers::Cli
+  # Provide an ``OptionParser``
+  #
+  # @param [Hash] options
+  # @return [OptionParser]
+  def make_parser(options = {})
+    parser = OptionParser.new
+
+    {
+      basedir: ['--basedir=BASEDIR', 'Basedir [%s]' % options[:basedir]],
+      output: ['-o=OUTPUT', '--output=OUTPUT', 'Output [/dev/stdout]'],
+      require: ['-r=REQUIRE', '--require=REQUIRE',
+                'Required file on startup'],
+      ignores: ['--ignores x,y,z', Array, 'Ignores'],
+      paths: ['--paths x,y,z', Array, 'Paths'],
+      stats: ['--[no-]stats', 'Display some stats'],
+      version: ['--version', 'Display the version and exit']
+    }.each do |k, v|
+      parser.on(*v) { |o| options[k] = o }
+    end
+
+    parser
+  end
+
+  # Prepare options
+  #
+  # Process values in order to easify their use
+  #
+  # @param [Hash] options
+  # @return [Hash]
+  def prepare_options(options)
+    [:require, :output].each do |k|
+      next unless options[k]
+      begin
+        options[k] = Pathname.new(options[k])
+      rescue TypeError
+        next
+      end
+      unless options[k].absolute?
+        options[k] = Pathname.new(Dir.pwd).join(options[k])
+      end
+    end
+
+    [:ignores, :paths].each do |k|
+      next unless options[k]
+      options[k] = [options[k]] if options[k].is_a? String
+
+      options[k] = options[k].to_a.map { |s| /#{s}/ } if :ignores == k
+    end
+
+    options
+  end
+
+  # Get the license
+  #
+  # @return [String]
+  def license
+    Grouik.version_info[:license].to_s.gsub(/\n{3}/mi, "\n\n")
+  end
+
+  # Get a displayable version
+  #
+  # Some inspiration taken from ``wget --version``
+  #
+  # @return [String]
+  def version_chapter
+    ['%s %s on %s' % [Grouik.name, Grouik::VERSION, host_os],
+     nil,
+     license].join("\n")
+  end
+
+  # @return [String]
+  def host_os
+    RbConfig::CONFIG['host_os']
+  end
+
+  # Read a config file
+  #
+  # @param [String] path
+  # @return [Hash]
+  def read_config(path)
+    file = Pathname.new(path.to_s)
+    config = YAML.safe_load(file.read)
+
+    h = config.each_with_object({}) do |(k, v), n|
+      n[k.intern] = v
+    end
+
+    h
+  end
+end

data/src/lib/grouik/helpers/loader.rb

@@ -0,0 +1,72 @@
+# 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 'grouik/types'
+
+# Loader helper, see ``Grouik::Loader``
+class Grouik::Helpers::Loader
+  # Make loadables
+  #
+  # @@return [Grouik::Types::Loadables]
+  def make_loadables
+    Grouik::Types::Loadables.new
+  end
+
+  # Make ignores
+  #
+  # @param [Array<String|Regexp>] input
+  # @return [Array<Regexp>]
+  def make_ignores(input)
+    input.to_a.map { |s| s.is_a?(Regexp) ? s : /^#{s}$/ }
+  end
+
+  # Register paths
+  #
+  # @param [String] basedir
+  # @param [Array<String|Pathname>] paths
+  def register_paths(basedir, paths)
+    basedir = Pathname.new(basedir)
+
+    paths.reverse.each do |path|
+      $LOAD_PATH.unshift basedir.realpath.join(path).to_s
+    end
+  end
+
+  # @return [Pathname]
+  def pwd
+    Pathname.new(Dir.pwd)
+  end
+
+  # @param [String] path
+  # @return [Array<Pathname>]
+  def files_in_path(path)
+    loaddir = path.to_s
+    basereg = %r{^#{Regexp.quote(loaddir)}\/}
+
+    Dir.glob(path.join('**/*.rb'))
+      .sort
+      .map { |file| file.gsub(basereg, '') }
+      .map { |file| Pathname.new(file) }
+  end
+
+  # Collect loadables by paths
+  #
+  # @param [Array<String>] paths
+  # @return [Grouik::Types::Loadables]
+  def collect_loadables(paths)
+    loadables = self.make_loadables
+
+    paths.each do |path|
+      self.files_in_path(path).each do |file|
+        loadables = loadables.add_file(file, path.to_s)
+      end
+    end
+
+    loadables
+  end
+end

data/src/lib/grouik/helpers/process.rb

@@ -0,0 +1,82 @@
+# 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.
+
+# Helper providing outputs (mostly useful in a CLI/Rake context)
+#
+# Main methods are ``display_errors`` and ``display_status``
+class Grouik::Helpers::Process
+  # Display loading errors
+  #
+  # @param [Grouik::Process] process
+  # @return [self]
+  def display_errors(process)
+    process.errors.each do |_k, struct|
+      Grouik.message do |m|
+        m.stream  = STDERR
+        m.type    = 'error'
+        m.content = ('%s:%s: %s' % [
+                       struct.source,
+                       struct.line,
+                       struct.message,
+                     ])
+      end
+    end
+  end
+
+  # Display (on ``STDERR``) loader related statistics
+  #
+  # @param [Grouik::Process] process
+  # @return [self]
+  def display_status(process)
+    message  = '%s: %s files; %s iterations; %s errors (%.4f) [%s]'
+    loader   = process.loader
+
+    Grouik.message do |m|
+      m.stream  = STDERR
+      m.type    = 'status_%s' % status(process)
+      m.content = (message %
+                   [
+                     status(process).to_s.capitalize,
+                     loader.loadables.size,
+                     loader.attempts,
+                     loader.errors.size,
+                     loader.stats ? loader.stats.real : 0,
+                     format_filepath(process.output)
+                   ])
+    end
+    self
+  end
+
+  # Denote status from process
+  #
+  # @return [Symbol]
+  def status(process)
+    statuses = { true => :success, false => :failure }
+
+    statuses.fetch(process.success?)
+  end
+
+  protected
+
+  # Format a filepath with a ``require`` format
+  #
+  # @param [Pathname|String|Object] filepath
+  def format_filepath(filepath)
+    filepath = filepath.to_s
+
+    $LOAD_PATH.each do |path|
+      regexp = %r{^#{Regexp.quote(path.to_s)}\/}
+      if regexp.match(filepath)
+        filepath.gsub!(regexp, '').gsub!(/\.rb$/, '')
+        break
+      end
+    end
+
+    filepath
+  end
+end

data/src/lib/grouik/helpers.rb

@@ -0,0 +1,50 @@
+# 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'
+
+# Helpers (loader)
+#
+# Provide easy access to helpers
+module Grouik::Helpers
+  class << self
+    # Retrieve helper by name
+    #
+    # @param [String|Symbol] target
+    # @return [Object]
+    def get(target)
+      class_name = self.classify(target)
+
+      require load_dir.join(target.to_s) unless const_defined?(class_name)
+
+      inflector.constantize(class_name).new
+    end
+
+    # Directory where helpers stand
+    #
+    # @return [Pathname]
+    def load_dir
+      Pathname.new(__FILE__.gsub(/\.rb$/, ''))
+    end
+
+    protected
+
+    # @return ActiveSupport::Inflector
+    def inflector
+      ActiveSupport::Inflector
+    end
+
+    # Transform string
+    #
+    # return [String]
+    def classify(target)
+      '%s::%s' % [name, inflector.classify(target.to_s.gsub('/', '::'))]
+    end
+  end
+end

data/src/lib/grouik/loadable.rb

@@ -0,0 +1,51 @@
+require 'pathname'
+
+# Describe a loable item (Ruby file)
+class Grouik::Loadable
+  attr_reader :base
+  attr_reader :path
+  attr_reader :basedir
+
+  # @param [String] base
+  # @param [String] path
+  # @param [String] basedir
+  def initialize(base, path, basedir = '.')
+    @base = Pathname.new(base)
+    @path = path
+    @basedir = Pathname.new(basedir).realpath
+  end
+
+  # @param [Boolean] format format as loadable from ``$LOAD_PATH``
+  # @return [String]
+  def path(format = false)
+    path = @path.to_s
+
+    {
+      true  => path,
+      false => basedir.join(base, path).to_s
+    }[(format and loadable?)].gsub(/\.rb$/, '')
+  end
+
+  # @return [String]
+  def to_s
+    path(true)
+  end
+
+  # @return [Boolean]
+  def load(from = nil)
+    path = from ? Pathname.new(from).join(self.path) : self.path
+
+    return require path
+  end
+
+  def loadable?
+    self.class.paths.include?(basedir.join(base).to_s)
+  end
+
+  class << self
+    # @return [Array<String>]
+    def paths
+      $LOAD_PATH.map(&:to_s)
+    end
+  end
+end