friendly_extensions 0.0.61 → 0.0.62

data/lib/numbers.rb.orig

@@ -0,0 +1,220 @@
+# -*- encoding : utf-8 -*-
+# Numeric Extensions
+module Numbers
+  
+<<<<<<< HEAD
+=======
+  # returns an array with all prime numbers up to limit
+  def self.prime_numbers(limit = 1_000_000, options = {:verbose => false})
+    i = 1; divisors = [2]; primzahlen = []
+    t = Time.now
+    while i <= limit do
+      p = true
+      divisors.each do |d|
+        if i%d == 0 && d != i
+          p = false
+          break
+        end  
+      end
+      
+      if p == true
+        puts i if options[:verbose] == true
+        primzahlen << i
+      end    
+      
+      i += 1
+      divisors << divisors.last+1
+    end  
+    
+    puts "Took #{(t-Time.now).abs.round(2)} sec." if options[:verbose] == true
+    return primzahlen
+  end  
+  
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  Numeric.class_eval do
+  
+    # Convert Number to numeric german style with precision
+    def to_euro(label = nil, options = {})
+      options[:precision] ||= 2
+      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)
+<<<<<<< HEAD
+=======
+      nr = self.round.to_i
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+      result = ActionController::Base.helpers.number_with_precision(self, :precision => 0, :separator => ",", :delimiter => ".")
+      if !label.blank?
+        return [result, label].join("&nbsp;").html_safe
+      else
+        return result
+      end
+    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)
+<<<<<<< HEAD
+      [self.to_f, ref.to_f].min
+=======
+      [self, ref].min
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+    end
+  
+    # tested
+    def max(ref)
+<<<<<<< HEAD
+      [self.to_f, ref.to_f].max
+=======
+      [self, ref].max
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+    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 
+  
+    
+  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]}"
+<<<<<<< HEAD
+    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     
+  
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  end
+
+
+  Fixnum.class_eval do
+    def nan?
+      self.to_f.nan?
+    end
+  end
+
+end
+

data/lib/smart_currency.rb

@@ -11,7 +11,7 @@ module SmartCurrency
           include InstanceMethods
           auto_attributes = []
           self.skip_time_zone_conversion_for_attributes = []
-          attributes = self.columns.select {|c| (c.type == :integer || c.type == :decimal) && c.name != "id" }
+          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|
@@ -33,7 +33,9 @@ module SmartCurrency
     def currency_to_db(string)
       if string.is_a?(String) 
         return (string.gsub(/\./, '').gsub(/,/, '.')).to_f
-      else
+      elsif string.nil?
+        return 0
+      else  
         return string
       end      
     end

data/lib/smart_currency.rb.orig

@@ -0,0 +1,74 @@
+# -*- 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 = []
+<<<<<<< HEAD
+          attributes = self.columns.select {|c| (c.type == :integer || c.type == :decimal) && !c.name.match("id") }
+=======
+          attributes = self.columns.select {|c| (c.type == :integer || c.type == :decimal) && c.name != "id" }
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+          
+          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
+<<<<<<< HEAD
+      elsif string.nil?
+        return 0
+      else  
+=======
+      else
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+        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

@@ -53,10 +53,19 @@ module StringAndMore
   
     # Create string with german date format to Date
   	def to_date
-      matched_date = self.match(/((0|1|2|3)[0-9]{1})\.(0[0-9]{1}|11|12)\.[0-9]{4}/)
-      raise ArgumentError, "String has no date like DD.MM.YYYY" if matched_date.nil?
+      # Try German
+      matched_date = self.match(/((0|1|2|3)[0-9]{1})\.(0[0-9]{1}|10|11|12)\.[0-9]{4}/)
       
-  	  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)
+      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
     
     
@@ -72,11 +81,10 @@ module StringAndMore
     end  
   
     def to_label(options = {:show_tooltip => false})
-      attribute = self
-      l = ConceptLabel::LABELS[attribute]
+      l = ConceptLabel::LABELS[self]
       if l.nil? 
-        ConceptLabel.create(:label => attribute, :attribute_name => attribute)# rescue nil
-        return attribute
+        ConceptLabel.create(:label => self, :attribute_name => self)
+        return self
       else  
         unless options[:show_tooltip] == true
           return l[:label]
@@ -85,19 +93,11 @@ module StringAndMore
         end
       end  
     end
-  
-  
-  
-    def to_glossar(with = "", options = {:show_tooltip => false})
-      with ||= ""
-      attribute = self
-      l = Glossar.find_by_attribute_name(attribute)
-      if l.nil?
-        Glossar.create(:label => attribute, :attribute_name => attribute)
-      end  
     
-      return "<a href='#glossar_#{attribute.parameterize}' class='glossarlink_small'>#{attribute}#{with}</a>".html_safe
-    end
+    def shuffle
+      self.split("").sort_by {rand}.join.humanize
+    end  
+  
   
     def to_foldername(sep = "_")
       # deutsch umlaute ersetzen
@@ -193,7 +193,7 @@ module StringAndMore
       self.gsub(" ", "&nbsp;").html_safe
     end  
   
-  	def replace_entities(mode = :html)
+  	def replace_entities(mode = :html, options = {})
   	  str = self
   	  Chars2Remove::ENTITIES.each do |orig, rep|
   	     str = str.gsub(orig, rep[mode])

data/lib/string_and_more.rb.orig

@@ -0,0 +1,303 @@
+# -*- 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("")
+  
+    # 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
+  
+  
+    # 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
+<<<<<<< HEAD
+      # 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?
+=======
+      matched_date = self.match(/((0|1|2|3)[0-9]{1})\.(0[0-9]{1}|11|12)\.[0-9]{4}/)
+      raise ArgumentError, "String has no date like DD.MM.YYYY" if matched_date.nil?
+      
+  	  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)
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  	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})
+      l = ConceptLabel::LABELS[self]
+      if l.nil? 
+        ConceptLabel.create(:label => self, :attribute_name => self)
+        return self
+      else  
+        unless options[:show_tooltip] == true
+          return l[:label]
+        else
+          return l[:tooltip]
+        end
+      end  
+    end
+<<<<<<< HEAD
+    
+    def shuffle
+      self.split("").sort_by {rand}.join.humanize
+    end  
+=======
+  
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  
+  
+    def to_glossar(with = "", options = {:show_tooltip => false})
+      with ||= ""
+      attribute = self
+      l = Glossar.find_by_attribute_name(attribute)
+      if l.nil?
+        Glossar.create(:label => attribute, :attribute_name => attribute)
+      end  
+    
+      return "<a href='#glossar_#{attribute.parameterize}' class='glossarlink_small'>#{attribute}#{with}</a>".html_safe
+    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  
+  
+<<<<<<< HEAD
+  	def replace_entities(mode = :html, options = {})
+=======
+  	def replace_entities(mode = :html)
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  	  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("")
+   
+     # 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("")
+     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