ultra_command_line 0.4.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7cd80a8c2740619c3fbba59d3d76fee87f6763c
+  data.tar.gz: ab0a550b07ac26bfeae400c9d0a0002c563efe75
+SHA512:
+  metadata.gz: c8a55f46171afd5a91ea53301915efb2f5f92f61cc87f91f2c84b7638ffebc5788b49a621c8023282549552ffc146b39f1c0c3d2d2e89f75b88f14682cbc0ff3
+  data.tar.gz: 979c60dffeb59988e17a490064352ee18601fc14a02d9fc4674362077bab055cef6433b760c51268faf0b131763d2454cc9648e90bf125f85b71ca890224ba48

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+/.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.15.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://gems.nanonet'
+
+# Specify your gem's dependencies in ultra_command_line.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+UltraCommandLine
+================
+
+This gem is basically a wrapper around the `slop` gem which generates slop options from a YAML definition file.
+This is most probably only used by the `climatic` gem
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ultra_command_line'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ultra_command_line
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://gitlab.com/lbriais/ultra_command_line.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ultra_command_line'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docs/command_definition.puml

@@ -0,0 +1,160 @@
+@startuml
+
+
+skinparam class {
+    backgroundColor<<module>> LightGray
+    backgroundColor<<external>> Gray
+}
+
+set namespaceSeparator ::
+
+
+namespace Commands {
+
+    class OptionDefinition {
+        Defines one command line option,
+        wrapping around slop features.
+        +{method}:to_slop_options
+    }
+
+    class SubCommand {
+        Represents a a-la-git sub-command
+        ..
+        +{field}name
+    }
+
+    class MainCommand << (M, #ADD1B2) module>> {
+        Represents the main command.
+        Basically a Subcommand but
+        with an empty name.
+        ..
+    }
+
+    class Factory << (M, #ADD1B2) module>> {
+        How to create a SubCommand from
+        a definition hash.
+        ..
+        +{method}:from_hash
+    }
+
+    class HelpFormatter << (M, #ADD1B2) module>> {
+        Builds help for a command.
+        ..
+        +{field}help_template
+        +{method}:help
+    }
+
+    class Validation << (M, #ADD1B2) module>> {
+        Checks the validity of options
+        defined.
+        ..
+        +{method}:valid?
+    }
+
+
+    class CommandLineParser <<(M, #ADD1B2) module>> {
+        Parses command-line
+        ..
+        +{field}cmd_line_args
+        +{method}:extra_arguments
+        +{method}:params_hash
+    }
+
+
+    SubCommand "1" *-- "n" OptionDefinition : "contains\nand\ncreates"
+    SubCommand -|> Factory  : extends
+    SubCommand --|> HelpFormatter  : includes
+    SubCommand -|> Validation  : includes
+    SubCommand --|> CommandLineParser  : includes
+
+    MainCommand ..|> SubCommand : "included\nfor main command\nat runtime"
+
+}
+
+
+namespace Manager {
+
+
+    class Base {
+        Manages completely the list of
+        options definition and how to find
+        a processor for a list of command
+        line parameters
+    }
+
+    class LayeredDefinition <<(M, #ADD1B2) module>> {
+        Wrapper around SuperStack::Manager
+        to manage "contributions" to the definition
+        with cache management.
+        ..
+        +{method}:definition_hash
+        +{method}:contribute_to_definition
+        +{method}:[]=
+    }
+
+    class ProcessorMatcher <<(M, #ADD1B2) module>> {
+        Determines a suitable list of potential
+        processors from the command-line
+        parameters
+        ..
+        +{method}:candidates
+    }
+
+    class Commands <<(M, #ADD1B2) module>> {
+        Manages a main command
+        and optionally sub commands.
+        ..
+        +{field}commands
+    }
+
+    class Factory <<(M, #ADD1B2) module>> {
+        How to create a Manager from
+        a definition hash.
+        ..
+        +{method}:from_hash
+    }
+
+    Base -|> ProcessorMatcher : includes
+    Base ---|> LayeredDefinition : includes
+    Base --|> Commands : includes
+    Base --|> Factory : extends
+}
+
+namespace Processors {
+    class Base
+
+    class Registration<<(M, #ADD1B2) module>>
+
+    Base -|> Registration : includes
+
+}
+
+
+namespace Utils {
+    class BasicLogger<<(M, #ADD1B2) module>>
+    class ErrorPropagation<<(M, #ADD1B2) module>>
+    class YamlFactory<<(M, #ADD1B2) module>> {
+        If your module or class implements
+        #from_hash, then including this module
+        will bring the ability to load it from
+        a yaml string or a yaml file.
+        ..
+            +{method}:from_yaml
+            +{method}:from_yaml_file
+    }
+}
+
+Manager::Commands "1" *---- "n" Commands::SubCommand : "contains\nand\ncreates"
+Manager::ProcessorMatcher "0" *- "n" Processors::Base
+
+Manager::Factory -|> Utils::YamlFactory : includes
+Commands::Factory -|> Utils::YamlFactory : includes
+
+Manager::Base        -|>  Utils::ErrorPropagation : includes
+Commands::SubCommand --|> Utils::ErrorPropagation : includes
+
+
+
+
+
+@enduml

data/lib/ultra_command_line.rb

@@ -0,0 +1,23 @@
+require 'slop'
+
+require 'ultra_command_line/version'
+require 'ultra_command_line/error'
+require 'ultra_command_line/utils/basic_logger'
+require 'ultra_command_line/utils/error_propagation'
+require 'ultra_command_line/utils/yaml_factory'
+
+
+module UltraCommandLine
+
+  extend UltraCommandLine::Utils::BasicLogger
+
+  def self.new_slop_options
+    Slop::Options.new underscore_flags: false
+  end
+
+end
+
+
+require 'ultra_command_line/commands/sub_command'
+require 'ultra_command_line/manager/base'
+

data/lib/ultra_command_line/commands/command_line_parser.rb

@@ -0,0 +1,34 @@
+module UltraCommandLine
+  module Commands
+
+    module CommandLineParser
+
+      def params_hash
+        parse_cmd_line_options.to_hash
+      end
+
+      def extra_arguments
+        parse_cmd_line_options.to_hash
+        @extra_arguments ||= []
+      end
+
+      private
+
+      def parse_cmd_line_options(options_definition = UltraCommandLine.new_slop_options)
+        parser = build_parser(options_definition)
+        hash = parser.parse cmd_line_args
+        # @cmd_line_args = cmd_line_args
+        @extra_arguments = parser.arguments
+        hash
+      end
+
+      def build_parser(options_definition)
+        options_definition.banner = banner
+        options.each { |option| option.to_slop_options options_definition }
+        Slop::Parser.new options_definition
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/commands/factory.rb

@@ -0,0 +1,31 @@
+module UltraCommandLine
+  module Commands
+
+    module Factory
+
+      DEFAULT_BANNER = ''.freeze
+
+      include UltraCommandLine::Utils::YamlFactory
+
+      def from_hash(definition_hash, factory_options = {})
+        name = factory_options.fetch :name, ''
+        options_definition_hash = definition_hash.fetch(:options, {})
+        manager = factory_options[:manager]
+        banner = definition_hash.fetch :banner, DEFAULT_BANNER
+        create_command name, options_definition_hash, banner, manager
+      end
+
+      private
+
+      def create_command(name, options_definition_hash, banner, manager)
+        options = options_definition_hash.map do |option_name, option_definition_hash|
+          option_type = option_definition_hash[:type].to_sym
+          UltraCommandLine::Commands::OptionDefinition.new option_name, option_type, option_definition_hash
+        end
+        new manager, name, banner, options: options
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/commands/help_formatter.rb

@@ -0,0 +1,43 @@
+module UltraCommandLine
+  module Commands
+
+    module HelpFormatter
+
+      DEFAULT_SEPARATOR_WIDTH = 80
+      DEFAULT_SEPARATOR_FILLER = '-'.freeze
+      DEFAULT_TITLE = 'Options'.freeze
+
+      attr_writer :separator_width, :separator_filler
+
+      def separator_width
+        @separator_width ||= DEFAULT_SEPARATOR_WIDTH
+      end
+
+      def title
+        name.nil? || name.empty? ? DEFAULT_TITLE : name
+      end
+
+      def separator_filler
+        @separator_filler ||= DEFAULT_SEPARATOR_FILLER
+      end
+
+      def help
+        output = []
+        output << banner
+        unless options.empty?
+          output << build_separator(title)
+          output.concat options.map(&:help_line)
+        end
+        output
+      end
+
+      private
+
+      def build_separator(title)
+        "#{separator_filler * 2} #{title} ".ljust separator_width, separator_filler
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/commands/main_command.rb

@@ -0,0 +1,10 @@
+module UltraCommandLine
+  module Commands
+
+    module MainCommand
+
+
+    end
+
+  end
+end

data/lib/ultra_command_line/commands/option_definition.rb

@@ -0,0 +1,68 @@
+module UltraCommandLine
+  module Commands
+
+    class OptionDefinition
+
+      DEFAULT_SUMMARY = 'Option summary not provided.'.freeze
+      attr_reader :name, :type
+      attr_reader :short_aliases, :long_aliases
+      attr_accessor :summary, :default, :description, :help, :dependencies, :incompatibilities
+
+      def initialize(name, type, options = {})
+        @name = name
+        @type = type
+        @summary = options.fetch(:summary, DEFAULT_SUMMARY)
+        @default = options.fetch(:default, nil)
+        @description = options.fetch(:description, summary)
+        @help = options.fetch(:help, description)
+        @global = options.fetch(:global, false)
+        @dependencies = options.fetch(:dependencies, [])
+        self.dependencies = dependencies.is_a?(Array) ? dependencies : [dependencies]
+        @incompatibilities = options.fetch(:incompatibilities, [])
+        self.incompatibilities = incompatibilities.is_a?(Array) ? incompatibilities : [incompatibilities]
+        short_aliases = options.fetch(:short_aliases, [])
+        long_aliases = options.fetch(:long_aliases, [])
+        self.short_aliases = (short_aliases.is_a?(Array) ? short_aliases : [short_aliases]).map &:to_sym
+        self.long_aliases = (long_aliases.is_a?(Array) ? long_aliases : [long_aliases]).map &:to_sym
+      end
+
+      def short_aliases=(options)
+        options.each do |option|
+          raise UltraCommandLine::Error, "Invalid short option defined for slop option '#{option}' !" unless option.to_s.size == 1
+        end
+        @short_aliases = options
+      end
+
+      def long_aliases=(options)
+        if options.include? name
+          raise UltraCommandLine::Error, "Inconsistent long options for slop option '#{name}' already defined as main option !"
+        end
+        @long_aliases = options
+        # long_aliases.unshift name
+      end
+
+      def global?
+        @global
+      end
+
+      def to_slop_options(slop_options = UltraCommandLine.new_slop_options)
+        one_letter_options = short_aliases.map.each { |option| "-#{option}" }
+        word_options = long_aliases.map.each { |option| "--#{option}" }
+        # The main option as last entry before description
+        option_def = word_options.concat(one_letter_options) << "--#{name}" << summary
+        option_def.concat [{ default: default }] unless default.nil?
+        slop_options.send type, *option_def
+        slop_options.banner = nil
+        slop_options
+      rescue NoMethodError => e
+        raise UltraCommandLine::Error, "Invalid option type '#{e.name}' for option '#{name}' !"
+      end
+
+      def help_line(slop_options = UltraCommandLine.new_slop_options)
+        to_slop_options(slop_options).to_s.gsub /\n/, ''
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/commands/sub_command.rb

@@ -0,0 +1,58 @@
+require 'ultra_command_line/commands/validation'
+require 'ultra_command_line/commands/command_line_parser'
+require 'ultra_command_line/commands/main_command'
+require 'ultra_command_line/commands/option_definition'
+require 'ultra_command_line/commands/help_formatter'
+require 'ultra_command_line/commands/factory'
+
+module UltraCommandLine
+  module Commands
+
+    class SubCommand
+
+      include UltraCommandLine::Utils::ErrorPropagation
+
+      extend UltraCommandLine::Commands::Factory
+
+      include UltraCommandLine::Commands::Validation
+      include UltraCommandLine::Commands::HelpFormatter
+      include UltraCommandLine::Commands::CommandLineParser
+
+
+      attr_reader :name, :manager, :options, :aliases
+      attr_accessor :banner
+
+      def initialize(manager,
+                     name = '',
+                     banner = UltraCommandLine::Commands::Factory::DEFAULT_BANNER,
+                     options: [])
+        @manager = manager
+        @name = name
+        if name.empty?
+          class << self; include UltraCommandLine::Commands::MainCommand; end
+        end
+        self.banner = banner
+        @options = options
+        @aliases = [self.name]
+      end
+
+      def root_command?
+        singleton_class.ancestors.include? UltraCommandLine::Commands::MainCommand
+      end
+
+      def cmd_line_args
+        self_view_of_manager_cmd_line_args
+      end
+
+      private
+
+      attr_writer :manager
+
+      def self_view_of_manager_cmd_line_args
+        manager.cmd_line_args_for_command self
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/commands/validation.rb

@@ -0,0 +1,80 @@
+module UltraCommandLine
+  module Commands
+
+    module Validation
+
+
+      def valid?(raise_error: false)
+        # return false_or_raise 'You have to successfully parse cmd line parameters before checking its validity !', raise_error: raise_error  if params_hash.nil?
+        begin
+          raise if params_hash.nil?
+        rescue
+          return false_or_raise 'You have to successfully parse cmd line parameters before checking its validity !', raise_error: raise_error
+        end
+        return false unless check_options_dependencies raise_error: raise_error
+        return false unless check_options_incompatibilities raise_error: raise_error
+        if name.empty?
+          unless root_command?
+            return false_or_raise 'Only a root command should not have a name !', raise_error: raise_error
+          end
+        end
+        true
+      end
+
+      private
+
+      def check_options_incompatibilities(raise_error: false)
+        options.each do |option|
+          if option_eligible_for_incompatibility_test? option
+            option.incompatibilities.each do |incompatibility|
+              unless params_hash[incompatibility.to_sym].nil? or params_hash[incompatibility.to_sym] == false
+                return false_or_raise "Command line option '#{option.name}' is incompatible with option '#{incompatibility}' !",
+                                      raise_error: raise_error,
+                                      error_type: UltraCommandLine::OptionDependencyError
+              end
+            end
+          end
+        end
+        true
+      end
+
+      def option_eligible_for_incompatibility_test?(option)
+        return false if option.incompatibilities.empty?
+        keys_str = params_hash.keys.map &:to_s
+        if keys_str.include? option.name
+          not (params_hash[option.name.to_sym].nil? or params_hash[option.name.to_sym] == false)
+        else
+          false
+        end
+      end
+
+
+      def check_options_dependencies(raise_error: false)
+        options.each do |option|
+          if option_eligible_for_dependency_test? option
+            option.dependencies.each do |dependency|
+              if params_hash[dependency.to_sym].nil? or params_hash[dependency.to_sym] == false
+                return false_or_raise "Command line option '#{option.name}' requires option '#{dependency}' !",
+                                      raise_error: raise_error,
+                                      error_type: UltraCommandLine::OptionDependencyError
+              end
+            end
+          end
+        end
+        true
+      end
+
+      def option_eligible_for_dependency_test?(option)
+        return false if option.dependencies.empty?
+        keys_str = params_hash.keys.map &:to_s
+        if keys_str.include? option.name
+          not (params_hash[option.name.to_sym].nil? or params_hash[option.name.to_sym] == false)
+        else
+          false
+        end
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/error.rb

@@ -0,0 +1,7 @@
+module UltraCommandLine
+
+  class Error < StandardError; end
+
+  class OptionDependencyError < Error; end
+
+end

data/lib/ultra_command_line/manager/base.rb

@@ -0,0 +1,35 @@
+require 'ultra_command_line/manager/factory'
+require 'ultra_command_line/manager/layered_definition'
+require 'ultra_command_line/manager/cmd_line_args'
+require 'ultra_command_line/manager/commands'
+require 'ultra_command_line/manager/processors'
+
+module UltraCommandLine
+  module Manager
+
+    class Base
+
+      include UltraCommandLine::Utils::ErrorPropagation
+
+      extend UltraCommandLine::Manager::Factory
+
+      include UltraCommandLine::Manager::LayeredDefinition
+      include UltraCommandLine::Manager::Commands
+
+      include UltraCommandLine::Manager::Processors
+
+      def initialize(commands = [])
+        @commands = commands
+      end
+
+      def definition_hash_to_commands
+        self.class.from_hash(definition_hash) do |commands|
+          commands.each {|command| command.send :manager=, self }
+          @commands = commands
+        end
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/manager/cmd_line_args.rb

@@ -0,0 +1,25 @@
+
+module UltraCommandLine
+  module Manager
+
+    module CmdLineArgs
+
+      def cmd_line_args
+        @cmd_line_args ||= []
+      end
+
+      def cmd_line_args=(cmd_line_args)
+        cmd_line_args = case cmd_line_args
+                          when Array
+                            cmd_line_args
+                          when String
+                            cmd_line_args.split ' '
+                        end
+        UltraCommandLine.logger.debug "Cmd line: #{cmd_line_args.inspect}"
+        @cmd_line_args = cmd_line_args
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/manager/commands.rb

@@ -0,0 +1,67 @@
+module UltraCommandLine
+  module Manager
+
+    module Commands
+
+      include UltraCommandLine::Manager::CmdLineArgs
+
+      def commands
+        @commands ||= []
+      end
+
+      def root_command
+        return nil if commands.empty?
+        l = commands.select {|c| c.root_command? && c.name.empty? }
+        raise UltraCommandLine::Error, 'Wrong commands definition !' unless l.count == 1
+        l.first
+      end
+
+      def aliases_consistent?
+        # including aliases
+        full_names_list = []
+        commands.each do |command|
+          if command.root_command?
+            return false unless command.name.empty? && command.aliases == [command.name]
+          else
+            command.aliases.each do |alias_name|
+              return false if full_names_list.include? alias_name.to_s
+              full_names_list << alias_name.to_s
+            end
+
+          end
+        end
+        true
+      end
+
+      def command(cmd_line_args = self.cmd_line_args)
+        command_alias = cmd_line_args.empty? ? '' : cmd_line_args.first
+        command_by_alias(command_alias) || root_command
+      end
+
+      def command_by_alias(command_alias)
+        raise UltraCommandLine::Error, 'command names/aliases are not consistent !' unless aliases_consistent?
+        candidates = commands.select do |command|
+          command.aliases.map(&:to_s).include? command_alias.to_s
+        end
+        # raise UltraCommandLine::Error, "There is no command named '#{command_alias}'!" unless candidates.siez == 1
+        candidates.size == 1 ? candidates.first : nil
+      end
+
+      def cmd_line_args_for_command(command)
+        if command.root_command?
+          cmd_line_args
+        else
+          clfc = cmd_line_args.dup
+          clfc.shift
+          clfc
+        end
+      end
+
+      protected
+
+      attr_writer :commands
+
+    end
+
+  end
+end

data/lib/ultra_command_line/manager/factory.rb

@@ -0,0 +1,50 @@
+module UltraCommandLine
+  module Manager
+
+    module Factory
+
+      include UltraCommandLine::Utils::YamlFactory
+
+      def from_hash(definition_hash, factory_options = {})
+        UltraCommandLine.logger.debug 'Starting commands analysis from definition hash.'
+        commands = []
+        # Create main command
+        UltraCommandLine.logger.debug 'Defining main command.'
+        main_command = create_command '', definition_hash
+        main_command.banner = definition_hash.fetch :banner, ''
+        commands << main_command
+        # Create sub-commands
+        definition_hash.fetch(:subcommands, {}).each do |subcommand_name, subcommand_definition|
+          UltraCommandLine.logger.debug "Defining sub-command '#{subcommand_name}'."
+          # subcommand_definition ||= {}
+          subcommand = create_command subcommand_name, subcommand_definition
+          subcommand.banner = subcommand_definition.fetch :banner, ''
+          # Let's add global options
+          main_command.options.select(&:global?).each do |global_option|
+            subcommand.options << global_option
+          end
+          commands << subcommand
+        end
+        if block_given?
+          yield commands
+        else
+          # Return a new object supporting a list of commands as parameter
+          new_manager = new commands
+          new_manager.initialize_definition definition_hash
+          commands.each {|c| c.send :manager=, new_manager}
+          new_manager
+        end
+      end
+
+      private
+
+      def create_command(name, options_definition)
+        UltraCommandLine::Commands::SubCommand.from_hash options_definition, name: name, manager: self
+      end
+
+
+
+    end
+
+  end
+end

data/lib/ultra_command_line/manager/layered_definition.rb

@@ -0,0 +1,86 @@
+require 'super_stack'
+
+module UltraCommandLine
+  module Manager
+
+    module LayeredDefinition
+
+      def definition_hash
+        @cached_definition ||= layers_manager[].to_hash
+      end
+
+      def initialize_definition(hash)
+        reset_cached_configuration
+        @layers_manager = setup_layers_manager hash
+        self
+      end
+
+      def contribute_to_definition(hash, layer_name: :unknown_layer)
+        reset_cached_configuration
+        layers_manager
+        new_layer = SuperStack::LayerWrapper.from_hash hash
+        new_layer.name = layer_name
+        new_layer.priority = definition_counter
+        layers_manager.add_layer new_layer
+      end
+
+      def []=(key, value)
+        layers_manager[key] = value
+      end
+
+      def refresh
+        reset_cached_configuration
+      end
+
+      def clear
+        reset_definition_hash
+      end
+
+      private
+
+      BASE_LAYER_PRIORITY = 10
+      DEFINITION_LAYERS_BASE_PRIORITY = 100
+      UPDATE_LAYER_PRIORITY = 1000
+
+      def reset_cached_configuration
+        @cached_definition = nil
+      end
+
+      def reset_definition_hash
+        reset_cached_configuration
+        @layers_manager = nil
+      end
+
+      def definition_counter
+        raise UltraCommandLine::Error, 'Maximum number of definition reached !' if @definition_counter+1 >= UPDATE_LAYER_PRIORITY
+        @definition_counter += 1
+      end
+
+      def layers_manager
+        @layers_manager ||= setup_layers_manager
+      end
+
+      def setup_layers_manager(hash = nil)
+        merger = SuperStack::Manager.new
+        merger.merge_policy = SuperStack::MergePolicies::FullMergePolicy
+        base_layer = if hash.nil?
+                       SuperStack::Layer.new
+                     else
+                       SuperStack::LayerWrapper.from_hash(hash)
+                     end
+        base_layer.name = :base
+        base_layer.priority = BASE_LAYER_PRIORITY
+        merger.add_layer base_layer
+        update_layer = SuperStack::Layer.new
+        update_layer.name = :manual_updates
+        update_layer.priority = UPDATE_LAYER_PRIORITY
+        merger.add_layer update_layer
+        merger.write_layer = update_layer
+        @definition_counter = DEFINITION_LAYERS_BASE_PRIORITY
+        merger
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/manager/processors.rb

@@ -0,0 +1,75 @@
+module UltraCommandLine
+  module Manager
+
+    module Processors
+
+      include UltraCommandLine::Manager::Commands
+
+      MANDATORY_PROCESSOR_METHODS = %i[check_params execute].freeze
+
+      def processors(for_command: nil)
+        if for_command.nil?
+          processors_hash.values.inject([]) do |res, value|
+            res.concat value
+            res
+          end .uniq
+        else
+          processors_hash[for_command]
+        end
+      end
+
+      def register_processor(command_name_or_command, processor)
+        verify_processor_implementation processor
+        if processors.include? processor
+          msg = 'Trying to insert a processor already registered: %s' % [processor.inspect]
+          UltraCommandLine.logger.debug msg
+        end
+        command = command_name_or_command_to_command command_name_or_command
+        processors_hash[command.name] ||= []
+        processors_hash[command.name] << processor
+        command_name = command.name.empty? ? 'Root' : "#{command.name}"
+        UltraCommandLine.logger.debug "Registered Processor #{processor.inspect} to '#{command_name}' command"
+      end
+
+      def clear_processors
+        @processors_hash = nil
+      end
+
+      def processor
+        processor_candidates = processors_hash.fetch(command(cmd_line_args).name, []) .select do |processor|
+          processor.check_params command.cmd_line_args
+        end
+        raise UltraCommandLine::Error, 'No processor found for this command line' if processor_candidates.empty?
+        raise UltraCommandLine::Error, 'Too many possible processors' unless processor_candidates.size == 1
+        processor_candidates.first
+      end
+
+      private
+
+      def command_name_or_command_to_command(command_name_or_command)
+        case command_name_or_command
+        when String
+          command_by_alias command_name_or_command
+        when UltraCommandLine::Commands::SubCommand
+          command_name_or_command
+        else
+          raise UltraCommandLine::Error, "Invalid command or command name: '#{command_name_or_command.inspect}'"
+        end
+      end
+
+      def verify_processor_implementation(processor)
+        MANDATORY_PROCESSOR_METHODS.each do |method_name|
+          unless processor.respond_to? method_name
+            raise UltraCommandLine::Error, "Invalid processor '#{processor.inspect}' missing method '#{method_name}'!"
+          end
+        end
+      end
+
+      def processors_hash
+        @processors_hash ||= {}
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/utils/basic_logger.rb

@@ -0,0 +1,23 @@
+module UltraCommandLine
+  module Utils
+
+    module BasicLogger
+
+      class NullLogger
+        def method_missing(*args)
+          # Do nothing
+        end
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def logger
+        @logger ||= NullLogger.new
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/utils/error_propagation.rb

@@ -0,0 +1,22 @@
+module UltraCommandLine
+  module Utils
+
+    module ErrorPropagation
+
+      DEFAULT_ERROR_MESSAGE = 'Error message not provided!'.freeze
+
+      private
+
+      def false_or_raise(message = DEFAULT_ERROR_MESSAGE, raise_error: false, error_type: UltraCommandLine::Error)
+        if raise_error
+          raise error_type, message
+        else
+          UltraCommandLine.logger.warn message
+        end
+        false
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/utils/yaml_factory.rb

@@ -0,0 +1,24 @@
+module UltraCommandLine
+  module Utils
+
+    module YamlFactory
+
+      def from_yaml_file(yaml_file, factory_options = {}, &block)
+        yaml_file = File.expand_path yaml_file
+        UltraCommandLine.logger.debug "Loading commands definitions from '#{yaml_file}'."
+        raise UltraCommandLine::Error, 'Invalid Yaml command file specified !' unless File.exists? yaml_file
+        raise UltraCommandLine::Error, 'Cannot read Yaml command file !' unless File.readable? yaml_file
+        from_yaml File.read(yaml_file), factory_options, &block
+      end
+
+      def from_yaml(yaml, factory_options = {}, &block)
+        from_hash YAML.load(yaml), factory_options, &block
+      rescue => e
+        UltraCommandLine.logger.error "#{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+        raise UltraCommandLine::Error, 'Invalid Yaml content. Parser error !'
+      end
+
+    end
+
+  end
+end

data/lib/ultra_command_line/version.rb

@@ -0,0 +1,3 @@
+module UltraCommandLine
+  VERSION = '0.4.7'.freeze
+end

data/ultra_command_line.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ultra_command_line/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ultra_command_line'
+  spec.version       = UltraCommandLine::VERSION
+  spec.authors       = ['Laurent B.']
+  spec.email         = ['lbnetid+rb@gmail.com']
+
+  spec.summary       = %q{Manage complex sub_command line options.}
+  spec.description   = %q{Allows to handle complex sub_command line options with subcommands a-la-git.}
+  spec.homepage      = 'https://gitlab.com/lbriais/ultra_command_line'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov'
+
+  spec.add_dependency 'super_stack', '~> 1.0'
+  spec.add_dependency 'slop', '~> 4.5'
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: ultra_command_line
+version: !ruby/object:Gem::Version
+  version: 0.4.7
+platform: ruby
+authors:
+- Laurent B.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: super_stack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+description: Allows to handle complex sub_command line options with subcommands a-la-git.
+email:
+- lbnetid+rb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/command_definition.puml
+- lib/ultra_command_line.rb
+- lib/ultra_command_line/commands/command_line_parser.rb
+- lib/ultra_command_line/commands/factory.rb
+- lib/ultra_command_line/commands/help_formatter.rb
+- lib/ultra_command_line/commands/main_command.rb
+- lib/ultra_command_line/commands/option_definition.rb
+- lib/ultra_command_line/commands/sub_command.rb
+- lib/ultra_command_line/commands/validation.rb
+- lib/ultra_command_line/error.rb
+- lib/ultra_command_line/manager/base.rb
+- lib/ultra_command_line/manager/cmd_line_args.rb
+- lib/ultra_command_line/manager/commands.rb
+- lib/ultra_command_line/manager/factory.rb
+- lib/ultra_command_line/manager/layered_definition.rb
+- lib/ultra_command_line/manager/processors.rb
+- lib/ultra_command_line/utils/basic_logger.rb
+- lib/ultra_command_line/utils/error_propagation.rb
+- lib/ultra_command_line/utils/yaml_factory.rb
+- lib/ultra_command_line/version.rb
+- ultra_command_line.gemspec
+homepage: https://gitlab.com/lbriais/ultra_command_line
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Manage complex sub_command line options.
+test_files: []