params 0.0.2 → 0.0.8

data/lib/params/version.rb

@@ -0,0 +1,5 @@
+module BBFS
+  module Params
+    VERSION = "0.0.8"  # Parser updated in params.rb
+  end
+end

data/lib/params.rb

@@ -1,11 +1,322 @@
-# A simple params module.
+# Author: Yaron Dror (yaron.dror.bb@gmail.com)
+# Description: The file contains 'Params' module implementation.
+# Notes:
+#   module.init should be called if user wants to override defined parameters by file or command line.
+#   Parameter can be defined only once.
+#   Parameters have to be defined before they are accessed. see examples below.
+#
+# Examples of definitions:
+#   Params.string('parameter_str', 'this is a string' ,'description_for_string')
+#   Params.integer('parameter_int',1 , 'description_for_integer')
+#   Params.float('parameter_float',2.6 , 'description_for_float')
+#   Params.boolean('parameter_true', true, 'description_for_true')
+#   Params.boolean('parameter_false',false , 'description_for_false')
+#   Note. Parameters have to be defined before they are accessed.
+#
+# Examples of usages (get\set access is through the [] operator).
+#   local_var_of_type_string = Params['parameter_str']
+#   puts local_var_of_type_string  # Will produce --> this is a string
+#   Params['parameter_float'] = 3.8
+#   puts Params['parameter_float']  # Will produce --> 3.8
+#   Params['parameter_float'] = 3
+#   puts Params['parameter_float']  # Will produce --> 3.0 (note the casting)
+#   Note. only after definition, the [] operator will work. Else an error is raised.
+#     Params['new_param'] = true  # will raise an error, since the param was not defined yet.
+#     Params.boolean 'new_param', true, 'this is correct'  # this is the definition.
+#     Params['new_param'] = false  # Will set new value.
+#     puts Params['new_param']  # Will produce --> false
+#
+# Type check.
+#   A type check is forced both when overriding with file or command line and in [] usage.
+#   if parameter was defined as a Float using Params.float method (e.g. 2.6) and user
+#   provided an integer when overriding or when using [] operator then the integer will
+#   be casted to float.
+#
+# Params.Init - override parameters.
+#   implementation of the init sequence allows the override of
+#   defined parameters with new values through input file and\or command line args.
+#   Note that only defined parameters can be overridden. If new parameter is parsed
+#   through file\command line, then an error will be raised.
+#   Input config file override:
+#     Default configuration input file path is: '~/.bbfs/conf/<executable name>.conf'
+#     This path can be overridden by the command line arguments (see ahead).
+#     If path and file exist then the parameters in the file will override the defined
+#     parameters. File parameters format per line:<param_name>: <param value>
+#     Note: Space char after the colon is mandatory
+#   Command line arguments override:
+#     General format per argument is:--<param_name>=<param_value>
+#     those parameters will override the defined parameters and the file parameters.
+#   Override input config file:
+#     User can override the input file by using:--conf_file=<new_file_path>
+#
+# More examples in bbfs/examples/params/rb
+
+require 'optparse'
+require 'yaml'
+
 module BBFS
-  module PARAMS
-    def parameter(name, default_value, description)
-      self.instance_variable_set '@' + name, default_value
-      self.class.send('attr_accessor', name)
+  module Params
+
+    @init_debug_messages = []
+    @help_messages = []
+
+    def Params.get_init_messages
+      return @init_debug_messages
+    end
+
+    # Represents a parameter.
+    class Param
+      attr_accessor :name
+      attr_accessor :value
+      attr_accessor :desc
+      attr_accessor :type
+
+      # value_type_check method:
+      # 1. Check if member:'type' is one of:Integer, Float, String or Boolean.
+      # 2. input parameter:'value' class type is valid to override this parameter.
+      # 3. Return value. The value to override with correct type. A cast from integer to Float will
+      #    be made for Float parameters which are set with integer values.
+      # 4. Check will be skipped for nil value.
+      def value_type_check(value)
+        case( @type )
+          when 'Integer' then
+            if not @value.nil?
+              if not ((value.class.eql? Integer) or
+                      (value.class.eql? Fixnum))
+                raise "Parameter:'#{@name}' type:'Integer' but value type to override " \
+                      "is:'#{value.class}'."
+              end
+            end
+          when 'Float' then
+            if not @value.nil?
+              if not value.class.eql? Float
+                if not ((value.class.eql? Integer) or
+                       (value.class.eql? Fixnum))
+                  raise("Parameter:'#{@name}' type:'Float' but value type to override " \
+                        "is:'#{value.class}'.")
+                else
+                  return value.to_f
+                end
+              end
+            end
+          when 'String' then
+            if not @value.nil?
+              if not value.class.eql? String
+                raise("Parameter:'#{@name}' type:'String' but value type to override " \
+                      "is:'#{value.class}'.")
+              end
+            end
+          when 'Boolean' then
+            if not @value.nil?
+              if not((value.class.eql? TrueClass) or (value.class.eql? FalseClass))
+                raise("Parameter:'#{@name}' type:'Boolean' but value type to override " \
+                      "is:'#{value.class}'.")
+              end
+            end
+          else
+            raise("Parameter:'#{@name}' type:'#{@value.class}' but parameter " \
+                  "type to override:'#{value.class}' is not supported. " + \
+                  "Supported types are:Integer, Float, String or Boolean.")
+        end
+        return value
+      end
+
+      # supported types are: String, Integer, Float and Boolean
+      def initialize(name, value, type, desc)
+        @name = name
+        @type = type
+        @desc = desc
+        @value = value_type_check value
+      end
+    end
+
+    # The globals data structure.
+    @globals_db = Hash.new
+
+    def Params.raise_error_if_param_does_not_exist(name)
+      if not @globals_db[name]
+        raise("before using parameter:'#{name}', it should first be defined through Param module methods:" \
+               "Params.string, Params.integer, Params.float or Params.boolean.")
+      end
+    end
+
+    def Params.raise_error_if_param_exists(name)
+      if @globals_db[name]
+        raise("Parameter:'#{name}', can only be defined once.")
+      end
+    end
+
+    # Read global param value by other modules.
+    # Note that this operator should only be used, after parameter has been defined through
+    # one of Param module methods: Params.string, Params.integer,
+    # Params.float or Params.boolean."
+    def Params.[](name)
+      raise_error_if_param_does_not_exist(name)
+      @globals_db[name].value
+    end
+
+    # Write global param value by other modules.
+    # Note that this operator should only be used, after parameter has been defined through
+    # one of Param module methods: Params.string, Params.integer,
+    # Params.float or Params.boolean."
+    def Params.[]=(name, value)
+      raise_error_if_param_does_not_exist(name)
+      set_value = @globals_db[name].value_type_check(value)
+      @globals_db[name].value = set_value
+    end
+
+    #override parameter should only be called by Params module methods.
+    def Params.override_param(name, value)
+      existing_param = @globals_db[name]
+      if existing_param.nil?
+        raise("Parameter:'#{name}' has not been defined and can not be overridden. " \
+              "It should first be defined through Param module methods:" \
+              "Params.string, Params.integer, Params.float or Params.boolean.")
+      end
+      if value.nil?
+        existing_param.value = nil
+      elsif existing_param.type.eql?('String')
+        existing_param.value = value.to_s
+      else
+        set_value = existing_param.value_type_check(value)
+        existing_param.value = set_value
+      end
+    end
+
+    # Define new global parameter of type Integer.
+    def Params.integer(name, value, description)
+      raise_error_if_param_exists(name)
+      @globals_db[name] = Param.new(name, value, 'Integer', description)
+      end
+
+    # Define new global parameter of type Float.
+    def Params.float(name, value, description)
+      raise_error_if_param_exists(name)
+      @globals_db[name] = Param.new(name, value, 'Float', description)
+    end
+
+    # Define new global parameter of type String.
+    def Params.string(name, value, description)
+      raise_error_if_param_exists(name)
+      @globals_db[name] = Param.new(name, value, 'String', description)
+    end
+
+    # Define new global parameter of type Boolean.
+    def Params.boolean(name, value, description)
+      raise_error_if_param_exists(name)
+      @globals_db[name] = Param.new(name, value, 'Boolean', description)
+    end
+
+    # Initializes the project parameters.
+    # Precedence is: Defined params, file and command line is highest.
+    def Params.init(args)
+      @init_debug_messages = []
+      results = parse_command_line_arguments(args)
+      if not results['conf_file'].nil?
+        @init_debug_messages << "Configuration file was overridden. New path:'#{results['conf_file']}'"
+        Params['conf_file'] = results['conf_file']
+      end
+
+      #load yml params
+      if (not Params['conf_file'].nil?) and (File.exist?(File.expand_path Params['conf_file']))
+        @init_debug_messages << 'Configuration file path exists. Loading file parameters.'
+        read_yml_params(File.open(Params['conf_file'], 'r'))
+      else
+        @init_debug_messages << 'Configuration file path does not exist. Skipping loading file parameters.'
+      end
+
+      #override command line argument
+      results.keys.each do |result_name|
+        override_param(result_name, results[result_name])
+      end
+
+      print_global_parameters
+
+      # Prints help and parameters if needed.
+      puts @help_messages unless @help_messages.empty?
+      puts @init_debug_messages if Params['print_params_to_stdout']
+      exit unless @help_messages.empty?
+    end
+
+    # Load yml params and override default values.
+    # raise exception if a loaded yml param does not exist. or if types mismatch occurs.
+    def Params.read_yml_params(yml_input_io)
+      proj_params = YAML::load(yml_input_io)
+      proj_params.keys.each do |param_name|
+        override_param(param_name, proj_params[param_name])
+      end
+    end
+
+    #  Parse command line arguments
+    def Params.parse_command_line_arguments(args)
+      results = Hash.new  # Hash to store parsing results.
+      options = Hash.new  # Hash of parsing options from Params.
+
+      # Define options switch for parsing
+      # Define List of options see example on
+      # http://ruby.about.com/od/advancedruby/a/optionparser2.htm
+      opts = OptionParser.new do |opts|
+        @globals_db.values.each do |param|
+          tmp_name_long = "--" + param.name + "=MANDATORY"  # Define a command with single mandatory parameter
+          tmp_value = "Default value:" + param.value.to_s  #  Description and Default value
+
+          # Define type of the mandatory value
+          # It can be integer, float or String(for all other types).
+          case( param.type )
+            when 'Integer' then value_type = Integer
+            when 'Float' then value_type = Float
+            else value_type = String
+          end
+          # Switches definition - according to what
+          # was pre-defined in the Params
+          opts.on(tmp_name_long, value_type, tmp_value) do |result|
+            if result.to_s.upcase.eql? 'TRUE'
+              results[param.name] = true
+            elsif result.to_s.upcase.eql? 'FALSE'
+              results[param.name] = false
+            else
+              results[param.name] = result
+            end
+          end
+        end
+
+        # Define help command for available options
+        # executing --help will printout all pre-defined switch options
+        opts.on_tail("-h", "--help", "Show this message") do
+          @help_messages << opts
+        end
+
+        opts.parse(args)  # Parse command line
+      end
+      return results
+    end # end of Parse function
+
+    def Params.print_global_parameters
+      @init_debug_messages << "\n"
+      @init_debug_messages << 'Initialized global parameters:'
+      @init_debug_messages << '---------------------------------'
+      counter=0
+      @globals_db.values.each do |param|
+        counter += 1
+        @init_debug_messages << "#{counter}: #{param.name}=#{param.value}"
+      end
+      @init_debug_messages << '---------------------------------'
+    end
+
+    #Auxiliary method to retrieve the executable name
+    def Params.executable_name
+      /([a-zA-Z0-9\-_\.]+):\d+/ =~ caller[caller.size-1]
+      return $1
+    end
+    #define default params:
+    # 1. configuration file
+    Params.string('conf_file',  File.expand_path("~/.bbfs/conf/#{executable_name}.conf"), 'Default configuration file.')
+    # 2. Print params to stdout
+    Params.boolean('print_params_to_stdout', false, 'print_params_to_stdout or not during Params.init')
+
+    private_class_method :print_global_parameters, :parse_command_line_arguments, \
+                         :raise_error_if_param_exists, :raise_error_if_param_does_not_exist, \
+                         :read_yml_params, :override_param, :executable_name
     end
-    module_function :parameter
-  end
 end
 

data/test/params/params_spec.rb

@@ -0,0 +1,282 @@
+# Author: Yaron Dror (yaron.dror.bb@gmail.com)
+# Description: The file contains 'Param' module tests
+
+require 'rspec'
+require 'yaml'
+
+require_relative '../../lib/params.rb'
+
+module BBFS
+  module Params
+    # make private methods or Params public for testing capability.
+    public_class_method :print_global_parameters, :parse_command_line_arguments, \
+                        :raise_error_if_param_exists, :raise_error_if_param_does_not_exist, \
+                        :read_yml_params, :override_param
+
+    module Spec
+
+      describe 'Params::parameter' do
+
+        it 'should define a new parameters' do
+          Params.string 'par_str', 'sss' ,'desc_str'
+          Params.integer 'par_int',1 , 'desc_int'
+          Params.float 'par_float',2.6 , 'desc_float'
+          Params.boolean 'par_true', true, 'desc_true'
+          Params.boolean 'par_false',false , 'desc_false'
+          Params['par_str'].should eq 'sss'
+          Params['par_int'].should eq 1
+          Params['par_float'].should eq 2.6
+          Params['par_true'].should eq true
+          Params['par_false'].should eq false
+        end
+
+        it 'should raise an error for wrong parameter type definition.' do
+          expect { Params::Param.new 'bad_type', nil, 'non_existing_type', 'desc_bad_type' }.should raise_error
+        end
+
+        it 'should raise an error when trying to define twice the same parameter' do
+          Params.string 'only_once', '1st' ,''
+          expect { Params.string 'only_once', '2nd' ,'' }.to raise_error \
+              "Parameter:'only_once', can only be defined once."
+        end
+      end
+
+      describe 'Params::read_yml_params' do
+        it 'should raise error when yml parameter is not defined' do
+          expect { Params::read_yml_params StringIO.new 'not_defined: 10' }.to raise_error \
+              "Parameter:'not_defined' has not been defined and can not be overridden. " \
+              "It should first be defined through Param module methods:" \
+              "Params.string, Params.integer, Params.float or Params.boolean."
+        end
+
+        it 'Will test yml parameter loading' do
+          # string to other. Will not raise error. Instead a cast is made.
+          Params.string('tmp4str', 'string_value', 'tmp4 def')
+          expect { Params::read_yml_params StringIO.new 'tmp4str: strr' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4str: 4' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4str: 4.5' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4str: true' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4str: false' }.to_not raise_error
+
+          # override integer with other types.
+          Params.integer('tmp4int', 1, 'tmp4 def')
+          expect { Params::read_yml_params StringIO.new 'tmp4int: strr' }.to raise_error \
+          "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'String'."
+          expect { Params::read_yml_params StringIO.new 'tmp4int: 4' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4int: 4.5' }.to raise_error \
+              "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'Float'."
+          expect { Params::read_yml_params StringIO.new 'tmp4int: true' }.to raise_error \
+              "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'TrueClass'."
+          expect { Params::read_yml_params StringIO.new 'tmp4int: false' }.to raise_error \
+              "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'FalseClass'."
+
+          # override float with other types.
+          Params.float('tmp4float', 1.1, 'tmp4 def')
+          expect { Params::read_yml_params StringIO.new 'tmp4float: strr' }.to raise_error \
+          "Parameter:'tmp4float' type:'Float' but value type to override " \
+                      "is:'String'."
+          expect { Params::read_yml_params StringIO.new 'tmp4float: 4' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4float: 4.5' }.to_not raise_error
+          expect { Params::read_yml_params StringIO.new 'tmp4float: true' }.to raise_error \
+              "Parameter:'tmp4float' type:'Float' but value type to override " \
+                      "is:'TrueClass'."
+          expect { Params::read_yml_params StringIO.new 'tmp4float: false' }.to raise_error \
+              "Parameter:'tmp4float' type:'Float' but value type to override " \
+                      "is:'FalseClass'."
+          # override boolean with other types.
+          Params.boolean('tmp4true', true, 'tmp4 def')
+          expect { Params::read_yml_params StringIO.new 'tmp4true: strr' }.to raise_error \
+              "Parameter:'tmp4true' type:'Boolean' but value type to override " \
+                      "is:'String'."
+          expect { Params::read_yml_params StringIO.new 'tmp4true: 4' }.to raise_error \
+              "Parameter:'tmp4true' type:'Boolean' but value type to override " \
+                      "is:'Fixnum'."
+          expect { Params::read_yml_params StringIO.new 'tmp4true: 4.5' }.to raise_error \
+              "Parameter:'tmp4true' type:'Boolean' but value type to override " \
+                      "is:'Float'."
+          expect { Params::read_yml_params StringIO.new 'tmp4true: true' }.to_not raise_error
+          expect { Params.read_yml_params StringIO.new 'tmp4true: false' }.to_not raise_error
+
+          Params.boolean('tmp4False', true, 'tmp4 def')
+          expect { Params.read_yml_params StringIO.new 'tmp4False: strr' }.to raise_error \
+              "Parameter:'tmp4False' type:'Boolean' but value type to override " \
+                      "is:'String'."
+          expect { Params.read_yml_params StringIO.new 'tmp4False: 4' }.to raise_error \
+              "Parameter:'tmp4False' type:'Boolean' but value type to override " \
+                      "is:'Fixnum'."
+          expect { Params.read_yml_params StringIO.new 'tmp4False: 4.5' }.to raise_error \
+              "Parameter:'tmp4False' type:'Boolean' but value type to override " \
+                      "is:'Float'."
+          expect { Params.read_yml_params StringIO.new 'tmp4False: true' }.to_not raise_error
+          expect { Params.read_yml_params StringIO.new 'tmp4False: false' }.to_not raise_error
+
+        end
+
+        it 'should raise error when yml file format is bad' do
+          expect { Params.read_yml_params StringIO.new 'bad yml format' }.to raise_error
+        end
+
+        it 'should override defined values with yml values' do
+          Params.string('tmp5str', 'aaa', 'tmp5 def')
+          Params.integer('tmp5int', 11, 'tmp5 def')
+          Params.float('tmp5float', 11.11, 'tmp5 def')
+          Params.boolean('tmp5true', true, 'tmp5 def')
+          Params.boolean('tmp5false', false, 'tmp5 def')
+          Params.read_yml_params StringIO.new "tmp5str: bbb\ntmp5int: 12\ntmp5float: 12.12\n"
+          Params.read_yml_params StringIO.new "tmp5true: false\ntmp5false: true\n"
+          Params['tmp5str'].should eq 'bbb'
+          Params['tmp5int'].should eq 12
+          Params['tmp5float'].should eq 12.12
+          Params['tmp5true'].should eq false
+          Params['tmp5false'].should eq true
+        end
+      end
+
+      describe 'Params.parse_command_line_arguments' do
+        it 'should raise error when command line parameter is not defined' do
+          expect { Params.parse_command_line_arguments ['--new_param=9]'] }.to raise_error
+        end
+
+        it 'should parse parameter from command line.' do
+          # Override string with types.
+          Params.string('tmp6str', 'dummy', 'tmp6str def')
+          expect { Params.parse_command_line_arguments ['--tmp6str=9'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6str=8.1'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6str=ff'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6str=true'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6str=false'] }.to_not raise_error
+
+          # from fixnum to other types.
+          Params.integer('tmp6', 8, 'tmp6 def')
+          expect { Params.parse_command_line_arguments ['--tmp6=9'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6=8.1'] }.to raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6=ff'] }.to raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6=true'] }.to raise_error
+          expect { Params.parse_command_line_arguments ['--tmp6=false'] }.to raise_error
+
+          # from float to other types.
+          Params.float('tmp7', 8.9, 'tmp7 def')
+          # Casting fix num to float
+          expect { Params.parse_command_line_arguments ['--tmp7=9'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp7=3.4'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp7=ff'] }.to raise_error
+          expect { Params.parse_command_line_arguments ['--tmp7=true'] }.to raise_error
+          expect { Params.parse_command_line_arguments ['--tmp7=false'] }.to raise_error
+
+          # from TrueClass to other types.
+          Params.boolean('tmp8', true, 'tmp8 def')
+          expect { Params.parse_command_line_arguments ['--tmp8=9'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp8=3.4'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp8=ff'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp8=true'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp8=false'] }.to_not raise_error
+
+          # from FalseClass to other types.
+          Params.boolean('tmp9', false, 'tmp9 def')
+          expect { Params.parse_command_line_arguments ['--tmp9=9'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp9=3.4'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp9=ff'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp9=true'] }.to_not raise_error
+          expect { Params.parse_command_line_arguments ['--tmp9=false'] }.to_not raise_error
+        end
+      end
+
+      describe 'Params.init' do
+        it 'should override command line arguments correctly.' do
+          File.stub(:exist?).and_return false
+          # Override string with types.
+          Params.string('tmp6str2', 'dummy', 'tmp6str def')
+          expect { Params.init ['--tmp6str2=9'] }.to_not raise_error
+          expect { Params.init ['--tmp6str2=8.1'] }.to_not raise_error
+          expect { Params.init ['--tmp6str2=ff'] }.to_not raise_error
+          expect { Params.init ['--tmp6str2=true'] }.to_not raise_error
+          expect { Params.init ['--tmp6str2=false'] }.to_not raise_error
+
+          # from fixnum to other types.
+          Params.integer('tmp6Fixnum2', 8, 'tmp6 def')
+          expect { Params.init ['--tmp6Fixnum2=9'] }.to_not raise_error
+          expect { Params.init ['--tmp6Fixnum2=8.1'] }.to raise_error
+          expect { Params.init ['--tmp6Fixnum2=ff'] }.to raise_error
+          expect { Params.init ['--tmp6Fixnum2=true'] }.to raise_error
+          expect { Params.init ['--tmp6Fixnum2=false'] }.to raise_error
+
+          # from float to other types.
+          Params.float('tmp7float2', 8.9, 'tmp7 def')
+          # Casting fix num to float
+          expect { Params.init ['--tmp7float2=9'] }.to_not raise_error
+          expect { Params.init ['--tmp7float2=3.4'] }.to_not raise_error
+          expect { Params.init ['--tmp7float2=ff'] }.to raise_error
+          expect { Params.init ['--tmp7float2=true'] }.to raise_error
+          expect { Params.init ['--tmp7float2=false'] }.to raise_error
+
+          # from TrueClass to other types.
+          Params.boolean('tmp8true2', true, 'tmp8 def')
+          expect { Params.init ['--tmp8true2=9'] }.to raise_error
+          expect { Params.init ['--tmp8true2=3.4'] }.to raise_error
+          expect { Params.init ['--tmp8true2=ff'] }.to raise_error
+          expect { Params.init ['--tmp8true2=true'] }.to_not raise_error
+          expect { Params.init ['--tmp8true2=false'] }.to_not raise_error
+
+          # from FalseClass to other types.
+          Params.boolean('tmp9false2', false, 'tmp9 def')
+          expect { Params.init ['--tmp9false2=9'] }.to raise_error
+          expect { Params.init ['--tmp9false2=3.4'] }.to raise_error
+          expect { Params.init ['--tmp9false2=ff'] }.to raise_error
+          expect { Params.init ['--tmp9false2=true'] }.to_not raise_error
+          expect { Params.init ['--tmp9false2=false'] }.to_not raise_error
+        end
+
+        it 'should override defined values with command line values' do
+          File.stub(:exist?).and_return false
+          Params.string('tmp10str', 'aaa', 'tmp10 def')
+          Params.integer('tmp10int', 11, 'tmp10 def')
+          Params.float('tmp10float', 11.11, 'tmp10 def')
+          Params.boolean('tmp10true', true, 'tmp10 def')
+          Params.boolean('tmp10false', false, 'tmp10 def')
+          Params.init ['--tmp10str=bbb', '--tmp10int=12', '--tmp10float=12.12', \
+                       '--tmp10true=false', '--tmp10false=true']
+          Params['tmp10str'].should eq 'bbb'
+          Params['tmp10int'].should eq 12
+          Params['tmp10float'].should eq 12.12
+          Params['tmp10true'].should eq false
+          Params['tmp10false'].should eq true
+        end
+
+        it 'init should override parameters with file and command' do
+          Params.string('init_param', 'code', '')
+          File.stub(:exist?).and_return true
+          File.stub(:open).and_return StringIO.new 'init_param: yml'
+          Params.init ['--conf_file=dummy_file', '--init_param=command-line']
+          Params['init_param'].should eq 'command-line'
+        end
+
+        it 'init should override parameters with file only' do
+          Params.string('init_param2', 'code', '')
+          File.stub(:exist?).and_return true
+          File.stub(:open).and_return StringIO.new 'init_param2: yml'
+          Params.init ['--conf_file=dummy_file']
+          Params['init_param2'].should eq 'yml'
+        end
+
+        it 'init should override parameters with command line only' do
+          Params.string('init_param3', 'code', '')
+          File.stub(:exist?).and_return false
+          Params.init ['--init_param3=command-line']
+          Params['init_param3'].should eq 'command-line'
+        end
+
+        it 'init should not override any parameters' do
+          Params.string('init_param4', 'code', '')
+          File.stub(:exist?).and_return false
+          Params.init []
+          Params['init_param4'].should eq 'code'
+        end
+      end
+    end
+  end
+end
+

data/test/params/params_test.rb

@@ -0,0 +1,45 @@
+# Author: Yaron Dror (yaron.dror.bb@gmail.com)
+# Description: Params test file.
+# run: rake test.
+# Note: This file will be tested along with all project tests.
+
+require 'params'
+require 'test/unit'
+require_relative '../../lib/params.rb'
+
+module BBFS
+
+  class TestLog < Test::Unit::TestCase
+
+    def test_parsing_of_the_defined_parameters
+      #  Define options
+      Params.integer('remote_server1', 3333,
+                       'Listening port for backup server content data.')
+      Params.string('backup_username1', 'tmp', 'Backup server username.')
+      Params.string('backup_password1', 'tmp', 'Backup server password.')
+      Params.string('backup_destination_folder1', '',
+                       'Backup server destination folder, default is the relative local folder.')
+      Params.string('content_data_path1', File.expand_path('~/.bbfs/var/content.data'),
+                       'ContentData file path.')
+      Params.string('monitoring_config_path1', File.expand_path('~/.bbfs/etc/file_monitoring.yml'),
+                       'Configuration file for monitoring.')
+      Params.float('time_to_start1', 0.03,
+                             'Time to start monitoring')
+
+      cmd = [ '--remote_server1=2222','--backup_username1=rami','--backup_password1=kavana',
+             '--backup_destination_folder1=C:\Users\Alexey\Backup',
+             '--content_data_path1=C:\Users\Alexey\Content',
+             '--monitoring_config_path1=C:\Users\Alexey\Config',
+             '--time_to_start1=1.5']
+      Params.init cmd
+      assert_equal(2222,Params['remote_server1'])
+      assert_equal('rami',Params['backup_username1'])
+      assert_equal('kavana',Params['backup_password1'])
+      assert_equal('C:\Users\Alexey\Backup',Params['backup_destination_folder1'])
+      assert_equal('C:\Users\Alexey\Content',Params['content_data_path1'])
+      assert_equal('C:\Users\Alexey\Config',Params['monitoring_config_path1'])
+      assert_equal(1.5,Params['time_to_start1'])
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: params
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-11 00:00:00.000000000Z
+date: 2012-09-02 00:00:00.000000000 Z
 dependencies: []
 description: Dynamically stores, parses and providers params. Uses module local readers.
 email: kolmanv@gmail.com
@@ -19,7 +19,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/params.rb
-- lib/params/argument_parser.rb
+- lib/params/version.rb
+- test/params/params_spec.rb
+- test/params/params_test.rb
 homepage: http://github.com/kolmanv/bbfs
 licenses: []
 post_install_message: 
@@ -40,8 +42,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Dynamically stores, parses and providers params.
-test_files: []
+test_files:
+- test/params/params_spec.rb
+- test/params/params_test.rb

data/lib/params/argument_parser.rb

@@ -1,24 +0,0 @@
-class ReadArgs
-  def self.read_arguments(argv, parsed_arguments, commands = nil)
-    argv.each { |arg|
-      if arg.start_with?("--")
-        words = arg[2,arg.length-2].split('=')
-        parsed_arguments[words[0]]=words[1]
-      elsif commands != nil and not commands.key?(arg)
-        puts "Unknown command '%s'." % arg
-        return false
-      else
-        if parsed_arguments.key? arg
-          puts "Parse error, two commands found %s and %s" % parsed_arguments["command"], arg
-          return false
-        end
-        parsed_arguments["command"] = arg
-      end
-    }
-
-    return false unless commands == nil or parsed_arguments["command"] != nil
-    return false unless commands == nil or parsed_arguments["command"] != ""
-
-    return true
-  end
-end