argser 1.5 → 1.6

data/README.md

@@ -28,8 +28,8 @@ Argser::Parser.new({
 - <code>:usage</code>, a string describing how to use the application (default: "")
 - <code>:details</code>, a string containing details about the application (default: "")
 - <code>:info</code>, a string printer bellow errors indicating how to find more information about them (default: "For more information try '--help'")
-- <code>:unknown</code>, a string with the message to show when a parameter is not known (default: "Unknown parameter '$p'")
-- <code>:fatal</code>, a string with the message to show when an internal error is found while parsing parameters (default: "An internal error was found")
+- <code>:unknown</code>, a string with the error to show when a parameter is not known (default: "Unknown parameter '$p'")
+- <code>:fatal</code>, a string with the error to show when an internal error is found while parsing parameters (default: "An internal error was found")
 - <code>:help</code>, a boolean value indicating if the parser should automatically display the help if parameter :help is given (default: true)
 
 ## PARAMETERS OPTIONS
@@ -38,10 +38,10 @@ Argser::Parser.new({
 - <code>:type</code>,  symbol indicating the type of this parameter (default: :string)
 - <code>:default</code>, the default value if not other value is provided (default: '')
 - <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>:sanitize</code>, a function to sanitize the value given (return the identifier of an error 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>: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)
+- <code>:errors</code>, a hash with all available errors to show where the key is used as an identifier (:type and :required are created by default)
 
 ## REMAINING ARRAY OPTIONS
 
@@ -49,10 +49,10 @@ Argser::Parser.new({
 - <code>:default</code>, the default value if not other value is provided (default: '')
 - <code>:minimum</code>, minimum number of strings allowed
 - <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>:sanitize</code>, a function to sanitize the value given (return the identifier of an error 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>: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)
+- <code>:errors</code>, a hash with all available errors to show where the key is used as an identifier (:type and :required are created by default)
 
 ## AVAILABLE TYPES
 
@@ -91,8 +91,8 @@ parser = Argser::Parser.new({
             default:  18,
             type:     :integer,
             sanitize: lambda {|value, default| (value >= 18) ? value : :young},
-            messages: {
-                help:  "Specify your age",
+            help:  "Specify your age",
+            errors: {
                 type:  "I can't believe you're '$v' years old",
                 young: "You can't use this application unless you're older than 18!"
             }
@@ -103,8 +103,8 @@ parser = Argser::Parser.new({
         minimum: 1,
         maximum: 1,
         callback: lambda {|values, default| puts "Alright, I got your name!"},
-        messages: {
-            help: "Specify your name and surname",
+        help: "Specify your name and surname",
+        errors: {
             type: "What!? Your name is '$v'!?"
         }
     }
@@ -117,7 +117,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?'
@@ -139,6 +140,8 @@ greeting [OPTIONS] NAME
    -a   --age               Specify your age
    -h   --help              Display this help and exit
 
+                            Specify your name and surname
+
 Provided your age and your name, this application will greet you in a unique way.
 ```
 

data/examples/greetings.rb

@@ -17,7 +17,7 @@ parser = Argser::Parser.new({
             type:     :integer,
             sanitize: lambda {|value, default| (value >= 18) ? value : :young},
             help:  "Specify your age",
-            messages: {
+            errors: {
                 type:  "I can't believe you're '$v' years old",
                 young: "You can't use this application unless you're older than 18!"
             }
@@ -29,7 +29,7 @@ parser = Argser::Parser.new({
         maximum: 1,
         callback: lambda {|values, default| puts "Alright, I got your name!"},
         help: "Specify your name and surname",
-        messages: {
+        errors: {
             type: "What!? Your name is '$v'!?"
         }
     }

data/lib/argser/parser.rb

@@ -60,13 +60,13 @@ module Argser
 
                 #Iterate over all parameters and process their values
                 @params.each do |token, param|
-                    raise_error(param[:messages][:required], "--#{param[:token].to_s}") unless param?(token) or !param[:required]
+                    raise_error(param[:errors][: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_error(@remaining[:messages][:required]) unless (@remaining[:minimum] <= remaining?) and (remaining? <= @remaining[:maximum])
+                raise_error(@remaining[:errors][:required]) unless (@remaining[:minimum] <= remaining?) and (remaining? <= @remaining[:maximum])
                 validate_remaining()
                 sanitize(@remaining)
 
@@ -124,7 +124,7 @@ module Argser
             exit
         end
 
-        #Raise an error message
+        #Raise an error
         def raise_error(message, token='', value='')
             raise ParserError.new(message || @options[:fatal], token, value)
         end
@@ -136,8 +136,8 @@ module Argser
             #   :usage          A string describing how to use the application (default: "")
             #   :details        A string containing details about the application (default: "")
             #   :info           A string printer bellow errors indicating how to find more information about them (default: "For more information try '--help'")
-            #   :unknown        A string with the message to show when a parameter is not known (default: "Unknown parameter '$p'")
-            #   :fatal          A string with the message to show when an internal error is found while parsing parameters (default: "An internal error was found")
+            #   :unknown        A string with the error to show when a parameter is not known (default: "Unknown parameter '$p'")
+            #   :fatal          A string with the error to show when an internal error is found while parsing parameters (default: "An internal error was found")
             #   :help           A boolean value indicating if the parser should automatically display the help if parameter :help is given (default: true)
 
             #Save all options for the parser
@@ -158,10 +158,10 @@ module Argser
             #   :type        A symbol indicating the type of this parameter (default: :string)
             #   :default     The default value if not other value is provided (default: '')
             #   :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)
+            #   :sanitize    A function to sanitize the value given (return the identifier of an error 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)
+            #   :errors    A hash with all available errors 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
             def init_params(params={})
@@ -172,7 +172,7 @@ module Argser
                         type:     :boolean,
                         default:  false,
                         help: 'Display this help and exit',
-                        messages: {}
+                        errors: {}
                     }
                 end
 
@@ -186,18 +186,18 @@ module Argser
                         sanitize: lambda {|value, default| value},
                         callback: lambda {|value, default|},
                         help:     "",
-                        messages: {}
+                        errors: {}
                     }.merge param
 
                     @params[token][:token] = token
                     @params[token][:value] = @params[token][:default]
                     @params[token][:given] = false
 
-                    #Save messages, make sure :type and :required is available
-                    @params[token][:messages] = {
+                    #Save errors, make sure :type and :required is available
+                    @params[token][:errors] = {
                         type:     "ERROR: Invalid value '$v' for parameter '$p'",
                         required: "ERROR: Parameter '$p' is required"
-                    }.merge @params[token][:messages]
+                    }.merge @params[token][:errors]
 
                     #Register all tokens for the parameter
                     @tokens[token] = token
@@ -214,10 +214,10 @@ module Argser
             #   :default     The default value if not other value is provided (default: '')
             #   :minimum     Minimum number of strings allowed (default: 0)
             #   :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)
+            #   :sanitize    A function to sanitize the value given (return the identifier of an error 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 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)
+            #   :errors    A hash with all available errors 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={})
@@ -229,17 +229,17 @@ module Argser
                     sanitize: lambda {|value, default| value},
                     callback: lambda {|value, default|},
                     help: "",
-                    messages: {}
+                    errors: {}
                 }.merge remaining
 
                 @remaining[:value] = @remaining[:default]
                 @remaining[:given] = 0
 
-                #Save messages, make sure, :type and :required is available
-                @remaining[:messages] = {
+                #Save errors, make sure, :type and :required is available
+                @remaining[:errors] = {
                     type:     "ERROR: Invalid value '$v'",
                     required: "ERROR: Incorrect number of remaining arguments"
-                }.merge @remaining[:messages]
+                }.merge @remaining[:errors]
             end
 
             #Validate the value of a parameter based on its type
@@ -247,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_error(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[:errors][: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_error(param[:messages][:type], param[:token], param[:value]) unless param[:value] =~ param[:type]
+                    raise_error(param[:errors][:type], param[:token], param[:value]) unless param[:value] =~ param[:type]
                 end
             end
 
@@ -261,21 +261,21 @@ module Argser
                 if (@remaining[:type].is_a? Symbol)
                     type = TYPES[@remaining[:type]]
                     @remaining[:value].each_with_index do |value, i|
-                        raise_error(@remaining[:messages][:type], @remaining[:token], value) unless (@remaining[:given] == 0) or (match = type[0].match value)
+                        raise_error(@remaining[:errors][: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_error(@remaining[:messages][:type], @remaining[:token], value) unless value =~ @remaining[:type]
+                        raise_error(@remaining[:errors][:type], @remaining[:token], value) unless value =~ @remaining[:type]
                     end
                 end
             end
 
-            #Sanitize the value of the parameter, if a symbol is returned the associated message is shown
+            #Sanitize the value of the parameter, if a symbol is returned the associated error is shown
             def sanitize(param)
                 value = param[:sanitize].call(param[:value], !param[:given])
-                raise_error(param[:messages][value], param[:token], param[:value]) if value.is_a? Symbol
+                raise_error(param[:errors][value], param[:token], param[:value]) if value.is_a? Symbol
                 #Update the value
                 param[:value] = value
             end
@@ -288,7 +288,7 @@ module Argser
                 @remaining[:callback].call(@remaining[:value], !@remaining[:given])
             end
 
-            #Parser errors used to display messages ($p is replaced by the parameter used by the user, $v is replaced by the value given)
+            #Parser errors used to display errors ($p is replaced by the parameter used by the user, $v is replaced by the value given)
             class ParserError < Exception
                 attr_reader :message
                 def initialize(message, token='', value='')

metadata

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