rsmart_toolbox 0.6 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27fabd26f64bc774e3d4bbfefd30d7cc519bd561
-  data.tar.gz: 888167314f2c75e27f67461cdf8592f9f394440f
+  metadata.gz: 8df8ae09435c7a5b1e5020d14b9d25cd8139eab0
+  data.tar.gz: 2a344b354dab13174e72ef5ecf07965be1cc7847
 SHA512:
-  metadata.gz: e75b6da705654223a6ff1b8f36eb9d049c46511448d7eb8da9d2512f27b82b63f4c006d15dc85c03c592b7e713e7ec41687da6156581eba30754d4719294cb79
-  data.tar.gz: 3fc723d8d3595c88425cf35fdcd2a518f5c67bf2f71153ce9702a097660f84c75522a40ea7f8d20e2a35bf87041567bf57d33527e538df34e5bcf42505979597
+  metadata.gz: 401fc57dff32377887e72ee52c6438828da22abc8dd60f3dcd5cff9f5bcfbefc5643f8ac4e5911ef93a2aa1257a61be5de470467ffb104373d9bb5a53b41a342
+  data.tar.gz: 4547735ef1c185689c2fb76d2e38caf4e373292e30bcba2aa65563aece83a090821f6929beb897e574354229d527be7a057cfe72a05f5b4e860d6497afed2f37

data/README.md

@@ -21,7 +21,7 @@ gem 'rsmart_toolbox'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 ## Usage
 

data/lib/rsmart_toolbox/etl/grm.rb

@@ -16,9 +16,17 @@
 
 require "rsmart_toolbox/etl"
 
+# rSmart Grant and Research Management methods.
 module Rsmart::ETL::GRM
 
-  def self.parse_rolodex_id!(row, insert_str, values_str, opt={})
+  # Parses the <tt>ROLODEX_ID</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {Rsmart::ETL.parse_integer!}.
+  # @return [void]
+  # @see parse_integer!
+  def self.parse_rolodex_id!(row, insert_str, values_str, opt={ name: 'ROLODEX_ID', required: true, length: 6 })
     #   `ROLODEX_ID` decimal(6,0) NOT NULL DEFAULT '0',
     opt[:name]     = "ROLODEX_ID" if opt[:name].nil?
     opt[:required] = true if opt[:required].nil?
@@ -26,21 +34,42 @@ module Rsmart::ETL::GRM
     Rsmart::ETL::parse_integer! row, insert_str, values_str, opt
   end
 
-  def self.parse_country_code!(row, insert_str, values_str, opt={})
+  # Parses the <tt>COUNTRY_CODE</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {Rsmart::ETL.parse_string!}.
+  # @return [void]
+  # @see parse_string!
+  def self.parse_country_code!(row, insert_str, values_str, opt={ name: 'COUNTRY_CODE', length: 3 })
     #   `COUNTRY_CODE` char(3) COLLATE utf8_bin DEFAULT NULL,
     opt[:name]   = "COUNTRY_CODE" if opt[:name].nil?
     opt[:length] = 3 if opt[:length].nil?
     Rsmart::ETL::parse_string! row, insert_str, values_str, opt
   end
 
-  def self.parse_state!(row, insert_str, values_str, opt={})
+  # Parses the <tt>STATE</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {Rsmart::ETL.parse_string!}.
+  # @return [void]
+  # @see parse_string!
+  def self.parse_state!(row, insert_str, values_str, opt={ name: 'STATE', length: 30 })
     #   `STATE` varchar(30) COLLATE utf8_bin DEFAULT NULL,
     opt[:name]   = "STATE" if opt[:name].nil?
     opt[:length] = 30 if opt[:length].nil?
     Rsmart::ETL::parse_string! row, insert_str, values_str, opt
   end
 
-  def self.parse_sponsor_code!(row, insert_str, values_str, opt={})
+  # Parses the <tt>SPONSOR_CODE</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {Rsmart::ETL.parse_string!}.
+  # @return [void]
+  # @see parse_string!
+  def self.parse_sponsor_code!(row, insert_str, values_str, opt={ name: 'SPONSOR_CODE', required: true, length: 6 })
     #   `SPONSOR_CODE` char(6) COLLATE utf8_bin NOT NULL DEFAULT '',
     opt[:name]     = "SPONSOR_CODE" if opt[:name].nil?
     opt[:required] = true if opt[:required].nil?
@@ -48,14 +77,28 @@ module Rsmart::ETL::GRM
     Rsmart::ETL::parse_string! row, insert_str, values_str, opt
   end
 
-  def self.parse_postal_code!(row, insert_str, values_str, opt={})
+  # Parses the <tt>POSTAL_CODE</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {Rsmart::ETL.parse_string!}.
+  # @return [void]
+  # @see parse_string!
+  def self.parse_postal_code!(row, insert_str, values_str, opt={ name: 'POSTAL_CODE', length: 15 })
     #   `POSTAL_CODE` varchar(15) COLLATE utf8_bin DEFAULT NULL,
     opt[:name]   = "POSTAL_CODE" if opt[:name].nil?
     opt[:length] = 15 if opt[:length].nil?
     Rsmart::ETL::parse_string! row, insert_str, values_str, opt
   end
 
-  def self.parse_owned_by_unit!(row, insert_str, values_str, opt={})
+  # Parses the <tt>OWNED_BY_UNIT</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {Rsmart::ETL.parse_string!}.
+  # @return [void]
+  # @see parse_string!
+  def self.parse_owned_by_unit!(row, insert_str, values_str, opt={ name: 'OWNED_BY_UNIT', required: true, length: 8 })
     #   `OWNED_BY_UNIT` varchar(8) COLLATE utf8_bin NOT NULL,
     opt[:name]     = "OWNED_BY_UNIT" if opt[:name].nil?
     opt[:required] = true if opt[:required].nil?
@@ -63,7 +106,14 @@ module Rsmart::ETL::GRM
     Rsmart::ETL::parse_string! row, insert_str, values_str, opt
   end
 
-  def self.parse_email_address(str, opt={})
+  # Parse an <tt>EMAIL_ADDRESS</tt> from a String.
+  # @note The result is validated against a email address RegExp.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>EMAIL_ADDRESS</tt>.
+  # @raise [TextParseError] if the email address is not valid.
+  # @see parse_string
+  def self.parse_email_address(str, opt={ name: 'EMAIL_ADDRESS', length: 60 })
     #   `EMAIL_ADDRESS` varchar(60) COLLATE utf8_bin DEFAULT NULL,
     opt[:name]         = "EMAIL_ADDRESS" if opt[:name].nil?
     opt[:length]       = 60 if opt[:length].nil?
@@ -71,14 +121,27 @@ module Rsmart::ETL::GRM
     return Rsmart::ETL::parse_string str, opt
   end
 
-  def self.parse_email_address!(row, insert_str, values_str, opt={})
+  # Parses the <tt>EMAIL_ADDRESS</tt> by column :name and mutates the SQL statement accordingly.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {parse_email_address}.
+  # @return [void]
+  # @see parse_email_address
+  # @see mutate_sql_stmt!
+  def self.parse_email_address!(row, insert_str, values_str, opt={ name: 'EMAIL_ADDRESS' })
     #   `EMAIL_ADDRESS` varchar(60) COLLATE utf8_bin DEFAULT NULL,
     opt[:name] = "EMAIL_ADDRESS" if opt[:name].nil?
     email_address = parse_email_address row[ Rsmart::ETL::to_symbol( opt[:name] ) ]
     Rsmart::ETL::mutate_sql_stmt! insert_str, opt[:name], values_str, email_address
   end
 
-  def self.parse_principal_id(str, opt={})
+  # Parse a <tt>PRNCPL_ID</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>PRNCPL_ID</tt>.
+  # @see parse_string
+  def self.parse_principal_id(str, opt={ name: 'PRNCPL_ID', required: true, length: 40 })
     #   `PRNCPL_ID` varchar(40) COLLATE utf8_bin NOT NULL DEFAULT '',
     opt[:name]     = "PRNCPL_ID" if opt[:name].nil?
     opt[:required] = true if opt[:required].nil?
@@ -86,7 +149,12 @@ module Rsmart::ETL::GRM
     Rsmart::ETL::parse_string str, opt
   end
 
-  def self.parse_principal_name(str, opt={})
+  # Parse a <tt>PRNCPL_NM</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>PRNCPL_NM</tt>.
+  # @see parse_string
+  def self.parse_principal_name(str, opt={ name: 'PRNCPL_NM', required: true, length: 100 })
     #   `PRNCPL_NM` varchar(100) COLLATE utf8_bin NOT NULL,
     opt[:name]     = "PRNCPL_NM" if opt[:name].nil?
     opt[:length]   = 100  if opt[:length].nil?
@@ -98,36 +166,65 @@ module Rsmart::ETL::GRM
     return prncpl_nm
   end
 
-  def self.parse_emp_stat_cd(str, opt={})
+  # Parse an <tt>EMP_STAT_CD</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>EMP_STAT_CD</tt>.
+  # @raise [TextParseError] if the <tt>EMP_STAT_CD</tt> is not valid.
+  # @see parse_string
+  def self.parse_emp_stat_cd(str, opt={ name: 'EMP_STAT_CD', valid_values: /^(A|D|L|N|P|R|S|T)$/i })
     #   `EMP_STAT_CD` varchar(40) COLLATE utf8_bin DEFAULT NULL,
     opt[:name]         = "EMP_STAT_CD" if opt[:name].nil?
     opt[:valid_values] = /^(A|D|L|N|P|R|S|T)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_emp_typ_cd(str, opt={})
+  # Parse an <tt>EMP_TYP_CD</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>EMP_TYP_CD</tt>.
+  # @raise [TextParseError] if the <tt>EMP_TYP_CD</tt> is not valid.
+  # @see parse_string
+  def self.parse_emp_typ_cd(str, opt={ name: 'EMP_TYP_CD', valid_values: /^(N|O|P)$/i })
     #   `EMP_TYP_CD` varchar(40) COLLATE utf8_bin DEFAULT NULL,
     opt[:name]         = "EMP_TYP_CD" if opt[:name].nil?
     opt[:valid_values] = /^(N|O|P)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_address_type_code(str, opt={})
-    # TODO find real column name
+  # Parse an <tt>ADDR_TYP_CD</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>ADDR_TYP_CD</tt>.
+  # @raise [TextParseError] if the <tt>ADDR_TYP_CD</tt> is not valid.
+  # @see parse_string
+  def self.parse_address_type_code(str, opt={ name: 'ADDR_TYP_CD', length: 3, valid_values: /^(HM|OTH|WRK)$/i })
     opt[:name]         = "ADDR_TYP_CD" if opt[:name].nil?
     opt[:length]       = 3 if opt[:length].nil?
     opt[:valid_values] = /^(HM|OTH|WRK)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_name_code(str, opt={})
+  # Parse a <tt>NM_TYP_CD</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>NM_TYP_CD</tt>.
+  # @raise [TextParseError] if the <tt>NM_TYP_CD</tt> is not valid.
+  # @see parse_string
+  def self.parse_name_code(str, opt={ name: 'NM_TYP_CD', length: 4, valid_values: /^(OTH|PRFR|PRM)$/i })
     opt[:name]         = "NM_TYP_CD" if opt[:name].nil?
     opt[:length]       = 4 if opt[:length].nil?
     opt[:valid_values] = /^(OTH|PRFR|PRM)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_prefix(str, opt={})
+  # Parse a <tt>PREFIX_NM</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>PREFIX_NM</tt>.
+  # @raise [TextParseError] if the <tt>PREFIX_NM</tt> is not valid.
+  # @see parse_string
+  def self.parse_prefix(str, opt={ name: 'PREFIX_NM', length: 3, valid_values: /^(Ms|Mrs|Mr|Dr)?$/ })
     opt[:name]         = "PREFIX_NM" if opt[:name].nil?
     opt[:length]       = 3 if opt[:length].nil?
     opt[:valid_values] = /^(Ms|Mrs|Mr|Dr)?$/ if opt[:valid_values].nil?
@@ -135,7 +232,13 @@ module Rsmart::ETL::GRM
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_suffix(str, opt={})
+  # Parse a <tt>SUFFIX_NM</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>SUFFIX_NM</tt>.
+  # @raise [TextParseError] if the <tt>SUFFIX_NM</tt> is not valid.
+  # @see parse_string
+  def self.parse_suffix(str, opt={ name: 'SUFFIX_NM', length: 3, valid_values: /^(Jr|Sr|Mr|Md)?$/ })
     opt[:name]         = "SUFFIX_NM" if opt[:name].nil?
     opt[:length]       = 3 if opt[:length].nil?
     opt[:valid_values] = /^(Jr|Sr|Mr|Md)?$/ if opt[:valid_values].nil?
@@ -143,43 +246,76 @@ module Rsmart::ETL::GRM
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_phone_type(str, opt={})
-    # TODO find real column name
+  # Parse a <tt>PHONE_TYP_CD</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>PHONE_TYP_CD</tt>.
+  # @raise [TextParseError] if the <tt>PHONE_TYP_CD</tt> is not valid.
+  # @see parse_string
+  def self.parse_phone_type(str, opt={ name: 'PHONE_TYP_CD', length: 3, valid_values: /^(FAX|HM|MBL|OTH|WRK)$/i })
     opt[:name]         = "PHONE_TYP_CD" if opt[:name].nil?
     opt[:length]       = 3 if opt[:length].nil?
     opt[:valid_values] = /^(FAX|HM|MBL|OTH|WRK)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_phone_number(str, opt={})
-    # TODO find real column name
+  # Parse a <tt>PHONE_NBR</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>PHONE_NBR</tt>.
+  # @raise [TextParseError] if the <tt>PHONE_NBR</tt> is not valid.
+  # @see parse_string
+  def self.parse_phone_number(str, opt={ name: 'PHONE_NBR', length: 12, valid_values: /^(\d{3}-\d{3}-\d{4})?$/ })
     opt[:name]         = "PHONE_NBR" if opt[:name].nil?
     opt[:length]       = 12 if opt[:length].nil?
     opt[:valid_values] = /^(\d{3}-\d{3}-\d{4})?$/ if opt[:valid_values].nil?
     return Rsmart::ETL::parse_string str, opt
   end
 
-  def self.parse_email_type(str, opt={})
+  # Parse an <tt>EMAIL_TYP_CD</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>EMAIL_TYP_CD</tt>.
+  # @raise [TextParseError] if the <tt>EMAIL_TYP_CD</tt> is not valid.
+  # @see parse_string
+  def self.parse_email_type(str, opt={ name: 'EMAIL_TYP_CD', length: 3, valid_values: /^(HM|OTH|WRK)$/i })
     opt[:name]         = "EMAIL_TYP_CD" if opt[:name].nil?
     opt[:length]       = 3 if opt[:length].nil?
     opt[:valid_values] = /^(HM|OTH|WRK)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_year(str, opt={})
+  # Parse a <tt>YEAR</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>YEAR</tt>.
+  # @raise [TextParseError] if the <tt>YEAR</tt> is not valid.
+  # @see parse_string
+  def self.parse_year(str, opt={ name: 'YEAR', length: 4, valid_values: /^(\d{4})?$/ })
     opt[:length]       = 4 if opt[:length].nil?
     opt[:valid_values] = /^(\d{4})?$/ if opt[:valid_values].nil?
     return Rsmart::ETL::parse_string str, opt
   end
 
-  def self.parse_citizenship_type(str, opt={})
+  # Parse a <tt>CITIZENSHIP_TYPE_CODE</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>CITIZENSHIP_TYPE_CODE</tt>.
+  # @raise [TextParseError] if the <tt>CITIZENSHIP_TYPE_CODE</tt> is not valid.
+  # @see parse_string
+  def self.parse_citizenship_type(str, opt={ name: 'CITIZENSHIP_TYPE_CODE', valid_values: /^([1-4])$/ })
     opt[:name]         = "CITIZENSHIP_TYPE_CODE" if opt[:name].nil?
     opt[:valid_values] = /^([1-4])$/ if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  def self.parse_degree(str, opt={})
-    # TODO find real column name
+  # Parse a <tt>DEGREE</tt> from a String.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>DEGREE</tt>.
+  # @raise [TextParseError] if the <tt>DEGREE</tt> is not valid.
+  # @see parse_string
+  def self.parse_degree(str, opt={ name: 'DEGREE', length: 5 })
     opt[:name]         = "DEGREE" if opt[:name].nil?
     opt[:length]       = 5 if opt[:length].nil?
     opt[:valid_values] = /^(AS|BA|BComm|BEd|BS|DA|DC|DD|DDS|DEng|DFA|DH|DHA|DMin|DPA|DSN|DVM|DVS|HS|JD|LLD|LLM|MA|MAEd|MArch|MBA|MD|MDS|MDiv|MEE|MEd|MEng|MFA|MIS|MLS|MPA|MPE|MPH|MPd|MPhil|MS|MSEd|MST|MSW|MTh|PhD|PharD|ScD|ThD|UKNW)?$/ if opt[:valid_values].nil?
@@ -187,21 +323,33 @@ module Rsmart::ETL::GRM
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  # Designed specifically for actv_ind, but could be used on *any*
-  # fields that matches /^(Y|N)$/i.
-  def self.parse_actv_ind(str, opt={})
+  # Parse an <tt>ACTV_IND</tt> from a String.
+  # @note Designed specifically for <tt>ACTV_IND</tt>, but could be used on *any* fields that matches <tt>(Y|N)</tt>.
+  # @param [String] str the String to be parsed.
+  # @param [Hash] opt options Hash will be passed through to {Rsmart::ETL.parse_string}.
+  # @return [String] the parsed <tt>ACTV_IND</tt>.
+  # @raise [TextParseError] if the <tt>ACTV_IND</tt> is not valid.
+  # @see parse_string
+  def self.parse_actv_ind(str, opt={ name: 'ACTV_IND', default: 'Y', valid_values: /^(Y|N)$/i })
     #   `ACTV_IND` varchar(1) COLLATE utf8_bin DEFAULT 'Y',
-    opt[:name]         = "actv_ind" if opt[:name].nil?
+    opt[:name]         = "ACTV_IND" if opt[:name].nil?
     opt[:default]      = "Y" if opt[:default].nil?
     opt[:valid_values] = /^(Y|N)$/i if opt[:valid_values].nil?
     return Rsmart::ETL::parse_flag str, opt
   end
 
-  # Designed specifically for actv_ind, but could be used on *any*
-  # fields that matches /^(Y|N)$/i.
-  def self.parse_actv_ind!(row, insert_str, values_str, opt={})
+  # Parses the <tt>ACTV_IND</tt> by column :name and mutates the SQL statement accordingly.
+  # @note Designed specifically for <tt>ACTV_IND</tt>, but could be used on *any* fields that matches <tt>(Y|N)</tt>.
+  # @param row [CSV::Row] the CSV Row being parsed
+  # @param insert_str [String] the left side of the insert statement (i.e. columns)
+  # @param values_str [String] the right side of the insert statement (i.e. values)
+  # @param opt [Hash] options Hash will be passed through to {parse_actv_ind}.
+  # @return [void]
+  # @see parse_actv_ind
+  # @see mutate_sql_stmt!
+  def self.parse_actv_ind!(row, insert_str, values_str, opt={ name: 'ACTV_IND' })
     #   `ACTV_IND` varchar(1) COLLATE utf8_bin DEFAULT 'Y',
-    opt[:name] = "actv_ind" if opt[:name].nil?
+    opt[:name] = "ACTV_IND" if opt[:name].nil?
     actv_ind = parse_actv_ind row[ Rsmart::ETL::to_symbol( opt[:name] ) ]
     Rsmart::ETL::mutate_sql_stmt! insert_str, opt[:name], values_str, actv_ind
   end

data/lib/rsmart_toolbox/etl.rb

@@ -16,13 +16,17 @@
 
 require "rsmart_toolbox"
 
+# rSmart extract, transform and load methods.
 module Rsmart::ETL
 
+  # Any text parsing related errors will use this Exception.
   class TextParseError < StandardError
   end
 
+  # Prepares an Exception for consistent error handling.
   # @param [String, Exception] e the error to handle
   # @return [Exception] an Exception with a message formatted with $INPUT_LINE_NUMBER.
+  # @raise [ArgumentError] if an invalid argument is passed.
   def self.error(e)
     if e.kind_of? String
       # default to TextParseError
@@ -34,8 +38,10 @@ module Rsmart::ETL
     raise ArgumentError, "Unsupported error type: #{e.class}"
   end
 
+  # Prepares an Exception for consistent warning handling.
   # @param [String, Exception] e the warning to handle
   # @return [Exception] an Exception with a message formatted with $INPUT_LINE_NUMBER.
+  # @raise [ArgumentError] if an invalid argument is passed.
   def self.warning(e)
     if e.kind_of? String
       # default to TextParseError
@@ -47,6 +53,7 @@ module Rsmart::ETL
     raise ArgumentError, "Unsupported error type: #{e.class}"
   end
 
+  # Tests whether the subject matches one of the valid values.
   # @param [String, #match] subject used for validity checking.
   # @param [Array<Object>, Regexp] valid_values all of the possible valid values.
   # @option opt [Boolean] :case_sensitive performs case sensitive matching
@@ -73,6 +80,7 @@ module Rsmart::ETL
     return false
   end
 
+  # Matches the input against a set of well known boolean patterns.
   # @param [String] str String to be matched against well known boolean patterns.
   # @option opt [Boolean] :default the default return value if str is empty.
   # @return [Boolean] the result of matching the str input against well known boolean patterns.
@@ -92,9 +100,11 @@ module Rsmart::ETL
     raise Rsmart::ETL::error TextParseError.new "invalid value for Boolean: '#{str}'"
   end
 
+  # Encodes the input String and replaces invalid or undefined characters.
   # @param [String] str the String to be encoded and invalid characters replaced with valid characters.
   # @option opt [String] :encoding the character encoding to use.
   # @return [String] the result of encoding the String and replacing invalid characters with valid characters.
+  # @see String#encode
   def self.encode(str, opt={ encoding: "UTF-8" } )
     opt[:encoding] = "UTF-8" if opt[:encoding].nil?
     str.encode( opt[:encoding], :invalid => :replace,
@@ -113,7 +123,7 @@ module Rsmart::ETL
     encode( str.downcase.gsub(/\s+/, "_").gsub(/\W+/, "") ).to_sym
   end
 
-  # Mutates insert_str and values_str with column_name and value respectively.
+  # Mutates two sides of a SQL insert statement: insert_str and values_str with column_name and value respectively.
   # Proper SQL value quoting will be performed based on object type.
   # @param [String] insert_str the left side of the insert statement (i.e. columns)
   # @param [String] column_name the column name to append to insert_str.
@@ -142,6 +152,8 @@ module Rsmart::ETL
     return str.to_s.gsub("'", "\\\\'")
   end
 
+  # Parses a string using common parsing behavior with options. This method forms the foundation
+  # of all the other parsing methods.
   # @param [String] str the String to be parsed.
   # @option opt [String, #to_s] :default the default return value if str is empty. Must respond to #to_s
   # @option opt [Boolean] :escape_single_quotes escape single quote characters.

data/lib/rsmart_toolbox/version.rb

@@ -15,5 +15,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module Rsmart
-  VERSION = "0.6"
+  # The gem version number.
+  VERSION = "0.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsmart_toolbox
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: '0.7'
 platform: ruby
 authors:
 - Lance Speelmon
@@ -30,7 +30,7 @@ cert_chain:
   sKRWzEtHFamxQaIspOja5O4oQKiCbWa90fEuIoCtwyy1rQtL9VKoDTs4vZASXNuc
   F/lEyekXSjN36uTtlt4LkKLn/k7k5gRbt4+C9Q==
   -----END CERTIFICATE-----
-date: 2014-08-18 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder

metadata.gz.sig

@@ -1,2 +1,4 @@
-:���ƂL�bk���������s�q��CĠW���m��I���yf�a�$#(��{���e,��Y
-B.R�+�3���k�
+�蔱�P��)�
+��.��)��藲�:�ܣw�Y�O��KL�-�r�
+�7>����{a86U�̘�E^`�M�u�$�y����1.�\d`i�lw�WBs,���
+�9�)���,b"F[���t