friendly_extensions 0.0.61 → 0.0.62

data/test/array_test.rb

@@ -180,11 +180,33 @@ class ArrayTest < Test::Unit::TestCase
     assert_no_match Regexp.new("'"), a.to_sql
     assert_equal a.to_sql, "(1,2,4.5)"
     
-    # All others should be unquoted
+    # All others should be quoted
     a = ["a", :b]
     assert_match Regexp.new("'"), a.to_sql
     assert_equal a.to_sql, "('a','b')"
-  end         
+  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      
+  
   
   
   

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/numeric_test.rb

@@ -75,6 +75,16 @@ class NumericTest < Test::Unit::TestCase
     assert_equal 73.to_time(:discard_hour => true),    "01:13"
     
     assert_equal 3672.to_time,  "01:01:12"
-  end      
+  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  

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: friendly_extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.61
+  version: 0.0.62
 platform: ruby
 authors:
 - Florian Eck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-14 00:00:00.000000000 Z
+date: 2014-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: '0'
 description: Adds serveral cool features to your Ruby classes. Includes new features
   for Array, String, Hash, Numeric, Date/Datetime and some more.
 email: it-support@friends-systems.de
@@ -32,7 +32,9 @@ 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
@@ -40,12 +42,17 @@ files:
 - 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
 - test/hash_test.rb
 - test/numeric_test.rb
+- test/numeric_test.rb.orig
 - test/string_test.rb
 homepage: https://github.com/florianeck/rails_friendly_extensions
 licenses: []
@@ -72,7 +79,9 @@ specification_version: 4
 summary: Collection of useful features for Ruby/Rails Classes
 test_files:
 - test/array_test.rb
+- test/array_test.rb.orig
 - test/dummy_class.rb
 - test/hash_test.rb
 - test/numeric_test.rb
+- test/numeric_test.rb.orig
 - test/string_test.rb