chupakabra_tools 0.0.20 → 0.0.22

data/lib/chupakabra_tools/convert.rb

@@ -1,67 +1,67 @@
-module ChupakabraTools::Convert
-	def self.string_to_value(data, data_type)
-		result_value = nil
+module ChupakabraTools
+    module Convert
+        def self.string_to_value(data, data_type)
+            result_value = nil
 
-		if data
-			data = data.to_s unless data.is_a?(String)
-			data_type = "string" if data_type.nil?
-			data_type = data_type.to_s unless data_type.is_a?(String)
-			data_type.downcase!
+            if data
+                data = data.to_s unless data.is_a?(String)
+                data_type = "string" if data_type.nil?
+                data_type = data_type.to_s unless data_type.is_a?(String)
+                data_type.downcase!
 
 
-			begin
-				if data_type == "integer"
-					result_value = data.to_i
-				elsif data_type == "float" || data_type == "decimal"
-					result_value = data.to_f
-				elsif data_type == "datetime"
-					result_value = data.to_datetime
-				elsif data_type == "date"
-					result_value = data.to_date
-				elsif data_type == "time"
-					result_value = data.to_time
-				elsif data_type == "string"
-					result_value = data
-				elsif data_type == "text"
-					result_value = data
-				elsif data_type == "boolean"
-					result_value = data == "true" || data == "1" ? true : false
-				else
-					result_value = nil
-				end
-			rescue
-				#ignored
-			end
-		end
-		result_value
-	end
+                begin
+                    result_value = case data_type
+                                       when "integer", :integer
+                                           data.to_i
+                                       when "float", :float, "decimal", :decimal
+                                           data.to_f
+                                       when "datetime", :datetime
+                                           data.to_datetime
+                                       when "date", :date
+                                           data.to_date
+                                       when "time", :time
+                                           data.to_time
+                                       when "string", :string, "text", :text
+                                           data
+                                       when "boolean", :boolean
+                                           [1, "1", "true", :true, true].include?(data) ? true : false
+                                       else
+                                           nil
+                                   end
+                rescue
+                    #ignored
+                end
+            end
+            result_value
+        end
 
-	def self.value_to_string(data, data_type)
-		result_value = nil
-		data_type.strip! if data_type && data.is_a?(String)
-		begin
-			if data_type == "integer"
-				result_value = data
-			elsif data_type == "float" ||  data_type == "decimal"
-				result_value = data
-			elsif data_type == "datetime"
-				result_value = data
-			elsif data_type == "date"
-				result_value = data
-			elsif data_type == "time"
-				result_value = data
-			elsif data_type == "string"
-				result_value = data
-			elsif data_type == "text"
-				result_value = data
-			elsif data_type == "boolean"
-				result_value = data == "1" || data == "true" || data == "on" ? "true" : "false"
-			else
-				result_value = data
-			end
-		rescue
-			#ignored
-		end
-		result_value
-	end
+        def self.value_to_string(data, data_type)
+            result_value = nil
+            data_type.strip! if data_type && data.is_a?(String)
+            begin
+                result_value = case data_type
+                                   when "integer", :integer
+                                       data
+                                   when "float", :float, "decimal", :decimal
+                                       data
+                                   when "datetime", :datetime
+                                       data
+                                   when "date", :date
+                                       data
+                                   when "time", :time
+                                   when data
+                                   when "string", :string, "text", :text
+                                       data
+                                   when "boolean", :boolean
+                                       data == "1" || data == "true" || data == "on" ? "true" : "false"
+                                   else
+                                       data
+                               end
+            rescue
+                #ignored
+            end
+            result_value
+        end
+    end
 end

data/lib/chupakabra_tools/http.rb

@@ -1,18 +1,20 @@
-module ChupakabraTools::Http
-	def self.retrieve_operating_system(user_agent)
-		unless user_agent
-			"Unknown"
-		end
-		if user_agent.downcase.match(/mac/i)
-			"MacOS"
-		elsif user_agent.downcase.match(/windows/i)
-			"Windows"
-		elsif user_agent.downcase.match(/linux/i)
-			"Linux"
-		elsif user_agent.downcase.match(/unix/i)
-			"Unix"
-		else
-			"Unknown"
-		end
-	end
+module ChupakabraTools
+    module Http
+        def self.retrieve_operating_system(user_agent)
+            unless user_agent
+                "Unknown"
+            end
+            if user_agent.downcase.match(/mac/i)
+                "MacOS"
+            elsif user_agent.downcase.match(/windows/i)
+                "Windows"
+            elsif user_agent.downcase.match(/linux/i)
+                "Linux"
+            elsif user_agent.downcase.match(/unix/i)
+                "Unix"
+            else
+                "Unknown"
+            end
+        end
+    end
 end

data/lib/chupakabra_tools/number_as_text.rb

@@ -1,64 +1,66 @@
 #encoding: utf-8
-module ChupakabraTools::NumberAsText
+module ChupakabraTools
+    module NumberAsText
 
-	def self.number_to_russian_string(money)
+        def self.number_to_russian_string(money)
 
-		number_strings = Hash.new
-		number_strings[:thousands] = ["тысяч", "тысяча", "тысячи", "тысячи", "тысячи", "тысяч", "тысяч", "тысяч", "тысяч", "тысяч"]
-		number_strings[:millions] = ["миллионов", "миллион", "миллиона", "миллиона", "миллиона", "миллионов", "миллионов", "миллионов", "миллионов", "миллионов"]
-		number_strings[:billions] = ["миллиардов", "миллиард", "миллиарда", "миллиарда", "миллиарда", "миллиардов", "миллиардов", "миллиардов", "миллиардов", "миллиардов"]
-		number_strings[:trillions] = ["триллионов", "триллион", "триллиона", "триллиона", "триллиона", "триллионов", "триллионов", "триллионов", "триллионов", "триллионов"]
+            number_strings = Hash.new
+            number_strings[:thousands] = ["тысяч", "тысяча", "тысячи", "тысячи", "тысячи", "тысяч", "тысяч", "тысяч", "тысяч", "тысяч"]
+            number_strings[:millions] = ["миллионов", "миллион", "миллиона", "миллиона", "миллиона", "миллионов", "миллионов", "миллионов", "миллионов", "миллионов"]
+            number_strings[:billions] = ["миллиардов", "миллиард", "миллиарда", "миллиарда", "миллиарда", "миллиардов", "миллиардов", "миллиардов", "миллиардов", "миллиардов"]
+            number_strings[:trillions] = ["триллионов", "триллион", "триллиона", "триллиона", "триллиона", "триллионов", "триллионов", "триллионов", "триллионов", "триллионов"]
 
 
-		money_trilions = extract_number_order(number, "trillions")
-		if money_trilions > 0
+            money_trilions = extract_number_order(number, "trillions")
+            if money_trilions > 0
 
-		end
-		money_billions = extract_number_order(number, "billions")
-		if money_billions > 0
+            end
+            money_billions = extract_number_order(number, "billions")
+            if money_billions > 0
 
-		end
-		money_millions = extract_number_order(number, "millions")
-		if money_millions > 0
+            end
+            money_millions = extract_number_order(number, "millions")
+            if money_millions > 0
 
-		end
-		money_thousands = extract_number_order(number, "thousands")
-		if money_thousands > 0
+            end
+            money_thousands = extract_number_order(number, "thousands")
+            if money_thousands > 0
 
-		end
+            end
 
-		money_hundreds = extract_number_order(number, "")
+            money_hundreds = extract_number_order(number, "")
 
-	end
+        end
 
-	def self.format_hundreds(number)
-		number_strings = Hash.new
-		number_strings["1-9"] = ["", "один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять"]
-		number_strings["10-19"] =["десять", "одиннадцать", "двенадцать", "тринадцать", "четырнадцать", "пятнадцать", "шестнадцать", "семнадцать", "восемнадцать", "девятнадцать"]
-		number_strings["20-90"] = ["", "", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят", "девяносто"]
-		number_strings["100-900"] = ["", "сто", "двести", "триста", "четыреста", "пятьсот", "шестьсот", "семьсот", "восемьсот", "девятьсот"]
+        def self.format_hundreds(number)
+            number_strings = Hash.new
+            number_strings["1-9"] = ["", "один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять"]
+            number_strings["10-19"] =["десять", "одиннадцать", "двенадцать", "тринадцать", "четырнадцать", "пятнадцать", "шестнадцать", "семнадцать", "восемнадцать", "девятнадцать"]
+            number_strings["20-90"] = ["", "", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят", "девяносто"]
+            number_strings["100-900"] = ["", "сто", "двести", "триста", "четыреста", "пятьсот", "шестьсот", "семьсот", "восемьсот", "девятьсот"]
 
-		money_string = ""
-		money_hundreds = ((number/ 100).to_i * 100 - (number / 1000).to_i * 1000) / 100
+            money_string = ""
+            money_hundreds = ((number/ 100).to_i * 100 - (number / 1000).to_i * 1000) / 100
 
-		if money_hundreds > 0
-			money_string += number_strings["100-900"]
-		end
+            if money_hundreds > 0
+                money_string += number_strings["100-900"]
+            end
 
-	end
+        end
 
-	def self.extract_number_order(number, order)
-		devider = 1
-		if order == "trillions"
-			devider = 1000000000000
-		elsif order == "billions"
-			devider = 1000000000
-		elsif order == "millions"
-			devider = 1000000
-		elsif order == "thousands"
-			devider = 1000
-		end
-		((number/devider).to_i * devider - (number/(devider * 1000)).to_i * devider * 1000)/devider
-	end
+        def self.extract_number_order(number, order)
+            devider = 1
+            if order == "trillions"
+                devider = 1000000000000
+            elsif order == "billions"
+                devider = 1000000000
+            elsif order == "millions"
+                devider = 1000000
+            elsif order == "thousands"
+                devider = 1000
+            end
+            ((number/devider).to_i * devider - (number/(devider * 1000)).to_i * devider * 1000)/devider
+        end
 
+    end
 end

data/lib/chupakabra_tools/security.rb

@@ -1,52 +1,91 @@
-module ChupakabraTools::Security
-	def self.generate_secret(options={})
-		options ||= {}
-		options =
-			{
-				big: true,
-				small: true,
-				digits: true,
-				specials: false,
-			    length: 8
-			}.merge(options)
-
-		chars = ""
-
-		if options[:small] && options[:small] == true
-			chars += ("a".."z").to_a.join
-		end
-
-		if options[:big] && options[:big] == true
-			chars += ("A".."Z").to_a.join
-		end
-
-		if options[:digits] && options[:digits] == true
-			chars += ("0".."9").to_a.join
-		end
-
-		if options[:specials] && options[:specials] == true
-			chars += "!@#$\%^&*()_+<>/?"
-		end
-
-		if chars.blank?
-			chars = ("a".."z").to_a.join
-		end
-
-
-		len = 8
-		begin
-			if options[:length] && options[:length].to_i > 5
-				len = options[:length].to_i
-			end
-		rescue
-		end
-
-		new_pass = ""
-		1.upto(len) { |i| new_pass << chars[rand(chars.size-1)] }
-		new_pass
-	end
-
-	def self.get_password_hash(password)
-		::Digest::SHA256.hexdigest(password)
-	end
+module ChupakabraTools
+    # Module Responsible for security features
+    module Security
+        # @!method generate_secret
+        # @return [String] generated secret string
+        # @param [Hash] options set of options which influence at a process of secret generation
+        # @option options [Symbol] :big (true) Use Big Letters while generating secret
+        # @option options [Symbol] :small (true) Use Small Letters while generating secret
+        # @option options [Symbol] :digits (true) Use Digits while generating secret
+        # @option options [Symbol] :specials (false) Use Special Signs while generating secret
+        # @option options [Symbol] :length (8) Length of the secret
+        # @option
+        #
+        # @
+        # This method generate secret string based on supplied options
+        def self.generate_secret(options={})
+            options ||= {}
+            options =
+                {
+                    big: true,
+                    small: true,
+                    digits: true,
+                    specials: false,
+                    length: 8
+                }.merge(options)
+
+            chars = ""
+
+            if options[:small] && options[:small] == true
+                chars += ("a".."z").to_a.join
+            end
+
+            if options[:big] && options[:big] == true
+                chars += ("A".."Z").to_a.join
+            end
+
+            if options[:digits] && options[:digits] == true
+                chars += ("0".."9").to_a.join
+            end
+
+            if options[:specials] && options[:specials] == true
+                chars += "!@#$\%^&*()_+<>/?"
+            end
+
+            if chars.blank?
+                chars = ("a".."z").to_a.join
+            end
+
+
+            len = 8
+            begin
+                if options[:length] && options[:length].to_i > 5
+                    len = options[:length].to_i
+                end
+            rescue
+            end
+
+            new_pass = ""
+            1.upto(len) { |i| new_pass << chars[rand(chars.size-1)] }
+            new_pass
+        end
+
+        # @!method get_password_hash
+        # @param [String] password Password to hash
+        # @param [String] salt Salt for enforcing password protection security. Use nil if you want to hash password without salt
+        # @param [:symbol] algorithm Hashing algorithm. May be one of followings: :sha1, :sha256, :sha512.
+        # Method gets a password hash with or without salt using supplied hashing algorithm. :sha512 is used if an algorithm is not supplied
+        def self.get_password_hash(password, salt, algorithm = nil)
+            data = password
+            data = salt + data if salt && !salt.blank?
+            self.hash_it(data, algorithm)
+        end
+
+        # @!method hash_it
+        # @param [String] data Data to hash
+        # @param [:symbol] algorithm Hashing algorithm: :sha1, :sha256, :sha512.
+        # Method gets a hash using supplied hashing algorithm. :sha512 is used if an algorithm is not supplied
+        def self.hash_it(data, algorithm = nil)
+            case algorithm
+                when :sha1
+                    ::Digest::SHA1.hexdigest(data)
+                when :sha256
+                    ::Digest::SHA256.hexdigest(data)
+                when :sha512
+                    ::Digest::SHA512.hexdigest(data)
+                else
+                    ::Digest::SHA512.hexdigest(data)
+            end
+        end
+    end
 end

data/lib/chupakabra_tools/strings.rb

@@ -1,38 +1,35 @@
-module ChupakabraTools::Strings
-	def self.cut_string(string, length, options={})
-		options ||= {}
-		options.stringify_keys!
-
-		string ||= ""
-
-		length ||= 30
-
-		if string.length > length
-			string[0..length] + "..."
-		end
-	end
-
-	def self.trim(str, chars = nil, options = {})
-		# testing "str" for valid string
-
-		options = { force_trim_whitespaces: false }.merge!(options || {})
-
-		return str if str.nil?
-		return nil if !str.is_a?(String)
-		return "" if str.blank?
-		# testing "chars" for valid string
-		return str.strip if chars.nil? || !chars.is_a?(String) || chars.blank? || chars.length > 1
-		result_str = str
-
-		result_str.strip! if options[:force_trim_whitespaces]
-		result_str = result_str.slice(1..result_str.length-1) while result_str.length > 0 && result_str.chr == chars
-		result_str.reverse!
-		result_str = result_str.slice!((1..result_str.length-1)) while result_str.length > 0 && result_str.chr == chars
-		result_str.reverse!
-
-
-
-
-
-	end
+module ChupakabraTools
+    module Strings
+        def self.cut_string(string, length, options={})
+            options ||= {}
+            options.stringify_keys!
+
+            string ||= ""
+
+            length ||= 30
+
+            if string.length > length
+                string[0..length] + "..."
+            end
+        end
+
+        def self.trim(str, chars = nil, options = {})
+            # testing "str" for valid string
+
+            options = {force_trim_whitespaces: false}.merge!(options || {})
+
+            return str if str.nil?
+            return nil unless str.is_a?(String)
+            return "" if str.blank?
+            # testing "chars" for valid string
+            return str.strip if chars.nil? || !chars.is_a?(String) || chars.blank? || chars.length > 1
+            result_str = str
+
+            result_str.strip! if options[:force_trim_whitespaces]
+            result_str = result_str.slice(1..result_str.length-1) while result_str.length > 0 && result_str.chr == chars
+            result_str.reverse!
+            result_str = result_str.slice!((1..result_str.length-1)) while result_str.length > 0 && result_str.chr == chars
+            result_str.reverse!
+        end
+    end
 end