tool_pouch 0.0.34

data/lib/tool_pouch.rb

@@ -0,0 +1,43 @@
+require 'base64'
+require 'cgi'
+require 'digest/sha1'
+require 'digest/md5'
+require 'find'
+require 'net/http'
+require 'openssl'
+require 'yaml'
+require 'uri'
+# HashTree
+
+module ToolPouch
+  DATA_PATH = File.expand_path("../../data", __FILE__) + '/'
+
+  def self.get_data(name, extension='yml')
+    set_data_cache(name, YAML.load_file("#{DATA_PATH}#{name}.#{extension}")['data']) if not data_cached?(name)
+
+    return get_data_cache(name)
+  end
+
+  def self.get_data_cache(name)
+    @data_cache[name]
+  end
+
+  def self.set_data_cache(name, data)
+    @data_cache = {} if not @data_cache
+
+    @data_cache[name] = data
+
+    return @data_cache[name]
+  end
+
+  def self.data_cached?(name)
+    @data_cache and @data_cache[name]
+  end
+end
+
+require 'tool_pouch/babel'
+require 'tool_pouch/krono'
+require 'tool_pouch/locksmith'
+require 'tool_pouch/mathema'
+require 'tool_pouch/trail'
+require 'tool_pouch/transistor'

data/lib/tool_pouch/babel.rb

@@ -0,0 +1,225 @@
+# -*- encoding : utf-8 -*-
+module ToolPouch::Babel
+  def self.bytes_to(size, options={})
+    options.reverse_merge!(:unit => nil, :show_unit => true)
+
+    unit = options[:unit]
+
+    divider = 1
+
+    unless options[:unit]
+      if size < 1000
+        unit = :b
+      elsif size < 1000000
+        unit = :kb
+      elsif size < 1000000000
+        unit = :mb
+      else
+        unit = :gb
+      end
+    end
+
+    case unit
+      when :kb then divider = 1000
+      when :mb then divider = 1000000
+      when :gb then divider = 1000000000
+    end
+
+    sprintf("%0.02f", (size.to_f / divider)) + (options[:show_unit] ? ' ' + unit.to_s.upcase_utf8 : '')
+  end
+
+  def self.convert_accents(str)
+    str_to_convert = String.new(str)
+    table = {'Á' => 'A', 'Â' => 'A', 'Ä' => 'A', 'À' => 'A', 'Å' => 'A', 'Ç' => 'C', 'É' => 'E', 'Ê' => 'E', 'Ë' => 'E', 'È' => 'E', 'Í' => 'I', 'Î' => 'I', 'Ï' => 'I', 'Ì' => 'I', 'Ñ' => 'N', 'Œ' => 'O', 'Ó' => 'O', 'Ô' => 'O', 'Ö' => 'O', 'Ò' => 'O', 'Õ' => 'O', 'Ú' => 'U', 'Û' => 'U', 'Ü' => 'U', 'Ù' => 'U', 'Ý' => 'Y', 'Ÿ' => 'Y', 'Ž' => 'Z', 'á' => 'a', 'â' => 'a', 'ä' => 'a', 'æ' => 'a', 'à' => 'a', 'å' => 'a', 'ã' => 'a', 'ç' => 'c', 'é' => 'e', 'ê' => 'e', 'ë' => 'e', 'è' => 'e', 'ð' => 'o', 'í' => 'i', 'î' => 'i', 'ï' => 'i', 'ì' => 'i', 'ñ' => 'n', 'ó' => 'o', 'ô' => 'o', 'ö' => 'o', 'œ' => 'o', 'ò' => 'o', 'õ' => 'o', 'ú' => 'u', 'û' => 'u', 'ü' => 'u', 'ù' => 'u', 'ý' => 'y', 'ÿ' => 'y', 'ž' => 'z'}
+
+    table.each { |k, v| str_to_convert.gsub!(k, v) }
+
+    return str_to_convert
+  end
+
+  def self.currency_for_country(country)
+    case country
+    when 'fra', 'ita', 'lux', 'bel', 'deu' then 'eur'
+    when 'can' then 'cad'
+    when 'usa' then 'usd'
+    when 'che' then 'chf'
+    end
+  end
+
+  def self.currency_for_region(region)
+    return case region
+      when 'europe' then 'eur'
+      when 'quebec' then 'cad'
+      when 'usa' then 'usd'
+      when 'suisse' then 'chf'
+      else ''
+    end
+  end
+
+  def self.enumerate(terms)
+    last_element = terms.pop;
+
+    if terms.length == 0
+      return last_element;
+    else
+      return terms.join(', ') + ' ' + I18n.t('and') + ' ' + last_element;
+    end
+  end
+
+  def self.extract_first_quotes(value)
+    value.index('"') ? value.split('"')[1] : ''
+  end
+
+  def self.extract_first_tag(value)
+    if value.index('<') and value.index('>')
+      return value[value.index('<') + 2, value.rindex('>') - value.index('<')-2]
+    else
+      return ''
+    end
+  end
+
+  def self.random_string(size, options={})
+    options.reverse_merge!(:force_array => false, :quantity => 1, :reject => [])
+
+    chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+    strings = []
+    try = 0
+
+    options[:quantity].times do
+      new_random = ''
+      while new_random.empty? do
+        1.upto(size) { |i| new_random << chars[rand(chars.size)] }
+
+        new_random = '' if options[:reject].include?(new_random)
+        try += 1
+
+        return nil if try > 500
+      end
+      options[:reject] << new_random
+      strings << new_random
+    end
+
+    (options[:quantity] == 1 and not options[:force_array]) ? strings.first : strings
+  end
+
+  def self.region_for_country(country)
+    return case country.downcase
+      when 'ita', 'fra', 'lux', 'bel', 'deu' then 'europe'
+      when 'che' then 'suisse'
+      when 'can' then 'quebec'
+      when 'usa' then 'usa'
+    end
+  end
+
+  def self.strip_html(value)
+    (value) ? value.to_s.gsub(/<\/?[^>]*>/, "") : value
+  end
+
+  def self.to_currency_symbol(unit)
+    return case unit.downcase
+      when 'cad', 'usd' then '$'
+      when 'eur' then '€'
+      when 'chf' then 'CHF'
+      else ''
+    end
+  end
+
+  # TODO : Finish the method
+  def self.to_iso3166_1(country_code, options={})
+    options.reverse_merge!(:to_alpha => '3')
+
+    from_2_to_3 = { "be" => "bel", "ca" => "can", "ch" => "che", "de" => "deu", "fr" => "fra", "it" => "ita", "lx" => "lux", "us" => "usa" }
+    from_3_to_2 = from_2_to_3.invert
+
+    if options[:to_alpha].to_s == '3'
+      return from_2_to_3[country_code.to_s.downcase]
+    elsif options[:to_alpha].to_s == '2'
+      return from_3_to_2[country_code.to_s.downcase]
+    else
+      return nil
+    end
+  end
+
+  def self.to_iso639(language, options={})
+    options.reverse_merge!(:from => nil, :to => '2b')
+
+    options[:from] = options[:from] ? [options[:from]].flatten : ['1', '2b', '2t', '3']
+
+    options[:from].each do |from|
+      table = ToolPouch.get_data('iso639')['iso639_convert']["#{from}_to_#{options[:to]}"]
+
+      return table[language] if table and not table[language].to_s.empty?
+    end
+
+    return language
+  end
+
+  def self.to_latin_encoded(value)
+    latin_table = { 'Æ' => '306', 'Á' => '301', 'Â' => '302', 'Ä' => '304', 'À' => '300', 'Å' => '305', 'Ã' => '303', 'Ç' => '307', 'É' => '311', 'Ê' => '312', 'Ë' => '313', 'È' => '310', 'Ð' => '320', '€' => '240', 'Í' => '315', 'Î' => '316', 'Ï' => '317', 'Ì' => '314', 'Ł' => '225', 'Ñ' => '321', 'Œ' => '226', 'Ó' => '323', 'Ô' => '324', 'Ö' => '326', 'Ò' => '322', 'Ø' => '330', 'Õ' => '325', 'Š' => '227', 'Þ' => '336', 'Ú' => '332', 'Û' => '333', 'Ü' => '334', 'Ù' => '331', 'Ý' => '335', 'Ÿ' => '230', 'Ž' => '231', 'á' => '341', 'â' => '342', '´' => '264', 'ä' => '344', 'æ' => '346', 'à' => '340', 'å' => '345', '^' => '136', '~' => '176', '*' => '052', 'ã' => '343', '˘' => '030', '¦' => '246', '•' => '200', 'ˇ' => '031', 'ç' => '347', '¸' => '270', '¢' => '242', 'ˆ' => '032', '©' => '251', '¤' => '244', '†' => '201', '‡' => '202', '°' => '260', '÷' => '367', 'ı' => '232', 'é' => '351', 'ê' => '352', 'ë' => '353', 'è' => '350', 'ð' => '360', '¡' => '241', 'fi' => '223', 'fl' => '224', 'ƒ' => '206', 'ß' => '337', '«' => '253', '»' => '273', 'í' => '355', 'î' => '356', 'ï' => '357', 'ì' => '354', 'ł' => '233', 'µ' => '265', '×' => '327', 'ñ' => '361', '#' => '043', 'ó' => '363', 'ô' => '364', 'ö' => '366', 'œ' => '234', 'ò' => '362', 'ª' => '252', 'º' => '272', 'ø' => '370', 'õ' => '365', '¶' => '266', '¿' => '277', '„' => '214', '“' => '215', '”' => '216', '®' => '256', 'š' => '235', '§' => '247', '£' => '243', 'þ' => '376', '™' => '222', 'ú' => '372', 'û' => '373', 'ü' => '374', 'ù' => '371', 'ý' => '375', 'ÿ' => '377', '¥' => '245', 'ž' => '236' }
+    value_encoded = ''
+
+    value.each_char { |c| value_encoded << (latin_table[c] ? "\\" + latin_table[c] : c) }
+
+    value_encoded
+  end
+
+  def self.to_price(amount, options={})
+    options.reverse_merge!(:separator => ',', :format => '%n%u', :unit => 'cad')
+
+    price = amount.to_s.rjust(3,'0')
+    price = price[0..-3] + options[:separator] + price[-2..-1]
+
+    if options[:unit]
+      unit_symbol = to_currency_symbol(options[:unit])
+      price = options[:format].gsub('%u', unit_symbol).gsub('%n', price)
+    end
+
+    return price
+  end
+
+  def self.to_roman(numeric)
+    numerals = [
+      { :roman => 'M', :arab => 1000 },
+      { :roman => 'CM', :arab => 900 },
+      { :roman => 'D', :arab => 500 },
+      { :roman => 'CD', :arab => 400 },
+      { :roman => 'C', :arab => 100 },
+      { :roman => 'XC', :arab => 90 },
+      { :roman => 'L', :arab => 50 },
+      { :roman => 'XL', :arab => 40 },
+      { :roman => 'X', :arab => 10 },
+      { :roman => 'IX', :arab => 9 },
+      { :roman => 'V', :arab => 5 },
+      { :roman => 'IV', :arab => 4 },
+      { :roman => 'I', :arab => 1 }
+    ]
+
+    roman = '';
+    numerals.each do |num|
+      while numeric >= num[:arab]
+        roman += num[:roman]
+        numeric -= num[:arab]
+      end
+    end
+
+    return roman
+  end
+
+  def self.to_slug(value)
+    value.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n,'').downcase.gsub(/[^[:alnum:]]/,'-')
+  end
+
+  def self.to_slug_advanced(value)
+    to_slug(value).gsub(/-{2,}/,'-').gsub(/-\Z/, '')
+  end
+
+  def self.validate_email?(email, options={})
+    options.reverse_merge!(:allow_blank => false)
+
+    if options[:allow_blank] and email.blank?
+      return true
+    else
+      return (email.match(/^\S+@\S+\.\S+$/) ? true : false)
+    end
+  end
+end

data/lib/tool_pouch/krono.rb

@@ -0,0 +1,153 @@
+module ToolPouch::Krono
+  def self.datestamp(date=nil)
+    date = Time.now unless date
+
+    return date.strftime("%Y%m%d")
+  end
+
+  def self.floor(datetime, seconds=60)
+    return Time.at((datetime.to_f / seconds).floor * seconds)
+  end
+
+  def self.format_in_time(number)
+    minutes = (number >= 1) ? number.modulo(number.floor) : number
+    minutes = (minutes * 60).to_i.to_s
+
+    return number.floor.to_s.rjust(2, '0') + ':' + minutes.rjust(2, '0')
+  end
+
+  def self.is_iso8601?(date)
+    date.is_a? String and date =~ /^\d{4}-(0\d|1[0-2])-([0-2]\d|3[0-1])T([0-1]\d|2[0-4]):([0-5]\d):([0-5]\d)([zZ]|([+-](0\d|1[0-4]):[0-5]\d))/
+  end
+
+  def self.is_valid?(strtime, options={})
+    options.reverse_merge!(:blank_is_valid => true)
+
+    if strtime.blank?
+      return options[:blank_is_valid]
+    else
+      begin
+        return (Time.zone.parse(strtime) ? true : false)
+      rescue
+        return false
+      end
+    end
+  end
+
+  def self.parse_in_utc(date_string)
+    last_time_zone = Time.zone.name
+
+    Time.zone = 'UTC'
+    utc_time = Time.zone.parse(date_string)
+    Time.zone = last_time_zone
+
+    return utc_time
+  end
+
+  def self.parse_timestamp(raw_timestamp, options={})
+    options.reverse_merge!(:time_only => false)
+
+    timestamp = Time.zone.parse(raw_timestamp)
+
+    return options[:time_only] ? timestamp.strftime("%H:%M:%S") : timestamp
+  end
+
+  def self.round(datetime, seconds=60)
+    return Time.at((datetime.to_f / seconds).round * seconds)
+  end
+
+  def self.seconds_to_unit(seconds, options={})
+    options.reverse_merge!(:force => nil, :format => :time, :show_unit => true)
+    seconds = seconds.to_f
+
+    result = seconds
+    time_table = {'year' => 31536000, 'day' => 86400, 'hour' => 3600, 'minute' => 60, 'second' => 1}
+    unit_selected = 'second'
+
+    time_table.each do |unit, value|
+      if (seconds >= value and not options[:force]) or (unit == options[:force])
+        unit_selected = unit
+        result = seconds / value
+        break
+      end
+    end
+
+    formatted_result = (options[:format] == :time) ? format_in_time(result) : sprintf("%0.02f", result)
+
+    if options[:show_unit]
+      return formatted_result + " " + I18n.t("datetime.short.#{unit_selected}")
+    else
+      return formatted_result.to_i
+    end
+  end
+
+  def self.start_timer
+    @timer = Time.now
+  end
+
+  def self.stop_timer
+    Time.now - @timer
+  end
+
+  def self.time_format
+    {
+      :basic => "%Y%m%dT%H%M%S",
+      :shortdate => "%Y-%m-%d",
+      :shorttime => "%H:%M:%S",
+      :shortdatetime => "%Y-%m-%dT%H:%M:%S"
+    }
+  end
+
+  def self.time_process_in_seconds(time)
+    time = time.split('.')[0]
+    new_time = time.split(':')
+
+    return (new_time[new_time.length-2].to_i * 60).to_i + new_time.last.to_i
+  end
+
+  def self.datetime_standard
+    [ :iso8601 ]
+  end
+
+  def self.timestamp(date=nil)
+    date = Time.now.getgm unless date
+
+    return date.strftime("%Y%m%d%H%M%S")
+  end
+
+  def self.timestamp_db(date=nil)
+    date = Time.now unless date
+
+    return date.strftime("%Y-%m-%d %H:%M:%S")
+  end
+
+  def self.timezone(date, options={})
+    options.reverse_merge!(:standard => :iso8601)
+    send("timezone_" + options[:standard].to_s, date) if datetime_standard.include?(options[:standard])
+  end
+
+  def self.timezone_iso8601(date)
+    if date.utc?
+      'Z'
+    else
+     off = date.utc_offset
+     sign = off < 0 ? '-' : '+'
+     sprintf('%s%02d:%02d', sign, *(off.abs / 60).divmod(60))
+    end
+  end
+
+  def self.to_iso8601(date, options={})
+    options.reverse_merge!(:format => :basic, :utc => false, :timezone => false)
+
+    date = date.utc if options[:utc]
+
+    if time_format[options[:format]]
+      iso8601_date = date.strftime(time_format[options[:format]])
+      iso8601_date = iso8601_date + timezone(date, :standard => :iso8601) if options[:timezone] and options[:format] != :shortdate
+    else
+      iso8601_date = date.iso8601
+    end
+
+    return iso8601_date
+  end
+end

data/lib/tool_pouch/locksmith.rb

@@ -0,0 +1,111 @@
+require 'active_support/time'
+require 'active_support/core_ext/object'
+require 'tool_pouch/trail'
+
+module ToolPouch::Locksmith
+  include ToolPouch
+
+  def self.build_digest_request(url, password, lifespan = 2.minutes)
+    if url.blank? || password.blank?
+      nil
+    else
+      nonce = Babel.random_string(15)
+      timestamp = (Time.now + lifespan).utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+      escaped_timestamp = CGI.escape(timestamp)
+
+      uri = Addressable::URI.parse url
+      params = uri.query_values || {}
+      params.merge!({'timestamp' => timestamp, 'nonce' => nonce})
+
+      digested_url = digest_uri(uri, params).to_s
+      params.merge!({
+        token: hexdigest([password, nonce, escaped_timestamp].join, digested_url)
+      })
+      uri.query_values = params
+      uri.to_s
+    end
+  end
+
+  def self.check_digest_request(url, password)
+    if url.blank? || password.blank?
+      false
+    else
+      uri = Addressable::URI.parse url
+      params = uri.query_values || {}
+
+      unescaped_timestamp = CGI.unescape(params['timestamp'].to_s)
+      escaped_timestamp = CGI.escape(unescaped_timestamp)
+      token_key = [password, params['nonce'].to_s, escaped_timestamp].join
+
+      digested_url = digest_uri(uri, params).to_s
+
+      expire_at = Krono.parse_in_utc(unescaped_timestamp)
+      compare_hexdigest(token_key, digested_url, params['token']) && expire_at.future?
+    end
+  end
+
+  # Harmonize generated URL and request URL so they can be compared.
+  #   Digest params are added to the query
+  #   Scheme is ignored (harmonized to http)
+  #   Note that the gem Adressable do order the query string by key values
+  def self.digest_uri(original_uri, params = nil)
+    uri = original_uri.dup
+    if params
+      p = params.dup
+      p.delete 'token'
+      uri.query_values = p
+    end
+    uri.scheme = nil
+    uri.port = nil
+    uri.to_s
+  end
+
+  def self.compare_hexdigest(password, value, target_key)
+    password and value and OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), password, value.to_s) == target_key
+  end
+
+  def self.decrypt(value, password)
+    decrypted_value = nil
+
+    if value and password
+      c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+      c.decrypt
+      c.key = Digest::SHA1.hexdigest(password)
+      begin
+        decrypted_value = c.update(Base64.decode64(value))
+        decrypted_value << c.final
+      rescue
+        decrypted_value = nil
+      end
+    end
+
+    return decrypted_value
+  end
+
+  def self.encrypt(value, password)
+    encrypt = nil
+
+    if value and password
+      begin
+        c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+        c.encrypt
+        c.key = Digest::SHA1.hexdigest(password)
+        e = c.update(value)
+        e << c.final
+        encrypt = Base64.encode64(e).strip
+      rescue
+        encrypt = nil
+      end
+    end
+
+    return encrypt
+  end
+
+  def self.generate_file_checksum(file)
+    File.exist?(file) ? Digest::MD5.hexdigest(File.read(file)) : nil
+  end
+
+  def self.hexdigest(password, value)
+    (password and value) ? OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), password, value) : nil
+  end
+end