argser 1.3 → 1.4

data/README.md

@@ -40,7 +40,8 @@ Argser::Parser.new({
 - <code>:required</code>, a boolean value indicating if this parameter is required or not
 - <code>:sanitize</code>, a function to sanitize the value given (return the identifier of a message to show it or the sanitized value the parser should save)
 - <code>:callback</code>, a function to call to do something with the parameter
-- <code>:messages</code> A hash with all available messages to show where the key is used as an identifier (:help, :type and :required are created by default)
+- <code>:help</code>, a string with the message to print as the help for this parameter
+- <code>:messages</code> A hash with all available messages to show where the key is used as an identifier (:type and :required are created by default)
 
 ## REMAINING ARRAY OPTIONS
 
@@ -50,7 +51,8 @@ Argser::Parser.new({
 - <code>:maximum</code>, maximum number of strings allowed
 - <code>:sanitize</code>, a function to sanitize the value given (return the identifier of a message to show it or the sanitized value the parser should save)
 - <code>:callback</code>, a function to call to do something with the parameter
-- <code>:messages</code>,  hash with all available messages to show where the key is used as an identifier (:help, :type and :required are created by default)
+- <code>:help</code>, a string with the message to print as the help for the remaining strings
+- <code>:messages</code>,  hash with all available messages to show where the key is used as an identifier (:type and :required are created by default)
 
 ## AVAILABLE TYPES
 

data/examples/greetings.rb

@@ -1,4 +1,4 @@
-require 'argser'
+require '../lib/argser/parser.rb'
 
 parser = Argser::Parser.new({
     options: {
@@ -16,8 +16,8 @@ parser = Argser::Parser.new({
             default:  18,
             type:     :integer,
             sanitize: lambda {|value, default| (value >= 18) ? value : :young},
+            help:  "Specify your age",
             messages: {
-                help:  "Specify your age",
                 type:  "I can't believe you're '$v' years old",
                 young: "You can't use this application unless you're older than 18!"
             }
@@ -28,8 +28,8 @@ parser = Argser::Parser.new({
         minimum: 1,
         maximum: 1,
         callback: lambda {|values, default| puts "Alright, I got your name!"},
+        help: "Specify your name and surname",
         messages: {
-            help: "Specify your name and surname",
             type: "What!? Your name is '$v'!?"
         }
     }
@@ -42,7 +42,8 @@ if (parser.param? :age)
     comment = case parser.param(:age)
         when 18..20 then "you're a teenager!"
         when 21..30 then "you're a young man!"
-        when 30..99 then "you're a little adult!"
+        when 30..99 then "you're an adult!"
+        when 100..1.0/0.0 then "you're awesome!"
     end
 else
     comment = 'how old are you?'

data/lib/argser/parser.rb

@@ -37,7 +37,7 @@ module Argser
                     if (arg =~ /^--?\w+$/)
                         arg = arg.downcase
 
-                        raise_message(@options[:unknown], arg) unless @tokens.has_key? arg
+                        raise_error(@options[:unknown], arg) unless @tokens.has_key? arg
                         param = @params[@tokens[arg]]
                         param[:given] = arg
                         if (@params[@tokens[arg]][:type] != :boolean)
@@ -60,13 +60,13 @@ module Argser
 
                 #Iterate over all parameters and process their values
                 @params.each do |token, param|
-                    raise_message(param[:messages][:required], "--#{param[:token].to_s}") unless param?(token) or !param[:required]
+                    raise_error(param[:messages][:required], "--#{param[:token].to_s}") unless param?(token) or !param[:required]
                     validate_param(param)
                     sanitize(param)
                 end
 
                 #Process the value of the remaining array
-                raise_message(@remaining[:messages][:required]) unless (@remaining[:minimum] <= remaining?) and (remaining? <= @remaining[:maximum])
+                raise_error(@remaining[:messages][:required]) unless (@remaining[:minimum] <= remaining?) and (remaining? <= @remaining[:maximum])
                 validate_remaining()
                 sanitize(@remaining)
 
@@ -116,16 +116,16 @@ module Argser
             @params.each do |token, param|
                 token = "--#{token.to_s}"
                 shortcut = (param[:shortcut].is_a? Symbol) ? "-#{param[:shortcut]}" : ''
-                help = param[:messages][:help]
+                help = param[:help]
                 puts "   #{shortcut.ljust(5, ' ')}#{token.ljust(20, ' ')}#{help}"
             end
-            puts "\n#{25.times {puts ' '}}#{@remaining[:help]}" unless @remaining[:help].empty?
+            puts "\n   #{''.ljust(25, ' ')}#{@remaining[:help]}" unless @remaining[:help].empty?
             puts "\n#{@options[:details]}" unless @options[:details].empty?
             exit
         end
 
         #Raise an error message
-        def raise_message(message, token='', value='')
+        def raise_error(message, token='', value='')
             raise ParserError.new(message || @options[:fatal], token, value)
         end
 
@@ -160,6 +160,7 @@ module Argser
             #   :required    A boolean value indicating if this parameter is required or not
             #   :sanitize    A function to sanitize the value given (return the identifier of a message to show it or the sanitized value the parser should save)
             #   :callback    A function to call to do something with the parameter
+            #   :help        A string with the message to print as the help for this parameter
             #   :messages    A hash with all available messages to show where the key is used as an identifier (:help, :type and :required are created by default)
 
             #Save all parameters the parser should recognize
@@ -170,9 +171,8 @@ module Argser
                         shortcut: :h,
                         type:     :boolean,
                         default:  false,
-                        messages: {
-                            help: 'Display this help and exit'
-                        }
+                        help: 'Display this help and exit',
+                        messages: {}
                     }
                 end
 
@@ -185,6 +185,7 @@ module Argser
                         required: false,
                         sanitize: lambda {|value, default| value},
                         callback: lambda {|value, default|},
+                        help:     "",
                         messages: {}
                     }.merge param
 
@@ -192,9 +193,8 @@ module Argser
                     @params[token][:value] = @params[token][:default]
                     @params[token][:given] = false
 
-                    #Save messages, make sure :help, :type and :required is available
+                    #Save messages, make sure :type and :required is available
                     @params[token][:messages] = {
-                        help:     "",
                         type:     "ERROR: Invalid value '$v' for parameter '$p'",
                         required: "ERROR: Parameter '$p' is required"
                     }.merge @params[token][:messages]
@@ -216,26 +216,27 @@ module Argser
             #   :maximum     Maximum number of strings allowed (default: Infinity)
             #   :sanitize    A function to sanitize the value given (return the identifier of a message to show it or the sanitized value the parser should save)
             #   :callback    A function to call to do something with the parameter
-            #   :messages    A hash with all available messages to show where the key is used as an identifier (:help, :type and :required are created by default)
+            #   :help        A string with the message to print as the help for the remaining strings
+            #   :messages    A hash with all available messages to show where the key is used as an identifier (:type and :required are created by default)
 
             #Save options for remaining strings
             def init_remaining(remaining={})
                 @remaining = {
                     type:     :string,
                     default:  [],
-                    minimum: 0,
-                    maximum: Float::INFINITY,
+                    minimum:  0,
+                    maximum:  Float::INFINITY,
                     sanitize: lambda {|value, default| value},
                     callback: lambda {|value, default|},
+                    help: "",
                     messages: {}
                 }.merge remaining
 
                 @remaining[:value] = @remaining[:default]
                 @remaining[:given] = 0
 
-                #Save messages, make sure :help, :type and :required is available
+                #Save messages, make sure, :type and :required is available
                 @remaining[:messages] = {
-                    help:     "",
                     type:     "ERROR: Invalid value '$v'",
                     required: "ERROR: Incorrect number of remaining arguments"
                 }.merge @remaining[:messages]
@@ -246,11 +247,11 @@ module Argser
                 #If the type is a symbol, it must be a valid type
                 if (param[:type].is_a? Symbol)
                     type = TYPES[param[:type]]
-                    raise_message(param[:messages][:type], param[:token], param[:value]) if (param[:given]) and (param[:value].is_a? String) and !(match = type[0].match param[:value])
+                    raise_error(param[:messages][:type], param[:token], param[:value]) if (param[:given]) and (param[:value].is_a? String) and !(match = type[0].match param[:value])
                     #Convert value to the correct type
                     param[:value] = type[1].call(param[:value], match, !param[:given])
                 else #Otherwise it must be a regexp and the value must match
-                    raise_message(param[:messages][:type], param[:token], param[:value]) unless param[:value] =~ param[:type]
+                    raise_error(param[:messages][:type], param[:token], param[:value]) unless param[:value] =~ param[:type]
                 end
             end
 
@@ -260,13 +261,13 @@ module Argser
                 if (@remaining[:type].is_a? Symbol)
                     type = TYPES[@remaining[:type]]
                     @remaining[:value].each_with_index do |value, i|
-                        raise_message(@remaining[:messages][:type], @remaining[:token], value) unless (@remaining[:given] == 0) or (match = type[0].match value)
+                        raise_error(@remaining[:messages][:type], @remaining[:token], value) unless (@remaining[:given] == 0) or (match = type[0].match value)
                         #Convert value to the correct type
                         @remaining[:value][i] = type[1].call(value, match, @remaining[:given] == 0)
                     end
                 else #Otherwise it must be a regexp and the values must match
                     @remaining[:value].each do |value|
-                        raise_message(@remaining[:messages][:type], @remaining[:token], value) unless value =~ @remaining[:type]
+                        raise_error(@remaining[:messages][:type], @remaining[:token], value) unless value =~ @remaining[:type]
                     end
                 end
             end
@@ -274,7 +275,7 @@ module Argser
             #Sanitize the value of the parameter, if a symbol is returned the associated message is shown
             def sanitize(param)
                 value = param[:sanitize].call(param[:value], !param[:given])
-                raise_message(param[:messages][value], param[:token], param[:value]) if value.is_a? Symbol
+                raise_error(param[:messages][value], param[:token], param[:value]) if value.is_a? Symbol
                 #Update the value
                 param[:value] = value
             end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: argser
 version: !ruby/object:Gem::Version
-  version: '1.3'
+  version: '1.4'
   prerelease: 
 platform: ruby
 authors: