friendly_extensions 0.0.8

data/lib/numbers.rb

@@ -0,0 +1,180 @@
+# -*- encoding : utf-8 -*-
+# Numeric Extensions
+module Numbers
+  
+  Numeric.class_eval do
+  
+    # Convert Number to numeric german style with precision
+    def to_euro(label = nil, options = {})
+      options[:precision] ||= 2
+      
+      options[:precision] = 0 if options[:fix_int] == true && self.is_a?(Integer)
+      
+      result = ActionController::Base.helpers.number_with_precision(self, :precision => options[:precision], :separator => ",", :delimiter => ".")
+    
+      if options[:pre] == true && self > 0
+        result = "+#{result}"
+      elsif options[:pre] == true && self < 0
+        result = "-#{result}"
+      end  
+        
+    
+      if !label.blank?
+        return [result, label].join("&nbsp;").html_safe
+      else
+        return result
+      end    
+    end
+  
+    # Convert Number to numeric german style without precision
+    def to_de(label=nil)
+      self.to_euro(label, :precision => 0)
+    end  
+    
+    def to_a
+      [self]
+    end  
+  
+    # Inflate number, y = duration of years, f = percentage
+    # tested
+    def infla(y=40,f=2)
+      self.to_f*(f.to_q**y)
+    end
+  
+    # Deflate number, y = duration of years, f = percentage
+    # tested
+    def defla(y=40,f=2)
+      self.to_f*((1-(f.fdiv(100)))**y)
+    end
+  
+    # Prüfen, welche Zahl aus dem Array am nächsten an der aktuellen Dran ist
+    # tested
+    def get_closest(nrs = [], lim = :ceil)
+    
+      com = {}
+      com_a = []
+      nrs.each do |n|
+        case lim
+        when :ceil
+          x = ((self+0.001)-n).abs
+        when :floor
+          x = ((self-0.001)-n).abs
+        else
+          raise ArgumentError, "lim must be :ceil or :floor"
+        end    
+        com.merge!(x => n)
+        com_a << x
+      end
+      return com[com_a.min]  
+    end  
+  
+    # tested
+    def min(ref)
+      [self.to_f, ref.to_f].min
+    end
+  
+    # tested
+    def max(ref)
+      [self.to_f, ref.to_f].max
+    end
+  
+    # Wert zwischen den Grenzen, ansonsten ober-oder unterkante
+    # tested
+    def min_max(m1, m2)
+      self.min(m2).max(m1)
+    end  
+  
+    # => tested
+    def fdiv(d)
+      self.to_f/d
+    end
+  
+  
+    # Finanzmathematik, Zinsen und so
+    def to_q
+      1+(self/100.0)
+    end  
+  
+    def alpha_sum(u,o)
+      (self**u - self**(o+1)).fdiv(1-self)
+    end  
+  
+  
+    def to_time(options = {})
+      values = [ self.to_i/3600, self.to_i / 60 % 60, self.to_i%60 ].map{ |t| t.to_s.rjust(2, '0') }
+      if options[:split] == true
+        return {:h => values[0].round, :m => values[1].round, :s => values[2].round}
+      elsif options[:discard_hour] == true && values[0] == "00"
+        return values[1,2].join(':')
+      else  
+        return values.join(':')
+      end  
+    end 
+    
+    def deg2rad
+      self * Math::PI / 180
+    end  
+  
+    
+  end  
+
+  Integer.class_eval do
+  
+  
+  
+    def odd?
+      self%2 == 0
+    end
+  
+    def even?
+      !self.odd?
+    end    
+  
+
+    # Cals
+    def to_years(options = {:s_years => "Jahre", :s_months => "Monate", :s_sep => "und"})
+      x = [self/12, self%12]
+      "#{x[0]} #{options[:s_years]} #{options[:s_sep]} #{x[1]} #{options[:s_months]}"
+    end
+  
+    def days_to_months(options = {:s_days => "Tage", :s_months => "Monate", :s_sep => "und"})
+      x = [self/30, self%30]
+      "#{x[0]} #{options[:s_months]} #{options[:s_sep]} #{x[1]} #{options[:s_days]}"
+    end 
+    
+    
+    # Split number in smallest prime factors
+    def prime_factors(options = {})
+      options[:nrs] ||= Math.sqrt(self).floor.prime_numbers
+      options[:nrs].each_with_index do |n,i|
+        if self%n == 0
+          return [n, (self/n).prime_factors(:nrs => options[:nrs])].flatten.except(1)
+        elsif i == options[:nrs].size-1
+          return [self]
+        end      
+      end
+    end
+    
+    # Create list with prime numbers up to 'self'  
+    def prime_numbers
+      s = (0..self).to_a
+      s[0] = s[1] = nil
+      s.each do |p|
+        next unless p
+        break if p * p > self
+        (p*p).step(self, p) { |m| s[m] = nil }
+      end
+      s.compact
+    end  
+ 
+  end
+
+
+  Fixnum.class_eval do
+    def nan?
+      self.to_f.nan?
+    end
+  end
+
+end
+

data/lib/smart_currency.rb

@@ -0,0 +1,66 @@
+# -*- encoding : utf-8 -*-
+module SmartCurrency
+  
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    def smart_currency
+      unless smart_currency?
+          include InstanceMethods
+          auto_attributes = []
+          self.skip_time_zone_conversion_for_attributes = []
+          attributes = self.columns.select {|c| (c.type == :integer || c.type == :decimal) && !c.name.match("id") }
+          
+          attributes.each do |a|
+            define_method("#{a.name}=") do |val|
+              self[a.name.to_sym] = currency_to_db(val)
+            end  
+          end  
+          
+      end    
+    end
+    
+    def smart_currency?
+      self.included_modules.include?(InstanceMethods)
+    end
+    
+  end  
+
+  module InstanceMethods # any method placed here will apply to instaces, like @hickwall  
+    
+    def currency_to_db(string)
+      if string.is_a?(String) 
+        return (string.gsub(/\./, '').gsub(/,/, '.')).to_f
+      elsif string.nil?
+        return 0
+      else  
+        return string
+      end      
+    end
+
+    def currency_to_view(decimal)
+      if !decimal.nil?
+        str = decimal.to_s.split(".")
+        str[1] = "0" unless str[1]
+        if str[1].size == 1
+          str[1] += "0"
+        end
+        if str[0].size == 5 || str[0].size == 6
+          str[0].gsub!(/\B([0-9]{3})\b/,'.\1')
+        elsif str[0].size > 7
+          str[0].gsub!(/([0-9]{3})\b/,'.\1').gsub!(/([0-9]{3}\.)/, '.\1') 
+        else
+          str[0].gsub!(/\B([0-9]{3})/,'.\1')  
+        end
+        str[1].size > 2 ? str[1] = str[1][0..1] : nil
+        return (str[0] + "," + str[1]).to_s  
+      else                                 
+        return "keine Angabe"
+      end  
+    end
+    
+  end
+   
+end

data/lib/string_and_more.rb

@@ -0,0 +1,301 @@
+# -*- encoding : utf-8 -*-
+module StringAndMore
+  String.class_eval do
+  
+    require "chars_2_remove"
+    require 'digest/sha1'
+    
+    # List with internation chars and their ASCII replacement
+    CHARS_TO_REMOVE = Chars2Remove::CHARS
+    
+    # Characters for creating randdom char combinations
+    String::RANDOM_CHARS = {:upcase => "ABCDEFGHIJKLMNOPQRSTUVWXYZ", :downcase => "abcdefghijklmnopqrstuvwxyz", :numbers => "1234567890"}
+    
+    # String charsets used for numeric encryption
+    STRING_CHARSETS = {
+      "a" => String::RANDOM_CHARS[:upcase],
+      "A" => String::RANDOM_CHARS[:downcase],
+      "1" => String::RANDOM_CHARS[:numbers],
+      "ä" => "äöüÄÖÜß",
+      "!" => '!\"§$%&/()=?+*#@,.-;:_\' ¡“”¶¢[]|{}≠¿^°≤≥∞…–‘’<>'
+    }
+    
+    # Array with all strings which can be encrypted
+    STRING_BASE = STRING_CHARSETS.values.join("")
+    
+    # Encode String Base with custom secrect key
+    #SHUFFLED_STRING_BASE =  STRING_CHARSETS.values.sort_by {|y| STRING_CHARSETS.values.map.with_index {|x,i| STRING_BASE.split("").reverse[i].hex * x.hex }[STRING_CHARSETS.values.index(y)] }
+    
+  
+    # Returns random String, for Passwords, Captachs etc..
+    # could create :upcase, :downcase, :numbers or :all
+    def self.random_string(l=12, mode = :all)
+      case mode
+      when :all
+        base = String::RANDOM_CHARS.values.join("").split("")
+      else
+        base = String::RANDOM_CHARS[mode].split("")
+      end
+    
+      str = ""
+    
+      l.times do 
+        str <<  base.shuffle[rand(base.size-1)]
+      end    
+      return str
+    end
+    
+    def self.email_message_id(mail_domain)
+      "<#{Digest::SHA2.hexdigest(Time.now.to_i.to_s)}@#{mail_domain}>"
+    end  
+  
+  
+    # Extract boolean status from string
+    def to_boolean
+      if ['true', 'True', 'TRUE', '1'].include?(self)
+        return true
+      else
+        return false
+      end
+    end
+  
+    # Create string with german date format to Date
+    def to_date
+      # Try German
+      matched_date = self.match(/((0|1|2|3)[0-9]{1})\.(0[0-9]{1}|10|11|12)\.[0-9]{4}/)
+      
+      if !matched_date.nil?
+        return Date.new(matched_date.to_s.split(".")[2].to_i, matched_date.to_s.split(".")[1].to_i, matched_date.to_s.split(".")[0].to_i)
+      elsif matched_date.nil?
+        matched_date = self.match(/[0-9]{4}-(0[0-9]{1}|10|11|12)-((0|1|2|3)[0-9]{1})/)
+        if !matched_date.nil?
+          return Date.new(matched_date.to_s.split("-")[0].to_i, matched_date.to_s.split("-")[1].to_i, matched_date.to_s.split("-")[2].to_i)
+        end  
+      end 
+       
+      raise ArgumentError, "String has no date like DD.MM.YYYY or YYYY-DD-MM" if matched_date.nil?
+    end
+    
+    
+    def to_number(type = :float)
+      extract = self.match(/[0-9\.,]{1,}/).to_s
+      final = extract.gsub(".", "").gsub(",", ".")
+      case type 
+      when :float
+        return final.to_f
+      else
+        return final.to_i
+      end    
+    end  
+  
+    def to_label(options = {:show_tooltip => false})
+      if FriendsLabel.table_exists?
+        l = FriendsLabel::LABELS[self]
+        if l.nil? 
+          FriendsLabel.create(:label => self, :attribute_name => self)
+          return self
+        else  
+          unless options[:show_tooltip] == true
+            return l[:label]
+          else
+            return l[:tooltip]
+          end
+        end  
+      else
+        return self
+      end    
+    end
+    
+    def shuffle
+      self.split("").sort_by {rand}.join.humanize
+    end  
+  
+  
+    def to_foldername(sep = "_")
+      # deutsch umlaute ersetzen
+      parameterized_string = self.strip.gsub(/\ {2,}/ , " ").de_2_int
+    
+      # Turn unwanted chars into the separator
+      parameterized_string.gsub!(/[^a-zA-Z0-9ÄÖÜöäüß\-_]+/, sep)
+      unless sep.nil? || sep.empty?
+        re_sep = Regexp.escape(sep)
+        # No more than one of the separator in a row.
+        parameterized_string.gsub!(/#{re_sep}{2,}/, sep)
+        # Remove leading/trailing separator.
+        parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/, '')
+      end
+      return parameterized_string
+    end
+  
+  
+  
+    def de_2_int
+      str = self
+      CHARS_TO_REMOVE.each do |de, int|
+        str = str.gsub(de, int)
+      end
+      str = str.gsub("  ", " ")
+      return str  
+    end
+	
+    def limit(l=20)
+      if self.size > l
+        s = self.size
+        s2 = (((self.size-1)/2).round)
+        first = self.slice(0..s2)
+        last  = self.slice(s2+1..-1)
+      
+        l1 = (l/2).round
+      
+        "#{first.first(l1)}...#{last.last(l1)}"
+      else
+        return self
+      end    
+    end  
+	
+	
+	
+	
+    def to_datetime
+      date  = self.split(" ").first
+      time  = self.split(" ").last.split(":")
+      DateTime.new(date.split(".")[2].to_i, date.split(".")[1].to_i, date.split(".")[0].to_i, time.first.to_i, time.last.to_i)
+    end  
+	
+	
+    def clear_html(options = {})
+      ActionView::Base.full_sanitizer.sanitize(self, :tags => options[:tags] )
+    end
+  
+    def replace_html(from, to)
+      new_text = self
+      new_text = new_text.gsub("<#{from}>", "<#{to}>")
+      new_text = new_text.gsub("</#{from}>", "</#{to}>")
+      return new_text
+    end    
+	
+    def to_model
+      self.singularize.camelize.constantize
+    end  
+	
+    def to_a
+      return [self]
+    end  
+	
+    #== HTML Styling
+    # as the function names say
+    
+    def bold
+      "<b>#{self}</b>".html_safe
+    end
+	
+    def ital
+      "<i>#{self}</i>".html_safe
+    end
+	
+    def span
+      "<span>#{self}</span>".html_safe
+    end
+	
+    def uline
+      "<u>#{self}</u>".html_safe
+    end  
+	
+    def nbsp
+      self.gsub(" ", "&nbsp;").html_safe
+    end  
+  
+    def replace_entities(mode = :html, options = {})
+      str = self
+      Chars2Remove::ENTITIES.each do |orig, rep|
+        str = str.gsub(orig, rep[mode])
+      end
+      return str.html_safe  
+    end
+	
+    def add_brs
+      return self.gsub("\n", "<br />")
+    end    
+	
+    #== colorization in console
+    
+    def colorize(color_code)
+      "\e[#{color_code};40m#{self}\e[0m"
+    end
+
+    def red
+      colorize(31)
+    end
+
+    def green
+      colorize(32)
+    end
+
+    def yellow
+      colorize(33)
+    end
+
+    def pink
+      colorize(35)
+    end
+	
+   
+    #== Numerische encription
+    # cool thing for simple encrypt and decrypt strings
+   
+    def numberize(options = {})
+      # Basisarray das alle zeichen enthält die verschlüsselt werden können
+      string_array = STRING_BASE.split("")
+      
+      if options[:token]
+        string_array = string_array.sort_by {|x| x.hash*options[:token].inspect.bytes.join("").to_i}
+      end  
+      
+      # Nur Zahlen und buchstaben für die verschlüsselung/mix nehmen wg. URLs
+      string_array_filtered = string_array.select {|s| !s.match(/[a-zA-Z0-9\-_]/).nil? }
+      splitted = self.split("")
+
+      numbered_string = ""
+
+      splitted.each do |s|
+        position = string_array.index(s)
+        if !position.nil?
+          numbered_string << (position.to_s.rjust(2, "0")+string_array_filtered[rand(string_array_filtered.size-1)])
+        end  
+      end
+
+      return options[:base_64] == true ? Base64.encode64(numbered_string) : numbered_string  
+    end  
+	
+    def denumberize(options = {})
+      string_array = STRING_BASE.split("")
+      
+      if options[:token]
+        string_array = string_array.sort_by {|x| x.hash*options[:token].inspect.bytes.join("").to_i}
+      end 
+      
+      real_string = ""
+      (options[:base_64] == true ? Base64.decode64(self) : self  ).scan(/[0-9]{2}.{1}/).each do |s|
+        real_string << string_array[s.first(2).to_i]
+      end
+      return real_string  
+    end
+   
+   
+  
+  
+      
+  end
+  
+
+  Symbol.class_eval do
+
+    def to_label(options = {})
+      self.to_s.to_label(options)
+    end
+    
+    def gsub(old, repl)  
+      self.to_s.gsub(old, repl)
+    end  
+  end  
+end