clin 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98bdce921d4896c86ed482d8db5cf87a74b2795a
-  data.tar.gz: e025be0b4c3c5fd36f49437e21abfc1f00ef1a0c
+  metadata.gz: 96826af1a7b6e82847b69c692292d7c2a10c69ed
+  data.tar.gz: 28fd292aafc8be55a10af75853283a4def9def65
 SHA512:
-  metadata.gz: 8a70c2a7c6e53bf8eb781b37841dc24052e8396a2b6a2e8d73d6ea9dc90525fe1e03bf2437f43aefdeaf6aef648b210d7c79fec2fd8d7a31734c5ab21da7d9c1
-  data.tar.gz: ef60cf35207752817b52bae1514c55f5db9c12e5f87ae322a17469b9039b6a37470327c6bb4e4d43d37f024c5ae5acd283ec200090c6bad5f6705739086edd49
+  metadata.gz: 3690346888ff69f711f292bca3f1e15a4580599ea12f070264b2c6eb6cdedc3f5081ac8113c08d2f391e1a892c6e6e36832d9351367ce83a924ab9ec801392e3
+  data.tar.gz: 05d2c816d4140359ce2a01fca4462417b6c55fca85580fb7ffe7b8692b60498fe33b2dad151b21c783b7673b1a47f8e31a19215e1c63982a072e73a28345f1fd

data/.gitignore

@@ -12,4 +12,5 @@
 *.o
 *.a
 mkmf.log
-.idea
+.idea
+*.gem

data/.rubocop.yml

@@ -13,6 +13,9 @@ Metrics/MethodLength:
   CountComments: false
   Max: 25
 
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
 
 AllCops:
   Exclude:

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.2.0
+Features:
+    - Allow unknown options to be ignored and not raise Error(#1)
+    - Added list options. For options that can be multiple times in the same command(#2)
+    - Added default value for options.(#3)
+## 0.1.0
+Inital release.

data/README.md

@@ -2,7 +2,7 @@
 [![Build Status](https://travis-ci.org/timcolonel/clin.svg?branch=master)](https://travis-ci.org/timcolonel/clin)
 [![Coverage Status](https://coveralls.io/repos/timcolonel/clin/badge.svg?branch=master)](https://coveralls.io/r/timcolonel/clin?branch=master)
 [![Code Climate](https://codeclimate.com/github/timcolonel/clin/badges/gpa.svg)](https://codeclimate.com/github/timcolonel/clin)
-
+[![Inline docs](http://inch-ci.org/github/timcolonel/clin.svg?branch=master)](http://inch-ci.org/github/timcolonel/clin)
 Clin is Command Line Interface library that provide an clean api for complex command configuration.
 The way Clin is design allow a command defined by the user to be called via the command line as well as directly in the code without any additional configuration
 ## Installation

data/examples/dispatcher.rb

@@ -5,8 +5,6 @@ require 'clin'
 class DisplayCommand < Clin::Command
   arguments 'display <message>'
 
-  general_option Clin::HelpOptions
-
   self.description = 'Display the given message'
 
   def run
@@ -18,8 +16,6 @@ end
 class PrintCommand < Clin::Command
   arguments 'print <message>'
 
-  general_option Clin::HelpOptions
-
   self.description = 'Print the given message'
 
   def run
@@ -27,50 +23,26 @@ class PrintCommand < Clin::Command
   end
 end
 
-Clin::CommandDispatcher.parse('display "My Message"').run
-puts
-puts '=' * 60
-puts
-Clin::CommandDispatcher.parse('print "My Message"').run
-puts
-puts '=' * 60
-puts
-begin
-  Clin::CommandDispatcher.parse('display -h').run
-rescue Clin::CommandLineError => e
-  puts e
-end
-puts
-puts '=' * 60
-puts
-begin
-  Clin::CommandDispatcher.parse('-h')
-rescue Clin::CommandLineError => e
-  puts e
+if __FILE__ == $PROGRAM_NAME
+  Clin::CommandDispatcher.parse('display "My Message"').run
+  puts
+  puts '=' * 60
+  puts
+  Clin::CommandDispatcher.parse('print "My Message"').run
+  puts
+  puts '=' * 60
+  puts
+  begin
+    Clin::CommandDispatcher.parse('display -h').run
+  rescue Clin::CommandLineError => e
+    puts e
+  end
+  puts
+  puts '=' * 60
+  puts
+  begin
+    Clin::CommandDispatcher.parse('-h')
+  rescue Clin::CommandLineError => e
+    puts e
+  end
 end
-
-# Output:
-#
-# $ ruby dispatcher.rb
-# Display: 'My Message'
-#
-# ============================================================
-#
-# Print: 'My Message'
-#
-# ============================================================
-#
-# Usage: command display <message> [Options]
-#
-# Options:
-#   -h, --help                       Show the help.
-#
-# Description:
-# Display the given message
-#
-#
-# ============================================================
-#
-# Usage:
-#   command display <message> [Options]
-#   command print <message> [Options]

data/examples/list_option.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+require 'clin'
+require 'clin'
+
+# Simple command Example
+class ListCommand < Clin::Command
+  list_option :echo, 'Echo some text'
+  list_flag_option :line, 'Print a line in between'
+  general_option Clin::HelpOptions
+
+  def run
+    @params[:echo].each do |msg|
+      puts msg
+      params[:line].times do
+        puts
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  ListCommand.parse('--echo "Message 1" --echo "Message 2"').run
+  puts
+  puts '=' * 60
+  puts
+  ListCommand.parse('--echo "Message 3" --echo "Message 4" -ll').run
+end

data/examples/nested_dispatcher.rb

@@ -5,7 +5,9 @@ require 'clin'
 class DispatchCommand < Clin::Command
   arguments 'you <args>...'
   dispatch :args, prefix: 'you'
-  general_option Clin::HelpOptions
+  skip_options true
+
+  flag_option :verbose, 'Verbose the output'
 
   self.description = 'YOU print the given message'
 
@@ -17,8 +19,8 @@ end
 # Simple command Example
 class DisplayCommand < DispatchCommand
   arguments 'you display <message>'
-
-  general_option Clin::HelpOptions
+  option :echo, 'Display more text'
+  option :times, 'Display the text multiple times', type: Integer
 
   self.description = 'Display the given message'
 
@@ -31,8 +33,6 @@ end
 class PrintCommand < DispatchCommand
   arguments 'you print <message>'
 
-  general_option Clin::HelpOptions
-
   self.description = 'Print the given message'
 
   def run
@@ -40,27 +40,28 @@ class PrintCommand < DispatchCommand
   end
 end
 
-
-Clin::CommandDispatcher.parse('you display "My Message"').run
-puts
-puts '=' * 60
-puts
-Clin::CommandDispatcher.parse('you print "My Message"').run
-puts
-puts '=' * 60
-puts
-begin
-  Clin::CommandDispatcher.parse('you -h').run
-rescue Clin::CommandLineError => e
-  puts e
-end
-puts
-puts '=' * 60
-puts
-begin
-  Clin::CommandDispatcher.parse('-h')
-rescue Clin::CommandLineError => e
-  puts e
+if __FILE__ == $PROGRAM_NAME
+  Clin::CommandDispatcher.parse('you display "My Message"').run
+  puts
+  puts '=' * 60
+  puts
+  Clin::CommandDispatcher.parse('you print "My Message"').run
+  puts
+  puts '=' * 60
+  puts
+  begin
+    Clin::CommandDispatcher.parse('you -h').run
+  rescue Clin::CommandLineError => e
+    puts e
+  end
+  puts
+  puts '=' * 60
+  puts
+  begin
+    Clin::CommandDispatcher.parse('-h')
+  rescue Clin::CommandLineError => e
+    puts e
+  end
 end
 
 # Output:
@@ -88,4 +89,4 @@ end
 # Usage:
 #   command you <args>... [Options]
 #   command you display <message> [Options]
-#   command you print <message> [Options]
+#   command you print <message> [Options]

data/examples/simple.rb

@@ -15,7 +15,7 @@ class SimpleCommand < Clin::Command
   end
 end
 
-if __FILE__== $0
+if __FILE__ == $PROGRAM_NAME
   SimpleCommand.parse('display "My Message" --echo SOME').run
   puts
   puts '=' * 60

data/examples/test.rb

@@ -1,2 +1,9 @@
 $LOAD_PATH.push File.expand_path('../../lib', __FILE__)
-require 'clin'
+require 'clin'
+
+a = [1, 2, 3]
+
+b, c = a
+
+puts b
+puts c

data/lib/clin/argument.rb

@@ -18,14 +18,16 @@ class Clin::Argument
     @name = check_variable(argument)
   end
 
+  # Check if the argument is optional(i.e [arg])
   def check_optional(argument)
-    if check_between(argument, '[', ']')
+    if beck_between(argument, '[', ']')
       @optional = true
       return argument[1...-1]
     end
     argument
   end
 
+  # Check if the argument is multiple(i.e arg...)
   def check_multiple(argument)
     if argument.end_with? '...'
       @multiple = true
@@ -34,8 +36,9 @@ class Clin::Argument
     argument
   end
 
+  # Check if the argument is variable(i.e <arg>)
   def check_variable(argument)
-    if check_between(argument, '<', '>')
+    if beck_between(argument, '<', '>')
       @variable = true
       return argument[1...-1]
     end
@@ -46,21 +49,21 @@ class Clin::Argument
   def parse(argv)
     return handle_empty if argv.empty?
     if @multiple
-      ensure_name(argv) unless @variable
+      ensure_fixed(argv) unless @variable
       [argv, []]
     else
-      ensure_name(argv[0]) unless @variable
+      ensure_fixed(argv[0]) unless @variable
       [argv[0], argv[1..-1]]
     end
   end
 
-  private
+  protected
 
-  def ensure_name(args)
+  # Ensure the argument are equal to the fix value
+  def ensure_fixed(args)
     [*args].each do |arg|
-      if arg != @name
-        fail Clin::FixedArgumentError, @name, arg
-      end
+      next if arg == @name
+      fail Clin::FixedArgumentError, @name, arg
     end
   end
 
@@ -78,10 +81,24 @@ class Clin::Argument
     end
   end
 
-  def check_between(argument, start_char, end_char)
+  # Check +argument+ start with +start_char+ and end with +end_char+
+  # @param argument [String]
+  # @param start_char [Char]
+  # @param end_char [Char]
+  # @return [Boolean]
+  # @raise [Clin::Error] if it start but not end with.
+  # ```
+  #   beck_between('[arg]', '['. ']') # => true
+  #   beck_between('<arg>', '<'. '>') # => true
+  #   beck_between('[<arg>]', '['. ']') # => true
+  #   beck_between('[<arg>]', '<'. '>') # => false
+  #   beck_between('[<arg>', '<'. '>') # => raise Clin::Error
+  # ```
+  def beck_between(argument, start_char, end_char)
     if argument[0] == start_char
       if argument[-1] != end_char
-        fail Clin::Error, "Argument format error! Cannot start with #{start_char} and not end with #{end_char}"
+        fail Clin::Error, "Argument format error! Cannot start
+                            with #{start_char} and not end with #{end_char}"
       end
       return true
     end

data/lib/clin/command.rb

@@ -6,20 +6,19 @@ require 'clin/common/help_options'
 
 # Clin Command
 class Clin::Command < Clin::CommandOptionsMixin
-
   class_attribute :args
   class_attribute :description
 
-
   # Redispatch will be reset to nil when inheriting a dispatcher command
   class_attribute :_redispatch_args
   class_attribute :_abstract
   class_attribute :_exe_name
+  class_attribute :_skip_options
 
   self.args = []
   self.description = ''
   self._abstract = false
-
+  self._skip_options = false
 
   # Trigger when a class inherit this class
   # Rest class_attributes that should not be shared with subclass
@@ -27,6 +26,7 @@ class Clin::Command < Clin::CommandOptionsMixin
   def self.inherited(subclass)
     subclass._redispatch_args = nil
     subclass._abstract = false
+    subclass._skip_options = false
     super
   end
 
@@ -46,11 +46,23 @@ class Clin::Command < Clin::CommandOptionsMixin
   # end
   # Git.usage # => git <command> <args>...
   # ```
-  def self.exe_name(value=nil)
+  def self.exe_name(value = nil)
     self._exe_name = value unless value.nil?
     self._exe_name ||= Clin.exe_name
   end
 
+  def self.skip_options(value)
+    self._skip_options = value
+  end
+
+  def self.skip_options?
+    _skip_options
+  end
+
+  def self.redispatch?
+    !_redispatch_args.nil?
+  end
+
   def self.arguments(args)
     self.args = []
     [*args].map(&:split).flatten.each do |arg|
@@ -70,37 +82,8 @@ class Clin::Command < Clin::CommandOptionsMixin
   # Parse the command and initialize the command object with the parsed options
   # @param argv [Array|String] command line to parse.
   def self.parse(argv = ARGV, fallback_help: true)
-    argv = Shellwords.split(argv) if argv.is_a? String
-    argv = argv.clone
-    options_map = parse_options(argv)
-    error = nil
-    begin
-      args_map = parse_arguments(argv)
-    rescue Clin::MissingArgumentError => e
-      error = e
-    rescue Clin::FixedArgumentError => e
-      raise e unless fallback_help
-      error = e
-    end
-    args_map ||= {}
-
-    options = options_map.merge(args_map)
-    return handle_dispatch(options) unless self._redispatch_args.nil?
-    obj = new(options)
-    if error
-      fail Clin::HelpError, option_parser if fallback_help
-      fail error
-    end
-    obj
-  end
-
-  # Parse the options in the argv.
-  # @return [Array] the list of argv that are not options(positional arguments)
-  def self.parse_options(argv)
-    out = {}
-    parser = option_parser(out)
-    parser.parse!(argv)
-    out
+    parser = Clin::CommandParser.new(self, argv, fallback_help: fallback_help)
+    parser.parse
   end
 
   # Build the Option Parser object
@@ -121,22 +104,6 @@ class Clin::Command < Clin::CommandOptionsMixin
     end
   end
 
-  def self.execute_general_options(options)
-    general_options.each do |_cls, gopts|
-      gopts.execute(options)
-    end
-  end
-
-  # Parse the argument. The options must have been strip out first.
-  def self.parse_arguments(argv)
-    out = {}
-    self.args.each do |arg|
-      value, argv = arg.parse(argv)
-      out[arg.name.to_sym] = value
-    end
-    out.delete_if { |_, v| v.nil? }
-  end
-
   # Redispatch the command to a sub command with the given arguments
   # @param args [Array<String>|String] New argument to parse
   # @param prefix [String] Prefix to add to the beginning of the command
@@ -149,46 +116,32 @@ class Clin::Command < Clin::CommandOptionsMixin
     self._redispatch_args = [[*args], prefix, commands]
   end
 
-  # Method called after the argument have been parsed and before creating the command
-  # @param params [List<String>] Parsed params from the command line.
-  def self.handle_dispatch(params)
-    args, prefix, commands = self._redispatch_args
-    commands ||= default_commands
-    dispatcher = Clin::CommandDispatcher.new(commands)
-    args = args.map { |x| params[x] }.flatten
-    args = prefix.split + args unless prefix.nil?
-    begin
-      dispatcher.parse(args)
-    rescue Clin::HelpError
-      raise Clin::HelpError, option_parser
-    end
-  end
-
   def self.dispatch_doc(opts)
-    return if self._redispatch_args.nil?
+    return if _redispatch_args.nil?
     opts.separator 'Examples: '
-    commands = (self._redispatch_args[2] || default_commands)
+    commands = (_redispatch_args[2] || default_commands)
     commands.each do |cmd_cls|
       opts.separator "\t#{cmd_cls.usage}"
     end
   end
 
   def self.default_commands
-    # self.constants.map { |c| self.const_get(c) }.select { |c| c.is_a?(Class) && (c < Clin::Command) }
-    self.subcommands
+    # self.constants.map { |c| self.const_get(c) }
+    # .select { |c| c.is_a?(Class) && (c < Clin::Command) }
+    subcommands
   end
 
   # List the subcommands
   # The subcommands are all the Classes inheriting this one that are not set to abstract
   def self.subcommands
-    self.subclasses.reject(&:_abstract)
+    subclasses.reject(&:_abstract)
   end
 
   general_option 'Clin::HelpOptions'
 
   attr_accessor :params
 
-  def initialize(params)
+  def initialize(params = {})
     @params = params
     self.class.execute_general_options(params)
   end

data/lib/clin/command_dispatcher.rb

@@ -3,6 +3,7 @@ require 'clin/command'
 
 # Class charge dispatching the CL to the right command
 class Clin::CommandDispatcher
+  # Contains the list of commands the dispatch will test.
   attr_accessor :commands
 
   # Create a new command dispatcher.
@@ -32,7 +33,7 @@ class Clin::CommandDispatcher
 
   # Helper method to parse against all the commands
   # @see #parse
-  def self.parse(argv=ARGV)
+  def self.parse(argv = ARGV)
     Clin::CommandDispatcher.new.parse(argv)
   end
 

data/lib/clin/command_options_mixin.rb

@@ -1,5 +1,6 @@
 require 'clin'
 require 'clin/option'
+require 'clin/option_list'
 
 # Template class for reusable options and commands
 # It provide the method to add options to a command
@@ -9,7 +10,6 @@ class Clin::CommandOptionsMixin
   self.options = []
   self.general_options = {}
 
-
   # Add an option
   # @param args list of arguments.
   #   * First argument must be the name if no block is given.
@@ -52,6 +52,21 @@ class Clin::CommandOptionsMixin
     add_option Clin::Option.new(name, description, **config.merge(argument: false), &block)
   end
 
+  # Add a list option.
+  # @see Clin::OptionList#initialize
+  def self.list_option(name, description, **config)
+    add_option Clin::OptionList.new(name, description, **config)
+  end
+
+  # Add a list options that don't take arguments
+  # Same as .list_option but set +argument+ to false
+  # @see Clin::OptionList#initialize
+  def self.list_flag_option(name, description, **config)
+    add_option Clin::OptionList.new(name, description, **config.merge(argument: false))
+  end
+
+  # Add a new option.
+  # @param option [Clin::Option] option to add.
   def self.add_option(option)
     # Need to use += instead of << otherwise the parent class will also be changed
     self.options += [option]
@@ -62,14 +77,14 @@ class Clin::CommandOptionsMixin
   # @param config [Hash] General option config. Check the general option config.
   def self.general_option(option_cls, config = {})
     option_cls = option_cls.constantize if option_cls.is_a? String
-    self.general_options = self.general_options.merge(option_cls => option_cls.new(config))
+    self.general_options = general_options.merge(option_cls => option_cls.new(config))
   end
 
   # Remove a general option
   # Might be useful if a parent added the option but is not needed in this child.
   def self.remove_general_option(option_cls)
     option_cls = option_cls.constantize if option_cls.is_a? String
-    self.general_options = self.general_options.except(option_cls)
+    self.general_options = general_options.except(option_cls)
   end
 
   # To be called inside OptionParser block
@@ -85,4 +100,19 @@ class Clin::CommandOptionsMixin
       option.class.register_options(opts, out)
     end
   end
+
+  # Call #execute on each of the general options.
+  # This is called during the command initialization
+  # e.g. A verbose general option execute would be:
+  # ```
+  # def execute(params)
+  #  MyApp.verbose = true if params[:verbose]
+  # end
+  # ```
+  def self.execute_general_options(options)
+    general_options.each do |_cls, gopts|
+      gopts.execute(options)
+    end
+  end
+
 end