friendly_extensions 0.0.61 → 0.0.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ebc04c86f165e85cce604a03cbe21ffa685304e0
-  data.tar.gz: 3826585ee6fb0d1544bbde4e4b93519604a3a45b
+  metadata.gz: ff2c7ed3b7ba8d409f8ca14d3cbf0f168fc7a633
+  data.tar.gz: c240211d83e278a198fb710393ea1f3368f4495a
 SHA512:
-  metadata.gz: 3dc232df0e30edef609b48f461b8fa099e5e33ff19172f0b6db7f42a3cad3a3e2ac398fdf0abb934946e899bff56da43bf68d9257be95ec30e61305a0a805c5d
-  data.tar.gz: eb1f47fa799d108f31025ac86c3fad18d77ba99d99e546530509efafc663f9589429957c6ef71dc56c9b9e8921e987a02a45a9041e94798560f4e03061f465de
+  metadata.gz: 4b0a21c79bfeb6506dda677f9143e8e12d06561702fd2cf47ddd7f464e2445d83ca670a350bd6cec774e068812d84ed9bd54a363d400f09573e70d3f142ec2aa
+  data.tar.gz: 39ab444b280dae8877f3571ca4c4d8779e6b3030c5731b636f3f15b3c48b6b7bdcfcc54075d6fa9c5d4d688acd6a2d08b2b2adb7851f547c5b6af98aa3efa63e

data/lib/alphanumeric.rb

@@ -3,6 +3,10 @@ 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",
@@ -48,8 +52,25 @@ module Alphanumeric
     2050 => "PA",
   }
   
-  def self.year_letter(year=Time.now.year)
-    YEAR_LETTERS[year]
+  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
   end  
 
 end  

data/lib/alphanumeric.rb.orig

@@ -0,0 +1,84 @@
+# -*- encoding : utf-8 -*-
+module Alphanumeric
+  
+  # Give every year a letter
+  # TODO: should be automatically computed
+<<<<<<< HEAD
+  LETTERS = "abcdefghijklmnopqrstuvwxyz".upcase.split('')
+  
+  START_YEAR = 1960
+  
+=======
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  YEAR_LETTERS = {
+    2009 => "A",
+    2010 => "B",
+    2011 => "C",
+    2012 => "D",
+    2013 => "E",
+    2014 => "F",
+    2015 => "G",
+    2016 => "H",
+    2017 => "I",
+    2018 => "J",
+    2019 => "K",
+    2020 => "L",
+    2021 => "M",
+    2022 => "N",
+    2023 => "O",
+    2024 => "P",
+    2025 => "Q",
+    2026 => "R",
+    2027 => "S",
+    2028 => "T",
+    2029 => "U",
+    2030 => "V",
+    2031 => "W",
+    2032 => "X",
+    2033 => "Y",
+    2034 => "Z",
+    2035 => "AA",
+    2036 => "BA",
+    2037 => "CA",
+    2038 => "DA",
+    2039 => "EA",
+    2040 => "FA",
+    2041 => "GA",
+    2042 => "HA",
+    2043 => "IA",
+    2044 => "JA",
+    2045 => "KA",
+    2046 => "LA",
+    2047 => "MA",
+    2048 => "NA",
+    2049 => "OA",
+    2050 => "PA",
+  }
+  
+<<<<<<< HEAD
+  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]
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  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 ausschliessen
-      @value.size == 0 ? size = 1 : size = @value.size
-      @value.sum / size
+      # Divide by zero ausschließen
+      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
@@ -199,7 +199,82 @@ module ArrayExt
       else  
         self.join(sep)
       end  
-    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

data/lib/array.rb.orig

@@ -0,0 +1,313 @@
+# -*- encoding : utf-8 -*-
+# Add the methods to the Array Class
+module ArrayExt
+  Array.class_eval do
+  
+    # Use sum from Activesupport
+    # Sum is not a default in Ruby
+    def sum(identity = 0, &block)
+      if block_given?
+        map(&block).sum(identity)
+      else
+        inject { |sum, element| sum + element } || identity
+      end
+    end
+  
+    # Get avg. value from, either from numeric values or from
+    # values from a object included in array
+    def avg(attribute = nil)
+<<<<<<< HEAD
+      value = self
+      if attribute.nil?
+        value.delete(nil)
+        value = self.map {|r| r.to_f }
+      else
+        value = self
+        # Bei fehlerhaften attribute wird nil gespeichert
+        value = value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
+        # Leere Werte löschen
+        value.delete(nil)
+      end
+      # Divide by zero ausschließen
+      value.size == 0 ? size = 1 : size = value.size
+      value.sum / size
+=======
+      @value = self
+      if attribute.nil?
+        @value.delete(nil)
+        @value = self.map {|r| r.to_f }
+      else
+        @value = self
+        # Bei fehlerhaften attribute wird nil gespeichert
+        @value = @value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
+        # Leere Werte löschen
+        @value.delete(nil)
+      end
+      # Divide by zero ausschließen
+      @value.size == 0 ? size = 1 : size = @value.size
+      @value.sum / size
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+    end
+  
+  
+  
+    # Generate a hash with the given array elements as keys and 'init_value' as value
+    def array_to_hash(init_val = 0)
+      h = {}
+      self.each {|x| h.merge!(x => init_val) unless x.nil? }
+      return h
+    end
+  
+  
+    def to_structured_hash(attribute, options = {})
+      data = {}
+
+      self.each do |item|
+        if attribute.is_a?(Symbol) && options[:load_from_hash] != true
+          key = item.send(attribute) rescue ""
+        elsif attribute.is_a?(Symbol) && options[:load_from_hash] == true  
+          key = item[attribute] rescue ""
+        elsif attribute.is_a?(String)
+          attribute_methods = attribute.split(".")  
+          key = item.send(attribute_methods[0])
+          attribute_methods[1..-1].each do |x|
+            key = key.send(x) rescue ""
+          end
+        end
+
+        if data[key].nil?
+          data.merge!(key => [item])
+        else
+          data[key] << item
+        end      
+      end
+
+      return data  
+    end    
+
+  
+    # Sum up an array of objects with given attirbute
+    # Attributes can be given as symbol (:my_value will return obj.my_value)
+    # or as string ("user.my_value" will return my_value from user object which belongs to object in array)
+    # also, options could be passed, which could be *args or options hash
+    def sum_with_attribute(arg, opt =nil)
+      if arg.nil?
+        return self.compact.sum
+      else
+        values = []
+        if arg.is_a?(Symbol)
+          self.map {|i| ((opt.nil? ? i.send(arg) : i.send(arg, opt)) rescue 0) }.sum 
+        elsif arg.is_a?(String)
+          self.each do |v|
+            tag_methods = arg.split(".")  
+            tagx = v.send(tag_methods[0])
+            tag_methods[1..-1].each do |x|
+              # Use options if last method in chain called
+              if tag_methods[1..-1].last == x && !opt.nil?
+                tagx = tagx.send(x,opt)
+              else  
+                tagx = tagx.send(x)
+              end  
+            end
+            values << tagx  
+          end
+          return values.compact.sum
+        end
+      end
+    end
+  
+
+    # check the number of items included in the array
+    def count_for(item)
+      count = 0
+      self.each {|x| count += 1 if x == item}
+      return count
+    end
+  
+  
+    # return the item after the given val in array
+    # returns val if no item found or val is not included
+    # toggle :cycle => true to continue search at beginn of array if end is reached
+    def next(val, options = {})
+      i = self.index(val)
+      return val if i.nil?
+      
+      i == self.size-1 ?
+        (options[:cycle] == true ? self.first : val) : self[i+1] 
+    end  
+  
+  
+    # Schnittmenge / Intersection zwischen 2 Arrays
+    def isec(b)
+      raise ArgumentError, "#{b.inspect} is not an array" if !b.is_a?(Array)
+      (self- (self-b))
+    end  
+  
+    # like except for hash
+    def except(*args)
+      excluded = *args
+      return self - excluded
+    end  
+  
+    # break array into n arrays
+    def seperate(n = 8)
+<<<<<<< HEAD
+      f = n
+      aks_size  = self.size
+      rest      = aks_size % f
+
+      stack = ((aks_size - rest) / f)
+
+      arrays = (1..f).to_a
+
+      arrays.map! {|i| self.first(stack*i).last(stack) }
+=======
+      @f = n
+      aks_size  = self.size
+      rest      = aks_size % @f
+
+      @stack = ((aks_size - rest) / @f)
+
+      arrays = (1..@f).to_a
+
+      arrays.map! {|i| self.first(@stack*i).last(@stack) }
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+      arrays[-1] += self.last(rest) if rest != 0
+      #arrays.last.pop if (arrays.last.last.empty? || arrays.last.last.blank?)
+      return arrays
+    end
+  
+    # [1,2,3,5,6,7].stack(2)
+    #  will return [[1, 2], [3, 5], [6, 7]]
+    def stack(n = 4)
+      arr = []
+      i = (self.size.to_f/n).ceil
+      i.times do |x|
+        arr << self[x*n..(((x+1)*n)-1)]
+      end    
+      return arr
+    end  
+  
+
+    # Prepare array for use with mysql IN operator
+    def to_sql
+      return "(NULL)" if self.empty?
+      if self.first.is_a?(Numeric)
+        return "(#{self.join(',')})"
+      else
+        return "(#{self.map{|i| "'#{i.to_s}'"}.join(',')})"
+      end    
+    end 
+  
+    #== Untested / deprecated functions below, should be moved somewhere else!
+    # Ignore these functions, there are neither tested nor documented, use them for fun if you like but dont ask me ;-)
+  
+    def fill_with_sth(sth, size)
+      ary_length = self.size
+      diff = size - ary_length
+      if diff > 0
+        pop = Array.new(diff){|i| sth}
+        new_ary = pop.push(self).flatten!
+        return new_ary
+      else
+        return self
+      end
+    end
+
+
+    # Generiert einen JSON-String aus einem Array mit Werten
+    def json_labels
+      json = "["
+      self.each_with_index {|l,i| json << '{"id": "%s", "text": "%s"}' % [i, l] ; json << "," unless i+1 == self.size}
+      json << "]"
+    end
+
+    def to_text(sep = "<br />")
+      if Rails.env == "development"
+        raise "#REMOVED - use .join() - (17.12.2013, 15:18, Florian Eck)"
+      else  
+        self.join(sep)
+      end  
+<<<<<<< HEAD
+    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  
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+
+  end  
+end

data/lib/nil_class.rb

@@ -5,5 +5,8 @@ NilClass.class_eval do
     return "?"
   end
   
+  def to_de
+    "unbekannt"
+  end  
 
 end  

data/lib/numbers.rb

@@ -2,32 +2,6 @@
 # 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
@@ -51,7 +25,6 @@ module Numbers
   
     # Convert Number to numeric german style without precision
     def to_de(label=nil)
-      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
@@ -95,12 +68,12 @@ module Numbers
   
     # tested
     def min(ref)
-      [self, ref].min
+      [self.to_f, ref.to_f].min
     end
   
     # tested
     def max(ref)
-      [self, ref].max
+      [self.to_f, ref.to_f].max
     end
   
     # Wert zwischen den Grenzen, ansonsten ober-oder unterkante
@@ -161,8 +134,33 @@ 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     
-  
+    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