friendly_extensions 0.0.8 → 0.0.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29c0b1955597b587688ee28aa4ed2db4aa362e21
-  data.tar.gz: e8877f694cd2e9f205cd0f5791ebcec25f0187d6
+  metadata.gz: ebc04c86f165e85cce604a03cbe21ffa685304e0
+  data.tar.gz: 3826585ee6fb0d1544bbde4e4b93519604a3a45b
 SHA512:
-  metadata.gz: 14e5181cd8bf96edb76e90108ffaf724f62037f91098cc03ed23119e13d63f07e0ca41320f7e05e513e64887516208ebaea074fba7941d13d6d0febdd6fe1d40
-  data.tar.gz: b10b32aa9e92e6737ff0c4635270547ecbc903b180d84896f15349c7fa4c4c68913065b62df48c0e95ca19decfb9f44a5f0e4cb84e430f827f721a0c59d68508
+  metadata.gz: 3dc232df0e30edef609b48f461b8fa099e5e33ff19172f0b6db7f42a3cad3a3e2ac398fdf0abb934946e899bff56da43bf68d9257be95ec30e61305a0a805c5d
+  data.tar.gz: eb1f47fa799d108f31025ac86c3fad18d77ba99d99e546530509efafc663f9589429957c6ef71dc56c9b9e8921e987a02a45a9041e94798560f4e03061f465de

data/lib/alphanumeric.rb

@@ -3,10 +3,6 @@ module Alphanumeric
   
   # Give every year a letter
   # TODO: should be automatically computed
-  LETTERS = "abcdefghijklmnopqrstuvwxyz".upcase.split('')
-  
-  START_YEAR = 1960
-  
   YEAR_LETTERS = {
     2009 => "A",
     2010 => "B",
@@ -52,25 +48,8 @@ module Alphanumeric
     2050 => "PA",
   }
   
-  def self.year_letter(year=Time.now.year, letters = LETTERS)
-    
-    steps = []
-    
-    d = (year - START_YEAR)
-    n = d.fdiv(letters.size).ceil
-    string = ""
-    
-    n.times do |i| 
-      # First 
-      if i == 0
-        string << letters[d%letters.size]
-      else
-        x = d.fdiv(letters.size*(i+1)).round
-        string << letters[x]
-      end    
-    end  
-    
-    return string
+  def self.year_letter(year=Time.now.year)
+    YEAR_LETTERS[year]
   end  
 
 end  

data/lib/array.rb

@@ -16,20 +16,20 @@ module ArrayExt
     # Get avg. value from, either from numeric values or from
     # values from a object included in array
     def avg(attribute = nil)
-      value = self
+      @value = self
       if attribute.nil?
-        value.delete(nil)
-        value = self.map {|r| r.to_f }
+        @value.delete(nil)
+        @value = self.map {|r| r.to_f }
       else
-        value = self
+        @value = self
         # Bei fehlerhaften attribute wird nil gespeichert
-        value = value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
+        @value = @value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
         # Leere Werte löschen
-        value.delete(nil)
+        @value.delete(nil)
       end
-      # Divide by zero ausschließen
-      value.size == 0 ? size = 1 : size = value.size
-      value.sum / size
+      # Divide by zero ausschliessen
+      @value.size == 0 ? size = 1 : size = @value.size
+      @value.sum / size
     end
   
   
@@ -134,15 +134,15 @@ module ArrayExt
   
     # break array into n arrays
     def seperate(n = 8)
-      f = n
+      @f = n
       aks_size  = self.size
-      rest      = aks_size % f
+      rest      = aks_size % @f
 
-      stack = ((aks_size - rest) / f)
+      @stack = ((aks_size - rest) / @f)
 
-      arrays = (1..f).to_a
+      arrays = (1..@f).to_a
 
-      arrays.map! {|i| self.first(stack*i).last(stack) }
+      arrays.map! {|i| self.first(@stack*i).last(@stack) }
       arrays[-1] += self.last(rest) if rest != 0
       #arrays.last.pop if (arrays.last.last.empty? || arrays.last.last.blank?)
       return arrays
@@ -164,7 +164,7 @@ module ArrayExt
     def to_sql
       return "(NULL)" if self.empty?
       if self.first.is_a?(Numeric)
-        return "(#{self.compact.join(',')})"
+        return "(#{self.join(',')})"
       else
         return "(#{self.map{|i| "'#{i.to_s}'"}.join(',')})"
       end    
@@ -199,82 +199,7 @@ module ArrayExt
       else  
         self.join(sep)
       end  
-    end 
-    
-    
-    def interpolate(filtered_value = nil, options = {})
-      begin
-      
-        int_start_value = nil
-        int_end_value   = nil
-        int_from        = 0
-        int_to          = 0 
-        int_steps       = 0 
-      
-        array_with_interpolation = []
-      
-        self.each_with_index do |x,i| 
-          if i > 0
-            if x != filtered_value
-              # Wenn der letze ein fehler war ist die strecke zuende
-              if self[i-1] == filtered_value
-              
-                if i-1 == 0
-                  # Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
-                  # 
-                  m = (self[i+1]-x)
-                
-                  array_with_interpolation[0] = x-m
-                  array_with_interpolation << x
-                
-                else  
-                  int_end_value = x
-                  int_to        = i
-                
-                  # Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
-                  m = (int_end_value-int_start_value).fdiv((int_to-int_from))
-              
-                  # Fülle fehlende werte mit werten (y = mx + b)
-                  int_steps.times {|mi| array_with_interpolation << (int_start_value+((mi+1)*m)) }
-                  array_with_interpolation << int_end_value
-              
-                  # Reset all values
-                  int_start_value = int_end_value
-                  int_end_value   = nil
-                  int_from        = 0
-                  int_to          = 0 
-                  int_steps       = 0  
-                  puts array_with_interpolation.inspect
-                end  
-              else  
-                int_start_value = x
-                array_with_interpolation << x
-              end
-            # Wenn letzer wert fehlerhaft  
-            elsif i == self.size-1 && x == filtered_value
-              # Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
-              # Berechnung über gesamtes array
-              m = (array_with_interpolation.last-array_with_interpolation.first).fdiv(array_with_interpolation.size-1)
-              array_with_interpolation << (array_with_interpolation.last+m)
-            else  
-              int_steps += 1
-              int_from = i-int_steps
-            end    
-      
-          else
-            int_start_value = x
-            array_with_interpolation << x
-          end    
-        
-        end  
-      
-        return array_with_interpolation
-      rescue
-        puts "WARNING: Interpolation not possible!".red
-        return self
-      end    
-      
-    end   
+    end  
 
   end  
 end

data/lib/friendly_extensions.rb

@@ -1,14 +1,14 @@
 # -*- encoding : utf-8 -*-
 # All dit janze zeug laden
 
-require "friendly_extensions/engine"
-
 require "array"
+
 require "date_n_time"
 require "numbers"
 require "hash"
 require "string_and_more"
 require "boolean"
+
 require "nil_class"
 
 # SmartCurrency jetzt auch hier (26.03.2013, 16:30, Florian Eck)

data/lib/nil_class.rb

@@ -1,12 +1,9 @@
 # -*- encoding : utf-8 -*-
 NilClass.class_eval do
 
-  def to_euro(label = nil, options = {})
-    "unbekannt"
+  def to_euro(options={})
+    return "?"
   end
   
-  def to_de(label = nil, options = {})
-    "unbekannt"
-  end  
 
 end  

data/lib/numbers.rb

@@ -2,14 +2,37 @@
 # Numeric Extensions
 module Numbers
   
+  # 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  
+  
   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
@@ -28,11 +51,13 @@ module Numbers
   
     # Convert Number to numeric german style without precision
     def to_de(label=nil)
-      self.to_euro(label, :precision => 0)
-    end  
-    
-    def to_a
-      [self]
+      nr = self.round.to_i
+      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
@@ -70,12 +95,12 @@ module Numbers
   
     # tested
     def min(ref)
-      [self.to_f, ref.to_f].min
+      [self, ref].min
     end
   
     # tested
     def max(ref)
-      [self.to_f, ref.to_f].max
+      [self, ref].max
     end
   
     # Wert zwischen den Grenzen, ansonsten ober-oder unterkante
@@ -110,10 +135,6 @@ module Numbers
         return values.join(':')
       end  
     end 
-    
-    def deg2rad
-      self * Math::PI / 180
-    end  
   
     
   end  
@@ -140,33 +161,8 @@ module Numbers
     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     
+  
   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.match("id") }
+          attributes = self.columns.select {|c| (c.type == :integer || c.type == :decimal) && c.name != "id" }
           
           attributes.each do |a|
             define_method("#{a.name}=") do |val|
@@ -33,9 +33,7 @@ module SmartCurrency
     def currency_to_db(string)
       if string.is_a?(String) 
         return (string.gsub(/\./, '').gsub(/,/, '.')).to_f
-      elsif string.nil?
-        return 0
-      else  
+      else
         return string
       end      
     end

data/lib/string_and_more.rb

@@ -22,10 +22,6 @@ module StringAndMore
     
     # 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
@@ -44,10 +40,6 @@ module StringAndMore
       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
@@ -60,21 +52,12 @@ module StringAndMore
     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}/)
+  	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?
       
-      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
+  	  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)
+  	end
     
     
     def to_number(type = :float)
@@ -89,28 +72,33 @@ module StringAndMore
     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    
+      attribute = self
+      l = ConceptLabel::LABELS[attribute]
+      if l.nil? 
+        ConceptLabel.create(:label => attribute, :attribute_name => attribute)# rescue nil
+        return attribute
+      else  
+        unless options[:show_tooltip] == true
+          return l[:label]
+        else
+          return l[:tooltip]
+        end
+      end  
     end
-    
-    def shuffle
-      self.split("").sort_by {rand}.join.humanize
-    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 to_foldername(sep = "_")
       # deutsch umlaute ersetzen
       parameterized_string = self.strip.gsub(/\ {2,}/ , " ").de_2_int
@@ -138,155 +126,143 @@ module StringAndMore
       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)
+  	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  
+  	    "#{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 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 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}>")
+  	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    
+  	end    
 	
-    def to_model
+  	def to_model
       self.singularize.camelize.constantize
-    end  
+  	end  
 	
-    def to_a
-      return [self]
-    end  
+  	def to_a
+  	  return [self]
+  	end  
 	
-    #== HTML Styling
+  	#== HTML Styling
     # as the function names say
     
-    def bold
+  	def bold
       "<b>#{self}</b>".html_safe
-    end
+  	end
 	
-    def ital
+  	def ital
       "<i>#{self}</i>".html_safe
-    end
+  	end
 	
-    def span
+  	def span
       "<span>#{self}</span>".html_safe
-    end
+  	end
 	
-    def uline
+  	def uline
       "<u>#{self}</u>".html_safe
-    end  
+  	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 replace_entities(mode = :html)
+  	  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    
+  	def add_brs
+  	  return self.gsub("\n", "<br />")
+  	end    
 	
-    #== colorization in console
+  	#== colorization in console
     
-    def colorize(color_code)
-      "\e[#{color_code};40m#{self}\e[0m"
-    end
+      def colorize(color_code)
+        "\e[#{color_code};40m#{self}\e[0m"
+      end
 
-    def red
-      colorize(31)
-    end
+      def red
+        colorize(31)
+      end
 
-    def green
-      colorize(32)
-    end
+      def green
+        colorize(32)
+      end
 
-    def yellow
-      colorize(33)
-    end
+      def yellow
+        colorize(33)
+      end
 
-    def pink
-      colorize(35)
-    end
+      def pink
+        colorize(35)
+      end
 	
    
-    #== Numerische encription
-    # cool thing for simple encrypt and decrypt strings
+   #== 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("")
+   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 = ""
+     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
+     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  
+     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
-   
-   
-  
+   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