simple_command_line_parser 0.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44ad08c20f0031b4d60e6fdc75379e4353c8f3b7
-  data.tar.gz: 97764ce12639c868a1df57ad1fa85cd623b86b88
+  metadata.gz: 8fdb8a4c6de0e6a5c6789dd66f4e81bd72c9cd31
+  data.tar.gz: 69fa6a11bbc7471f54ae4b12186c1edea19b7fd4
 SHA512:
-  metadata.gz: 953181bc5bf01ae59f065f76909720c3f7572497693b622812dd1eb4cf553eac87a43b188d5757f1b06bc8d479f01937205389c36e859c5d9579a4508d709722
-  data.tar.gz: 671aec1d163d5b1285dfdacc06cf6d9019e74a8c64a87b88e453bca42e0c4a63bbf0dea9f0d0d0f4b7e9adde1468ff301052b06e5f9dad3f4fd0e459e14a6720
+  metadata.gz: b2e70774b3b6b3a7ab88d77dd0fdf4b8e5db8ac69a8e8fe81713d2026d7c68b1f984dde4ca29203f8957536a581749d4d1313c5e08aceb8c31f3afd54e46a2bb
+  data.tar.gz: 4c24163caee8a128b6cb403254a87578ca8c347cb836ebc9f3dc3f2112f63bf48b456557c6030ccc4a35db70c17025cfd5363df5a1a7176de1cef241e637e28f

data/lib/simple_command_line_parser.rb

@@ -2,14 +2,17 @@
 module BlackStack
 
   class SimpleCommandLineParser
+    YES = 'yes'
+    NO = 'no'
+    
     STRING = 0
     INT = 1
     BOOL = 2
-    BOOL_VALUES = ['yes', 'no']
+    BOOL_VALUES = [BlackStack::SimpleCommandLineParser::YES, BlackStack::SimpleCommandLineParser::NO]
     
     attr_accessor :args, :conf, :desc
 
-    # list tha possible values for the :type param in the h configuration.
+    # List tha possible values for the :type param in the h configuration.
     # Example: h = [{:name=>'w', :mandatory=>true, :description=>"Worker Name", :type=>BlackStack::CommandLineParser::STRING}] 
     def self.types()
       [
@@ -18,20 +21,28 @@ module BlackStack
         BlackStack::SimpleCommandLineParser::BOOL
       ]
     end
+
+    # List tha possible values for the :type param in the h configuration.
+    # Example: h = [{:name=>'w', :mandatory=>true, :description=>"Worker Name", :type=>BlackStack::CommandLineParser::STRING}] 
+    def self.type_name(n)
+      return 'string' if n == BlackStack::SimpleCommandLineParser::STRING 
+      return 'integer' if n == BlackStack::SimpleCommandLineParser::INT 
+      return 'boolean' if n == BlackStack::SimpleCommandLineParser::BOOL
+    end
  
     # possible values for the bool parameters in the command line
     def self.bool_values()
       BlackStack::SimpleCommandLineParser::BOOL_VALUES
     end
     
-    # will raise an exception if argv parameters does not meet with the configuration specification.
+    # Will raise an exception if argv parameters does not meet with the configuration specification.
     def self.validate_arguments(argv)
       # validate configuration format
       raise "Array of strings expected in the argv parameter." if !argv.kind_of?(Array)
       argv.each { |x| raise "Array of strings expected in the argv parameter." if !x.kind_of?(String) }
     end
 
-    # will raise an exception if the h configuration does not meet with the configuration specification.
+    # Will raise an exception if the h configuration does not meet with the configuration specification.
     def self.validate_configuration(h)
       raise "Array of strings expected in the h parameter." if !h.kind_of?(Array)
       h.each { |x| raise "Array of hashes expected in the h parameter." if !x.kind_of?(Hash) }
@@ -40,32 +51,49 @@ module BlackStack
         raise "A :mandatory key expected in all the params specification." if !x.key?(:mandatory)
         raise "A :description key expected in all the params specification." if !x.key?(:description)
         raise "A :type key expected in all the params specification." if !x.key?(:type)
+        raise "A :default key expected if the param is not mandatory." if ( x[:mandatory]==false && !x.key?(:default) )
+
         raise "String expected in the value of the :name parameter." if !x[:name].kind_of?(String)
         raise "String expected in the value of the :mandatory parameter." if (x[:mandatory]!=true && x[:mandatory]!=false)
         raise "String expected in the value of the :description parameter." if !x[:description].kind_of?(String)
         raise "Invalid code in the :type parameter." if !self.types.include?(x[:type]) 
-      }      
+
+        # if the :default key exists, it must match with the type
+        if x.key?(:default)
+          raise "Type mismatch for the default value of #{x[:name]}." if x[:type]==SimpleCommandLineParser::STRING && x[:default].to_s.size==0
+          raise "Type mismatch for the default value of #{x[:name]}." if x[:type]==SimpleCommandLineParser::INT && x[:default].to_s!=x[:default].to_i.to_s
+          raise "Type mismatch for the default value of #{x[:name]}." if x[:type]==SimpleCommandLineParser::BOOL && x[:default]!=true && x[:default]!=false
+        end
+      }  
     end # validate_configuration
 
-    # return an array of hashes (args) frm the array of string (argv).
+    # Returns an array of hashes (args) frm the array of string (argv).
     # Example of the argv array: ['w=worker01', 'd=euler']
     # Example of the args array: [{'w'=>'worker01'}, {'d'=>'euler'}]
     def self.parse_argumnts(argv)
       Hash[ argv.flat_map{|s| s.scan(/([^=\s]+)(?:=(\S+))?/) } ]
     end
  
-    # will raise an exception if the argv array does not match with the h configuration
+    # Will raise an exception if the argv array does not match with the h configuration
     def self.validate_values(argv, h)
       argc = SimpleCommandLineParser.parse_argumnts(argv)
       h.each { |x|
-        # if the parameter is mandatory, it must exist in the argc array
-        raise "Command line parameter #{x[:name]} expected." if ( x[:mandatory]==true && !argc.key?(x[:name]) )
+        if ( x[:mandatory] == true || argc[x[:name]].to_s.size>0 )
+          # if the parameter is mandatory, it must exist in the argc array
+          raise "Command line parameter #{x[:name]} expected." if ( x[:mandatory]==true && !argc.key?(x[:name]) )
+  
+          # if the parmaeter exists, it must match with the type
+          raise "Type mismatch for the command line parameter #{x[:name]}." if x[:type]==SimpleCommandLineParser::STRING && argc[x[:name]].to_s.size==0  
+          raise "Type mismatch for the command line parameter #{x[:name]}." if x[:type]==SimpleCommandLineParser::INT && argc[x[:name]].to_s!=argc[x[:name]].to_i.to_s
+          raise "Type mismatch for the command line parameter #{x[:name]}." if x[:type]==SimpleCommandLineParser::BOOL && !SimpleCommandLineParser::bool_values.include?(argc[x[:name]].to_s)
+        end # if
+      } # h.reach
+    end
 
-        # if the parmaeter exists, it must match with the type
-        raise "Type mismatch for the command line parameter #{x[:name]}." if x[:type]==SimpleCommandLineParser::STRING && argc[x[:name]].to_s.size==0
-        raise "Type mismatch for the command line parameter #{x[:name]}." if x[:type]==SimpleCommandLineParser::INT && argc[x[:name]].to_s!=argc[x.name].to_i.to_s
-        raise "Type mismatch for the command line parameter #{x[:name]}." if x[:type]==SimpleCommandLineParser::BOOL && !SimpleCommandLineParser::bool_values.include?(argc[x[:name]].to_s)
-      }
+    # Return true if the name of anyone of the parameters is 'h', 'help' or '?'.
+    # Otherwise return false.
+    def asking_help?()
+      ( key?('h')==true || key?('help')==true || key?('?')==true )
     end
 
     # argv: Array of strings. It is usually the command line parameters. 
@@ -91,45 +119,57 @@ module BlackStack
       self.desc = x[:description]
 
     end # def set_conf
-        
+
+    # write a full documentation of the command in the standard output
+    def print_help()
+      puts self.desc
+      puts "Parameters:"
+      self.conf.each { |y|
+        print "#{y[:name]}"
+        print " (#{BlackStack::SimpleCommandLineParser.type_name(y[:type])}. optional)" if !y[:mandatory]
+        print " (#{BlackStack::SimpleCommandLineParser.type_name(y[:type])})" if !y[:mandatory]
+        print ": "
+        print y[:description]
+        puts ""
+        puts ""
+      }
+    end
+
     # Unlike the set_conf method, this constructor will use the ARGV constant as the array of command line arguments.
     # This constructor will simply call the set_conf method. 
     # h: Array of hashes. Parser configuration.  
     # Example: h = [{:name=>'w', :mandatory=>true, :description=>"Worker Name", :type=>BlackStack::CommandLineParser::STRING}] 
     def initialize(x)
       self.set_conf(ARGV, x)
+      self.print_help if self.asking_help?
     end # initialize
 
+    # Return true if the name of anyone of the parameters is equel to the k parameter.
+    # Otherwise return false.
     def key?(k)
       self.args.key?(k)
     end
     
+    # Returns a string, and int, or a bool type value; depending in the type configuration of the param.
+    # If the type value is unknown, it will returns nil.
     def value(k)
-      self.args[k][:value]
-    end
-  
-    def askHelp?()
-      ( key?('h')==true || key?('help')==true || key?('?')==true )
-    end
-      
-    def validate()
-      # valido que los argumentos existan en la list de comandos conocidos
-      self.args.each do |key, value|
-        if (self.allowedParams().include?(key) == false)
-          raise "Unhandled command option or parameter (#{key}). Run this command with the option 'help' to get informaton about expected parameters."
-        end
+      h = self.args[k] 
+      i = self.conf.select {|j| j[:name]==k}.first 
+      raise "Unknown name of paraeter." if i.nil?
+      if !h.nil?
+        return h.to_s if i[:type] == BlackStack::SimpleCommandLineParser::STRING 
+        return h.to_i if i[:type] == BlackStack::SimpleCommandLineParser::INT 
+        return true if ( h == BlackStack::SimpleCommandLineParser::YES && i[:type] == BlackStack::SimpleCommandLineParser::BOOL ) 
+        return false if ( h == BlackStack::SimpleCommandLineParser::NO && i[:type] == BlackStack::SimpleCommandLineParser::BOOL ) 
+      else
+        return i[:default].to_s if i[:type] == BlackStack::SimpleCommandLineParser::STRING 
+        return i[:default].to_i if i[:type] == BlackStack::SimpleCommandLineParser::INT 
+        return true if ( i[:default] == true && i[:type] == BlackStack::SimpleCommandLineParser::BOOL ) 
+        return false if ( i[:default] == false && i[:type] == BlackStack::SimpleCommandLineParser::BOOL ) 
       end
-      
-      # TODO: si se pasa el comando w, entonces no se debepasar el comando d
-  
-      # TODO: si se pasa el comando w, entonces r debe ser "parent"
-  
-      # TODO: si se pasa el comando d, entonces no se debepasar el comando w
-  
-      # TODO: si se pasa el comando d, entonces r debe ser "child"
-  
+      return nil
     end
-  
+          
     def appUrl()   
       division_name = self.value("d")
       

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: simple_command_line_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Leandro Daniel Sardi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-04 00:00:00.000000000 Z
+date: 2019-11-05 00:00:00.000000000 Z
 dependencies: []
-description: This gem has been designed as a part of the BlackStack framework.
+description: 'Find documentation here: https://github.com/leandrosardi/simple_command_line_parser.'
 email: leandro.sardi@expandedventure.com
 executables: []
 extensions: []