friendly_extensions 0.0.62 → 0.0.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff2c7ed3b7ba8d409f8ca14d3cbf0f168fc7a633
-  data.tar.gz: c240211d83e278a198fb710393ea1f3368f4495a
+  metadata.gz: 599b81295e728316bffa52a91ee0f83cfe21a0fc
+  data.tar.gz: e279fc4b1e79c9dd27f2e59bcc223b472e20620e
 SHA512:
-  metadata.gz: 4b0a21c79bfeb6506dda677f9143e8e12d06561702fd2cf47ddd7f464e2445d83ca670a350bd6cec774e068812d84ed9bd54a363d400f09573e70d3f142ec2aa
-  data.tar.gz: 39ab444b280dae8877f3571ca4c4d8779e6b3030c5731b636f3f15b3c48b6b7bdcfcc54075d6fa9c5d4d688acd6a2d08b2b2adb7851f547c5b6af98aa3efa63e
+  metadata.gz: 29f70901e22e4edaff2566793f6d564606467fdeace229fcb910dc1c129f53b7fea4a866b9c3b64a30927f5142bb4c9b4f4980314e2aad1fba19193987105ad2
+  data.tar.gz: 777f32151ae55d93267d001432a3d361f32bf72b193fbf9a480d4c29eca51c338fc7995533e00ba038cfdb8536548473d0d6850981830f57074b011b50b63eb7

data/lib/array.rb

@@ -164,7 +164,7 @@ module ArrayExt
     def to_sql
       return "(NULL)" if self.empty?
       if self.first.is_a?(Numeric)
-        return "(#{self.join(',')})"
+        return "(#{self.compact.join(',')})"
       else
         return "(#{self.map{|i| "'#{i.to_s}'"}.join(',')})"
       end    

data/lib/friendly_extensions/engine.rb

@@ -0,0 +1,10 @@
+module FriendlyExtensions
+  class Engine < Rails::Engine
+    engine_name "friendly_extensions"
+    
+    initializer "friends.labeled_form_helper" do
+      ActionView::Helpers::FormBuilder.send(:include, FriendsLabeledFormHelper)
+    end  
+    
+  end
+end    

data/lib/friendly_extensions.rb

@@ -1,14 +1,14 @@
 # -*- encoding : utf-8 -*-
 # All dit janze zeug laden
 
-require "array"
+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/numbers.rb

@@ -7,6 +7,9 @@ module Numbers
     # 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
@@ -25,12 +28,11 @@ module Numbers
   
     # Convert Number to numeric german style without precision
     def to_de(label=nil)
-      result = ActionController::Base.helpers.number_with_precision(self, :precision => 0, :separator => ",", :delimiter => ".")
-      if !label.blank?
-        return [result, label].join(" ").html_safe
-      else
-        return result
-      end
+      self.to_euro(label, :precision => 0)
+    end  
+    
+    def to_a
+      [self]
     end  
   
     # Inflate number, y = duration of years, f = percentage
@@ -108,6 +110,10 @@ module Numbers
         return values.join(':')
       end  
     end 
+    
+    def deg2rad
+      self * Math::PI / 180
+    end  
   
     
   end  

data/lib/string_and_more.rb

@@ -40,6 +40,10 @@ 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
@@ -81,17 +85,21 @@ module StringAndMore
     end  
   
     def to_label(options = {:show_tooltip => false})
-      l = ConceptLabel::LABELS[self]
-      if l.nil? 
-        ConceptLabel.create(:label => self, :attribute_name => self)
+      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
-      else  
-        unless options[:show_tooltip] == true
-          return l[:label]
-        else
-          return l[:tooltip]
-        end
-      end  
+      end    
     end
     
     def shuffle

data/test/array_test.rb

@@ -24,7 +24,7 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal test_array.avg(:number), 4.5
   end
   
-  def test_array_avg_should_no_break_with_nil_and_emtpy
+  def test_array_avg_should_not_break_with_nil_and_emtpy
     assert_equal [3,nil].avg, 3
     assert_equal [].avg, 0
   end  

data/test/numeric_test.rb

@@ -9,6 +9,10 @@ class NumericTest < Test::Unit::TestCase
     #assert_equal 0.29.to_euro, "0,29"
   end
   
+  def test_number_should_convert_to_array
+    assert_equal 1.to_a, [1]
+  end  
+  
   # Test Math Functions  
   def test_math_infla_defla
     

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: friendly_extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.62
+  version: 0.0.65
 platform: ruby
 authors:
 - Florian Eck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-18 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -32,21 +32,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/alphanumeric.rb
-- lib/alphanumeric.rb.orig
 - lib/array.rb
-- lib/array.rb.orig
 - lib/boolean.rb
 - lib/chars_2_remove.rb
 - lib/date_n_time.rb
 - lib/friendly_extensions.rb
+- lib/friendly_extensions/engine.rb
 - lib/hash.rb
 - lib/nil_class.rb
 - lib/numbers.rb
-- lib/numbers.rb.orig
 - lib/smart_currency.rb
-- lib/smart_currency.rb.orig
 - lib/string_and_more.rb
-- lib/string_and_more.rb.orig
 - test/array_test.rb
 - test/array_test.rb.orig
 - test/dummy_class.rb
@@ -85,3 +81,4 @@ test_files:
 - test/numeric_test.rb
 - test/numeric_test.rb.orig
 - test/string_test.rb
+has_rdoc: 

data/lib/alphanumeric.rb.orig

@@ -1,84 +0,0 @@
-# -*- 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.orig

@@ -1,313 +0,0 @@
-# -*- 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/numbers.rb.orig

@@ -1,220 +0,0 @@
-# -*- 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.orig

@@ -1,74 +0,0 @@
-# -*- 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.orig

@@ -1,303 +0,0 @@
-# -*- 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