friendly_extensions 0.0.8

data/test/array_test.rb

@@ -0,0 +1,213 @@
+require "test/unit"
+require "array"
+require "dummy_class"
+
+class ArrayTest < Test::Unit::TestCase
+  
+  #== Tests for .sum
+  def test_array_should_sum
+    assert_equal [1,2].sum, 3
+  end  
+  
+  #== Tests for .avg
+  def test_array_avg_with_numbers
+    test_array = [4,5]
+    
+    assert_equal test_array.avg, 4.5
+  end  
+  
+  def test_array_avg_with_attributes
+    test_array = []
+    test_array << DummyClass.new(:number => 4)
+    test_array << DummyClass.new(:number => 5)
+
+    assert_equal test_array.avg(:number), 4.5
+  end
+  
+  def test_array_avg_should_not_break_with_nil_and_emtpy
+    assert_equal [3,nil].avg, 3
+    assert_equal [].avg, 0
+  end  
+  
+  
+  #== Tests for .array_to_hash
+  def test_array_should_make_to_hash
+    assert_equal [1,2].array_to_hash(""), {1 => "", 2 => ""}
+    assert_equal ["A","B"].array_to_hash(1), {"A" => 1, "B" => 1}
+    assert_equal ["A",nil].array_to_hash(1), {"A" => 1}
+  end  
+  
+  #== Tests for .to_structured_hash
+  def test_array_should_get_structured_with_symbol_and_nested_string
+    
+    # Create Test Datas
+    test_data_row = []
+    test_data_row << DummyClass.new(:sec_id => 1, :name => "bla-1")
+    test_data_row << DummyClass.new(:sec_id => 1, :name => "bla-2")
+    test_data_row << DummyClass.new(:sec_id => 1, :name => "bla-3")
+    
+    test_data_row << DummyClass.new(:sec_id => 2, :name => "blub-1")
+    test_data_row << DummyClass.new(:sec_id => 2, :name => "blub-2")
+    
+    test_data_hash_sym = test_data_row.to_structured_hash(:sec_id)
+    test_data_hash_str = test_data_row.to_structured_hash("return_self.sec_id")
+    
+    # Assertions
+    assert_equal test_data_hash_sym.keys.size, 2
+    assert_equal test_data_hash_sym[1].size, 3
+    assert_equal test_data_hash_sym[2].size, 2
+    
+    assert_equal test_data_hash_sym, test_data_hash_str
+  end
+  
+  #== Tests for .sum_with_attribute
+  def test_array_should_do_sum_with_attributes
+    
+    test_array = []
+    test_array << DummyClass.new(:number => 4)
+    test_array << DummyClass.new(:number => 5)
+      
+    # Using symbol  
+    assert_equal test_array.sum_with_attribute(:number), 9
+    
+    # Using nested string
+    assert_equal test_array.sum_with_attribute("return_self.number"), 9
+    
+    # Using symbol with options
+    assert_equal test_array.sum_with_attribute(:get_number, :double => true), 18
+    
+    # Using nested string with options
+    assert_equal test_array.sum_with_attribute("return_self.get_number", :double => true), 18
+  end
+  
+  #== Tests for .count_for
+  def test_array_should_count_for_items
+    a1 = [1,2,3]
+    
+    assert_equal a1.count_for(1), 1
+    
+    a2 = %w(a a b c)
+    assert_equal a2.count_for("a"), 2
+    
+    a3 = %w(a b c)
+    assert_equal a3.count_for("x"), 0
+    
+    a4 = [1,:a, nil]
+    assert_equal a4.count_for(nil), 1
+  end  
+  
+  #== Tests for .next
+  def test_get_next_array_item_without_cycle
+    a = [1,2,3]
+    assert_equal a.next(2), 3
+    assert_equal a.next(3), 3
+    assert_equal a.next(4), 4
+    
+    
+  end
+  
+  def test_get_next_array_item_with_cycle
+    a = [1,2,3]
+    assert_equal a.next(3, :cycle => true), 1
+    assert_equal a.next(1, :cycle => true), 2
+  end
+  
+  #== Tests for .isec
+  def test_array_must_isec_with_array
+    assert_raises ArgumentError do
+      [1,2,3].isec(3)
+    end  
+  end
+  
+  def test_array_isec
+    a1 = %w(a b c d)
+    a2 = %w(c d e f)
+    a3 = %w(a f x y)
+    a4 = %w(1 2 3 4)
+    
+    assert_equal a1.isec(a2), %w(c d)
+    assert_equal (a1+a2).isec(a3), %w(a f)
+    assert_equal a3.isec(a4), []
+  end
+  
+  #== Tests for .except
+  def test_array_except
+    a = [1,2,3, "a", "b"]
+    assert_equal a.except(1), [2,3, "a", "b"]
+    assert_equal a.except(1,2), [3, "a", "b"]
+    assert_equal a.except(1,"a"), [2,3, "b"]
+  end 
+  
+  #== Tests for .seperate
+  def test_array_seperation
+    {4 => (1..10).to_a, 25 => (1..100).to_a}.each do |n, array|
+      
+      sep_array = array.seperate(n)
+      
+      assert_equal sep_array.size, n
+      assert_equal sep_array.flatten, array
+    end  
+  end
+  
+  def test_array_should_seperate__arrays_correctly
+    # Fix for:
+    # [[1, "a"], [2, "b"], [3, "c"]].seperate(2).last
+    # => [[2, "b"], [[3, "c"]]] - Last Array is in an other array
+    
+    assert_equal [[1, "a"], [2, "b"], [3, "c"]].seperate(2).last.last, [3,"c"]
+    assert_equal [[1, "a"], [2, "b"], [3, "c"], [4, "d"]].seperate(2).last.last, [4,"d"]
+    
+  end  
+  
+  #== Tests for .stack
+  def test_array_stack
+    {4 => (1..10).to_a, 25 => (1..100).to_a}.each do |n, array|
+      
+      sep_array = array.stack(n)
+      
+      assert_equal sep_array.first.size, n
+      assert_equal sep_array.flatten, array
+    end  
+  end 
+  
+  #== Tests for .to_sql
+  def test_array_to_sql
+    # Empty array is NULL
+    assert_equal [].to_sql, "(NULL)"
+    
+    # Numbers should be unquoted
+    a = [1,2,4.5]
+    assert_no_match Regexp.new("'"), a.to_sql
+    assert_equal a.to_sql, "(1,2,4.5)"
+    
+    # All others should be quoted
+    a = ["a", :b]
+    assert_match Regexp.new("'"), a.to_sql
+    assert_equal a.to_sql, "('a','b')"
+  end     
+  
+  #== Test interpolation
+  def test_array_should_interpolate
+
+    # First should not fail
+    assert_equal [nil,1,2].interpolate(nil), [0,1,2]
+    # These fail:
+    # assert_equal [nil, nil,1,2].interpolate(nil), [-1, 0,1,2]
+    
+    
+    # Last should not fail
+    assert_equal [1,2,3], [1,2,nil].interpolate(nil).map {|x| x.to_i }
+    # These fail:
+    # assert_equal [1,2,3,4], [1,2,nil,nil].interpolate(nil).map {|x| x.to_i }
+    
+    # In The middle
+    assert_equal [1,2,3,4,5], [1,2,3,nil,5].interpolate(nil).map {|x| x.to_i }
+    assert_equal [1,2,3,4,5], [1,2,nil,nil,5].interpolate(nil).map {|x| x.to_i }
+    assert_equal [5,10,15,20,25], [5,nil,15,nil,25].interpolate(nil).map {|x| x.to_i }
+    assert_equal [5,10,15,20,25,30], [5,nil,15,nil,nil,30].interpolate(nil).map {|x| x.to_i }
+  end      
+  
+  
+  
+  
+end  

data/test/array_test.rb.orig

@@ -0,0 +1,221 @@
+require "test/unit"
+require "array"
+require "dummy_class"
+
+class ArrayTest < Test::Unit::TestCase
+  
+  #== Tests for .sum
+  def test_array_should_sum
+    assert_equal [1,2].sum, 3
+  end  
+  
+  #== Tests for .avg
+  def test_array_avg_with_numbers
+    test_array = [4,5]
+    
+    assert_equal test_array.avg, 4.5
+  end  
+  
+  def test_array_avg_with_attributes
+    test_array = []
+    test_array << DummyClass.new(:number => 4)
+    test_array << DummyClass.new(:number => 5)
+
+    assert_equal test_array.avg(:number), 4.5
+  end
+  
+  def test_array_avg_should_no_break_with_nil_and_emtpy
+    assert_equal [3,nil].avg, 3
+    assert_equal [].avg, 0
+  end  
+  
+  
+  #== Tests for .array_to_hash
+  def test_array_should_make_to_hash
+    assert_equal [1,2].array_to_hash(""), {1 => "", 2 => ""}
+    assert_equal ["A","B"].array_to_hash(1), {"A" => 1, "B" => 1}
+    assert_equal ["A",nil].array_to_hash(1), {"A" => 1}
+  end  
+  
+  #== Tests for .to_structured_hash
+  def test_array_should_get_structured_with_symbol_and_nested_string
+    
+    # Create Test Datas
+    test_data_row = []
+    test_data_row << DummyClass.new(:sec_id => 1, :name => "bla-1")
+    test_data_row << DummyClass.new(:sec_id => 1, :name => "bla-2")
+    test_data_row << DummyClass.new(:sec_id => 1, :name => "bla-3")
+    
+    test_data_row << DummyClass.new(:sec_id => 2, :name => "blub-1")
+    test_data_row << DummyClass.new(:sec_id => 2, :name => "blub-2")
+    
+    test_data_hash_sym = test_data_row.to_structured_hash(:sec_id)
+    test_data_hash_str = test_data_row.to_structured_hash("return_self.sec_id")
+    
+    # Assertions
+    assert_equal test_data_hash_sym.keys.size, 2
+    assert_equal test_data_hash_sym[1].size, 3
+    assert_equal test_data_hash_sym[2].size, 2
+    
+    assert_equal test_data_hash_sym, test_data_hash_str
+  end
+  
+  #== Tests for .sum_with_attribute
+  def test_array_should_do_sum_with_attributes
+    
+    test_array = []
+    test_array << DummyClass.new(:number => 4)
+    test_array << DummyClass.new(:number => 5)
+      
+    # Using symbol  
+    assert_equal test_array.sum_with_attribute(:number), 9
+    
+    # Using nested string
+    assert_equal test_array.sum_with_attribute("return_self.number"), 9
+    
+    # Using symbol with options
+    assert_equal test_array.sum_with_attribute(:get_number, :double => true), 18
+    
+    # Using nested string with options
+    assert_equal test_array.sum_with_attribute("return_self.get_number", :double => true), 18
+  end
+  
+  #== Tests for .count_for
+  def test_array_should_count_for_items
+    a1 = [1,2,3]
+    
+    assert_equal a1.count_for(1), 1
+    
+    a2 = %w(a a b c)
+    assert_equal a2.count_for("a"), 2
+    
+    a3 = %w(a b c)
+    assert_equal a3.count_for("x"), 0
+    
+    a4 = [1,:a, nil]
+    assert_equal a4.count_for(nil), 1
+  end  
+  
+  #== Tests for .next
+  def test_get_next_array_item_without_cycle
+    a = [1,2,3]
+    assert_equal a.next(2), 3
+    assert_equal a.next(3), 3
+    assert_equal a.next(4), 4
+    
+    
+  end
+  
+  def test_get_next_array_item_with_cycle
+    a = [1,2,3]
+    assert_equal a.next(3, :cycle => true), 1
+    assert_equal a.next(1, :cycle => true), 2
+  end
+  
+  #== Tests for .isec
+  def test_array_must_isec_with_array
+    assert_raises ArgumentError do
+      [1,2,3].isec(3)
+    end  
+  end
+  
+  def test_array_isec
+    a1 = %w(a b c d)
+    a2 = %w(c d e f)
+    a3 = %w(a f x y)
+    a4 = %w(1 2 3 4)
+    
+    assert_equal a1.isec(a2), %w(c d)
+    assert_equal (a1+a2).isec(a3), %w(a f)
+    assert_equal a3.isec(a4), []
+  end
+  
+  #== Tests for .except
+  def test_array_except
+    a = [1,2,3, "a", "b"]
+    assert_equal a.except(1), [2,3, "a", "b"]
+    assert_equal a.except(1,2), [3, "a", "b"]
+    assert_equal a.except(1,"a"), [2,3, "b"]
+  end 
+  
+  #== Tests for .seperate
+  def test_array_seperation
+    {4 => (1..10).to_a, 25 => (1..100).to_a}.each do |n, array|
+      
+      sep_array = array.seperate(n)
+      
+      assert_equal sep_array.size, n
+      assert_equal sep_array.flatten, array
+    end  
+  end
+  
+  def test_array_should_seperate__arrays_correctly
+    # Fix for:
+    # [[1, "a"], [2, "b"], [3, "c"]].seperate(2).last
+    # => [[2, "b"], [[3, "c"]]] - Last Array is in an other array
+    
+    assert_equal [[1, "a"], [2, "b"], [3, "c"]].seperate(2).last.last, [3,"c"]
+    assert_equal [[1, "a"], [2, "b"], [3, "c"], [4, "d"]].seperate(2).last.last, [4,"d"]
+    
+  end  
+  
+  #== Tests for .stack
+  def test_array_stack
+    {4 => (1..10).to_a, 25 => (1..100).to_a}.each do |n, array|
+      
+      sep_array = array.stack(n)
+      
+      assert_equal sep_array.first.size, n
+      assert_equal sep_array.flatten, array
+    end  
+  end 
+  
+  #== Tests for .to_sql
+  def test_array_to_sql
+    # Empty array is NULL
+    assert_equal [].to_sql, "(NULL)"
+    
+    # Numbers should be unquoted
+    a = [1,2,4.5]
+    assert_no_match Regexp.new("'"), a.to_sql
+    assert_equal a.to_sql, "(1,2,4.5)"
+    
+<<<<<<< HEAD
+    # All others should be quoted
+    a = ["a", :b]
+    assert_match Regexp.new("'"), a.to_sql
+    assert_equal a.to_sql, "('a','b')"
+  end     
+  
+  #== Test interpolation
+  def test_array_should_interpolate
+
+    # First should not fail
+    assert_equal [nil,1,2].interpolate(nil), [0,1,2]
+    # These fail:
+    # assert_equal [nil, nil,1,2].interpolate(nil), [-1, 0,1,2]
+    
+    
+    # Last should not fail
+    assert_equal [1,2,3], [1,2,nil].interpolate(nil).map {|x| x.to_i }
+    # These fail:
+    # assert_equal [1,2,3,4], [1,2,nil,nil].interpolate(nil).map {|x| x.to_i }
+    
+    # In The middle
+    assert_equal [1,2,3,4,5], [1,2,3,nil,5].interpolate(nil).map {|x| x.to_i }
+    assert_equal [1,2,3,4,5], [1,2,nil,nil,5].interpolate(nil).map {|x| x.to_i }
+    assert_equal [5,10,15,20,25], [5,nil,15,nil,25].interpolate(nil).map {|x| x.to_i }
+    assert_equal [5,10,15,20,25,30], [5,nil,15,nil,nil,30].interpolate(nil).map {|x| x.to_i }
+  end      
+  
+=======
+    # All others should be unquoted
+    a = ["a", :b]
+    assert_match Regexp.new("'"), a.to_sql
+    assert_equal a.to_sql, "('a','b')"
+  end         
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+  
+  
+  
+end  

data/test/dummy_class.rb

@@ -0,0 +1,36 @@
+class DummyClass
+  
+  # This is a dummy Class to store some Data in.
+  # IN real life, this would be ActiveRecord, but because of the are no database actions 
+  # required, we could just use this dummy
+  
+  # Store some possible data types in the class we can mess around with!
+  attr_accessor :id, :sec_id,  :name, :number, :date 
+  
+  def initialize(options = {})
+    
+    self.id     = options[:id]
+    self.sec_id = options[:sec_id]
+    
+    self.name   = options[:name]
+    self.number = options[:number] || 0
+    self.date   = options[:date]
+    
+  end  
+  
+  
+  # Just a dummy method
+  def return_self
+    self
+  end
+  
+  # Get number or number *2
+  def get_number(options = {})  
+    if options[:double] == true
+      self.number * 2
+    else
+      return self.number
+    end    
+  end  
+  
+end  

data/test/hash_test.rb

@@ -0,0 +1,46 @@
+require "test/unit"
+require "hash"
+
+class HashTest < Test::Unit::TestCase
+  
+  #== Test for .ordered
+  def test_hash_should_get_ordered
+    
+    test_hash = {
+      1 => "a", 2 => "b", 3 => "c"
+    }
+    
+    # Test options with sym or integer
+    assert_equal test_hash.ordered(:key), test_hash.ordered(0)
+    assert_equal test_hash.ordered(:value), test_hash.ordered(1)
+    assert_equal test_hash.ordered(0), test_hash.ordered(1)
+    
+    test_hash = {
+      1 => "z", 2 => "y", 3 => "x"
+    }
+    
+    assert_equal test_hash.ordered(:key).map {|r| r[0]}, [1,2,3]
+    assert_equal test_hash.ordered(:value).map {|r| r[0]}, [3,2,1]
+    
+  end  
+  
+  #== Test for .extract_data
+  def test_hash_should_extract_data
+    
+    # It should work with symbol and string as keys:
+    test_hash = {
+      "field_1" => 1, "field_2" => 0, :field_3 => 1
+    }
+    
+    # default trigger is "1", so nothing should happen now
+    assert_equal test_hash.extract_data, [] 
+    
+    # Using trigger = 1 should work
+    assert_equal test_hash.extract_data(nil, 1), ["field_1", "field_3"] 
+    
+    # Now using slice and trigger
+    assert_equal test_hash.extract_data("field_", 1), ["1", "3"] 
+      
+  end  
+  
+end  

data/test/numeric_test.rb

@@ -0,0 +1,94 @@
+require "test/unit"
+require "numbers"
+
+
+class NumericTest < Test::Unit::TestCase
+
+  
+  def test_number_to_euro
+    #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
+    
+    [2, 3.3].each do |f|
+      [40,250].each do |n|
+        i = 500
+        r_inf = r_def = i
+      
+        n.times do |i|
+          r_inf = r_inf*(1+f/100.0) 
+          r_def = r_def*(1-f/100.0) 
+        end  
+      
+        assert_equal i.infla(n,f).round(5), r_inf.round(5)
+        assert_equal i.defla(n,f).round(5), r_def.round(5)
+      end  
+    end  
+    
+  end  
+  
+  def test_number_should_get_closest
+    # Test for wrong limit mode:
+    assert_raise ArgumentError do 
+      1.get_closest([3,4], :zonk)
+    end
+    
+    # Check to find closest
+    assert_equal 2.get_closest([0,3,4], :ceil),       3  
+    assert_equal 2.get_closest([0,3,4], :floor),      3  
+    assert_equal -2.88.get_closest([0,3,4], :floor),  0  
+    
+    # Check to find closest with :floor
+    assert_equal 1.get_closest([0,2], :floor), 0  
+    assert_equal 5.5.get_closest([4.5,6.5], :floor), 4.5  
+    
+    # Check to find closest with :ceil
+    assert_equal 1.get_closest([0,2], :ceil), 2
+    assert_equal 5.5.get_closest([4.5,6.5], :ceil), 6.5    
+    
+  end  
+  
+  
+  def test_numbers_min_and_max
+    assert_equal 1, 1.min(3)
+    assert_equal 3, 1.max(3)
+    assert_equal 2, 2.min_max(1,3)
+    assert_equal 1, -1.min_max(1,3)
+    assert_equal 3, 4.min_max(1,3)
+  end 
+  
+  def test_float_dividor
+    assert !1.fdiv(1).is_a?(Integer)
+  end
+  
+  def test_to_q_faktor
+    assert_equal 2.to_q, 1.02
+  end 
+  
+  def test_time_should_be_calc_correct
+    assert_equal 23.to_time,    "00:00:23"
+    assert_equal 64.to_time,    "00:01:04"
+    
+    assert_equal 17.to_time(:discard_hour => true),    "00:17"
+    assert_equal 73.to_time(:discard_hour => true),    "01:13"
+    
+    assert_equal 3672.to_time,  "01:01:12"
+  end
+  
+  def test_prime_factors
+    
+    [16,234,4568,34950,183649].each do |nr|
+      primes = nr.prime_factors
+      puts "#{nr} => #{primes.inspect}"
+      assert_equal nr, eval(primes.join("*"))
+    end  
+    
+  end        
+
+end  

data/test/numeric_test.rb.orig

@@ -0,0 +1,94 @@
+require "test/unit"
+require "numbers"
+
+
+class NumericTest < Test::Unit::TestCase
+
+  
+  def test_number_to_euro
+    #assert_equal 0.29.to_euro, "0,29"
+  end
+  
+  # Test Math Functions  
+  def test_math_infla_defla
+    
+    [2, 3.3].each do |f|
+      [40,250].each do |n|
+        i = 500
+        r_inf = r_def = i
+      
+        n.times do |i|
+          r_inf = r_inf*(1+f/100.0) 
+          r_def = r_def*(1-f/100.0) 
+        end  
+      
+        assert_equal i.infla(n,f).round(5), r_inf.round(5)
+        assert_equal i.defla(n,f).round(5), r_def.round(5)
+      end  
+    end  
+    
+  end  
+  
+  def test_number_should_get_closest
+    # Test for wrong limit mode:
+    assert_raise ArgumentError do 
+      1.get_closest([3,4], :zonk)
+    end
+    
+    # Check to find closest
+    assert_equal 2.get_closest([0,3,4], :ceil),       3  
+    assert_equal 2.get_closest([0,3,4], :floor),      3  
+    assert_equal -2.88.get_closest([0,3,4], :floor),  0  
+    
+    # Check to find closest with :floor
+    assert_equal 1.get_closest([0,2], :floor), 0  
+    assert_equal 5.5.get_closest([4.5,6.5], :floor), 4.5  
+    
+    # Check to find closest with :ceil
+    assert_equal 1.get_closest([0,2], :ceil), 2
+    assert_equal 5.5.get_closest([4.5,6.5], :ceil), 6.5    
+    
+  end  
+  
+  
+  def test_numbers_min_and_max
+    assert_equal 1, 1.min(3)
+    assert_equal 3, 1.max(3)
+    assert_equal 2, 2.min_max(1,3)
+    assert_equal 1, -1.min_max(1,3)
+    assert_equal 3, 4.min_max(1,3)
+  end 
+  
+  def test_float_dividor
+    assert !1.fdiv(1).is_a?(Integer)
+  end
+  
+  def test_to_q_faktor
+    assert_equal 2.to_q, 1.02
+  end 
+  
+  def test_time_should_be_calc_correct
+    assert_equal 23.to_time,    "00:00:23"
+    assert_equal 64.to_time,    "00:01:04"
+    
+    assert_equal 17.to_time(:discard_hour => true),    "00:17"
+    assert_equal 73.to_time(:discard_hour => true),    "01:13"
+    
+    assert_equal 3672.to_time,  "01:01:12"
+<<<<<<< HEAD
+  end
+  
+  def test_prime_factors
+    
+    [16,234,4568,34950,183649].each do |nr|
+      primes = nr.prime_factors
+      puts "#{nr} => #{primes.inspect}"
+      assert_equal nr, eval(primes.join("*"))
+    end  
+    
+  end        
+=======
+  end      
+>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
+
+end