sugar_refinery 1.0.0

data/spec/array_op_spec.rb

@@ -0,0 +1,17 @@
+require 'sugar_refinery/array_op'
+using SugarRefinery::ArrayOp
+
+
+describe 'Array#^' do
+  it 'does an exclusive or' do
+    a = [1,2,3,4]
+    b = [3,4,5,6]
+    (a^b).should == [1,2,5,6]
+  end
+end
+
+describe 'Array#**' do
+  it 'returns the array product' do
+    ([1,2] ** %w[a b]).should == [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+  end
+end

data/spec/array_stats_spec.rb

@@ -0,0 +1,82 @@
+require "sugar_refinery/array_stats"
+using SugarRefinery::ArrayStats
+
+describe "doing statistics on arrays" do
+  let(:list) { (2..5).to_a }
+
+  describe "Array#mean" do
+    it "should return the average" do
+      list.mean.should == 3.5
+    end
+  end
+
+  describe "Array#stdev_sample" do
+    it "should return the standard deviation of the sample" do
+      list.stdev_sample.should be_close(1.2909944487358056, 1e-8)
+    end
+  end
+
+  describe "Array#stdev_population" do
+    it "should return the standard deviation of the population" do
+      list.stdev_population.should be_close(1.118033988749895, 1e-8)
+    end
+  end
+
+  describe "Array#stdev" do
+    it "should default to population" do
+      list.stdev.should be_close(list.stdev_population, 1e-8)
+    end
+
+    it "should delegate sample correctly" do
+      list.stdev(:sample).should be_close(list.stdev_sample, 1e-8)
+    end
+
+    it "should delegate population correctly" do
+      list.stdev(:population).should be_close(list.stdev_population, 1e-8)
+    end
+
+    it "should raise an error with any other key" do
+      expect { list.stdev(:pony) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "Array#z_score" do
+    it "should default to population" do
+      list.z_score.zip(list.z_score(:population)).each do |value, actual|
+        value.should be_close(actual, 1e-8)
+      end
+    end
+
+    it "should delegate sample correctly" do
+      sample_z_score = [
+        -1.161895003862225,
+        -0.3872983346207417,
+        0.3872983346207417,
+        1.161895003862225
+      ]
+
+      p list
+
+      list.z_score(:sample).zip(sample_z_score).each do |value, actual|
+        value.should be_close(actual, 1e-8)
+      end
+    end
+
+    it "should delegate population correctly" do
+      population_z_score = [
+        -1.3416407864998738,
+        -0.4472135954999579,
+        0.4472135954999579,
+        1.3416407864998738
+      ]
+
+      list.z_score(:population).zip(population_z_score).each do |value, actual|
+        value.should be_close(actual, 1e-8)
+      end
+    end
+
+    it "should raise an error with any other key" do
+      expect { list.z_score(:pony) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/blank_spec.rb

@@ -0,0 +1,22 @@
+require 'sugar_refinery/blank'
+using SugarRefinery::Blank
+
+
+describe 'Object#blank?' do
+  it 'should be blank for blank values' do
+    blank_values   = [ nil, false, '', '   ', "  \n\t  \r ", [], {}, // ]
+
+    blank_values.each{ |blank|
+      blank.blank?.should == true
+    }
+  end
+
+  it 'should not be blank for non blank values' do
+    present_values = [ Object.new, true, 0, 1, 'a', [nil], { nil => nil } ]
+
+    present_values.each{ |present|
+      present.blank?.should == false
+    }
+  end
+end
+

data/spec/camel_snake_spec.rb

@@ -0,0 +1,15 @@
+require 'sugar_refinery/camel_snake'
+using SugarRefinery::CamelSnake
+
+
+describe 'String#to_camel' do
+  it 'should turn a snake_cased string to CamelCase' do
+    'was_snake_case'.to_camel.should == 'WasSnakeCase'
+  end
+end
+
+describe 'String#to_snake' do
+  it 'should turn a CamelCased string to snake_case' do
+    'WasCamelCase'.to_snake.should == 'was_camel_case'
+  end
+end

data/spec/chain_map_spec.rb

@@ -0,0 +1,16 @@
+require "sugar_refinery/chain_map"
+using SugarRefinery::ChainMap
+
+describe "Array#chain_map" do
+  it "should repeatedly chain symbols as map calls" do
+    list = [-3, -2, -1]
+
+    list.chain_map(:abs, :to_s) == %w{3 2 1}
+  end
+
+  it "should repeatedly chain blocks as map calls" do
+    list = [-3, -2, -1]
+
+    list.chain_map(->(e) { e ** 2 }, ->(e) { e * -1 }) == [-9, -4, -1]
+  end
+end

data/spec/constantize_spec.rb

@@ -0,0 +1,33 @@
+require 'sugar_refinery/constantize'
+using SugarRefinery::Constantize
+
+
+describe 'String#constantize' do
+  it 'should return the constant with that name' do
+    'Object'.constantize.should == Object
+  end
+
+  it 'should also work for nested constants' do
+    'SugarRefinery::VERSION'.constantize.should == SugarRefinery::VERSION
+  end
+
+  it 'should throw name error if constant does not exist (and no parameter is given)' do
+    proc do
+      'ObfsefsefsefafesafaefRubySugarRefineryafdfselijfesject'.constantize
+    end.should raise_exception NameError
+  end
+
+  it 'should call the block (and not raise an error) if constant does not exist and block given' do
+    proc do
+      'ObfsefsefsefafesafaefRubySugarRefineryafdfselijfesject'.constantize do |string|
+         Default = [1,2,3]
+      end.should == [1,2,3]
+    end.should_not raise_exception
+  end
+
+  it 'should return the second parameter (and not raise an error) if constant does not exist and parameter given' do
+    proc do
+      'ObfsefsefsefafesafaefRubySugarRefineryafdfselijfesject'.constantize(Array).should == Array
+    end.should_not raise_exception
+  end
+end

data/spec/dir_utils_spec.rb

@@ -0,0 +1,32 @@
+require 'sugar_refinery/dir_utils'
+require 'securerandom'
+using SugarRefinery::DirUtils
+
+
+describe Dir do
+  describe '.join' do
+    it 'delegates to File.join' do
+      a = %w[some file path]
+      expect( Dir.join(a) ).to be == File.join(a)
+    end
+  end
+
+  describe '.split' do
+    it 'delegates to File.split' do
+      a = 'some/file/path'
+      expect( Dir.split(a) ).to be == File.split(a)
+    end
+  end
+
+  describe '.rm' do
+    it 'removes directories with content' do
+      path = "tmp_#{SecureRandom.uuid}"
+      FileUtils.mkdir path
+      FileUtils.touch "#{path}/123"
+      expect{
+        Dir.rm path
+      }.not_to raise_error
+      expect( Dir['*'] ).to_not include(path)
+    end
+  end
+end

data/spec/file_force_delete_spec.rb

@@ -0,0 +1,30 @@
+require 'sugar_refinery/file_force_delete'
+require 'fileutils'
+using SugarRefinery::FileForceDelete
+
+
+describe File do
+  describe '.delete!' do
+    after{ File.delete! 'random_filename' }
+    let :random_filename do
+      'test_' + (0..20).map{|e| [*'a'..'z'].sample }*''
+    end
+
+    it 'should delete the filename given as argument if it exists + return non-nil' do
+      FileUtils.touch random_filename
+      res = false
+      proc do
+        res = File.delete! random_filename
+      end.should_not raise_exception
+      res.should be_truthy
+    end
+
+    it 'should do nothing if the filename given as argument does not exist + return nil' do
+      res = false
+      proc do
+        res = File.delete! random_filename
+      end.should_not raise_exception
+      res.should be_falsey
+    end
+  end
+end

data/spec/file_gsub_spec.rb

@@ -0,0 +1,26 @@
+require 'sugar_refinery/file_gsub'
+require 'fileutils'
+using SugarRefinery::FileGsub
+
+
+describe File do
+  describe '.gsub' do
+    let :random_filename do
+      'test_' + (0..20).map{|e| [*'a'..'z'].sample }*''
+    end
+
+    it 'should read filename in arg1, substitute every key in the arg2 with its value and save the file' do
+      File.open(random_filename,'w'){ |file|
+        file.print 'should read filename in arg1, substitute every key in the arg2 with its value and save the file'
+      }
+      File.gsub random_filename,
+        /read/ => 'write',
+        /\d+/  => proc{|m| (m.to_i+1).to_s }
+
+      File.read(random_filename).should ==
+        'should write filename in arg2, substitute every key in the arg3 with its value and save the file'
+
+      FileUtils.rm random_filename
+    end
+  end
+end

data/spec/hash_op_spec.rb

@@ -0,0 +1,28 @@
+require 'sugar_refinery/hash_op'
+using SugarRefinery::HashOp
+
+
+describe 'Hash#<<' do
+  it 'appends new elements to the hash' do
+    a =  { 1=>4, 2=>5, 3=>6 }
+    a << { 4=>7 }
+    a << [5, 8]
+    a.should == { 1=>4, 2=>5, 3=>6, 4=>7, 5=>8 }
+  end
+end
+
+describe 'Hash#&' do
+  it 'selects a sub hash containt only equal key-value pairs' do
+    a = { 1=>4, 2=>5, 3=>6 }
+    b = { 1=>4, 2=>7 }
+    (a & b).should == { 1=>4 }
+  end
+end
+
+describe 'Hash#+' do
+  it 'merges two hashes' do
+    a = { 1=>4, 2=>5, 3=>6 }
+    b = { 1=>4, 2=>7, 4=>0 }
+    (a + b).should == { 1=>4, 2=>7, 3=>6, 4=>0 }
+  end
+end

data/spec/hash_zip_spec.rb

@@ -0,0 +1,11 @@
+require 'sugar_refinery/hash_zip'
+using SugarRefinery::HashZip
+
+
+describe Hash do
+  describe '.zip' do
+    it 'should zip together both given enumerables and take them as key=>values for a new hash' do
+      Hash.zip( [1,2,3], [4,5,6] ).should == { 1=>4, 2=>5, 3=>6 }
+    end
+  end
+end

data/spec/inner_map_spec.rb

@@ -0,0 +1,24 @@
+require "sugar_refinery/inner_map"
+using SugarRefinery::InnerMap
+
+describe "Array#inner_map" do
+  it "should delegate map to inner lists" do
+    list = [[1, 2], [3, 4]]
+
+    list.inner_map { |i| i + 1 }.should == [[2, 3], [4, 5]]
+  end
+end
+
+describe "Array#inner_inject" do
+  it "should delegate inject to inner lists" do
+    list = [%w{a b c}, %w{d e f}]
+
+    list.inner_inject(&:+).should == list.map(&:join)
+  end
+
+  it "should take default values" do
+    list = [[3, 2, 1], [-4]]
+
+    list.inner_inject(4, &:+).should == [10, 0]
+  end
+end

data/spec/lchomp_spec.rb

@@ -0,0 +1,20 @@
+require 'sugar_refinery/lchomp'
+using SugarRefinery::Lchomp
+
+describe String do
+  describe '#lchomp' do
+    it 'should chomp on the left side' do
+      string = 'ameise'
+      expect( string.lchomp('a') ).to eq 'meise'
+      expect( string ).to eq 'ameise'
+    end
+  end
+
+  describe '#lchomp!' do
+    it 'should chomp on the left side (mutating)' do
+      string = 'ameise'
+      expect( string.lchomp!('a') ).to eq 'meise'
+      expect( string ).to eq 'meise'
+    end
+  end
+end

data/spec/marshal_copy_spec.rb

@@ -0,0 +1,15 @@
+require 'sugar_refinery/marshal_copy'
+using SugarRefinery::MarshalCopy
+
+
+describe 'Object#marshal_copy' do
+  it 'create a (deep) copy via marshalling' do
+    a = %w[hello world]
+    b = a.marshal_copy
+    b.should == a
+
+    b[0][1,1] = ''
+    b.should_not == a
+  end
+end
+

data/spec/mash_spec.rb

@@ -0,0 +1,17 @@
+require 'sugar_refinery/mash'
+using SugarRefinery::Mash
+
+
+describe 'Array#mash' do
+  it 'should "map" a hash' do
+    [1,2,3].mash{|e| [e, e.to_s] }.should == {1=>'1',2=>'2',3=>'3',}
+  end
+end
+
+
+describe 'Enumerator#mash' do
+  it 'should "map" a hash' do
+    [1,2,3].each.mash{|e| [e, e.to_s] }.should == {1=>'1',2=>'2',3=>'3',}
+  end
+end
+

data/spec/ords_spec.rb

@@ -0,0 +1,15 @@
+require 'sugar_refinery/ords'
+using SugarRefinery::Ords
+
+
+describe 'Array#chrs' do
+  it 'converts the array to a string, using each element as ord value for the char' do
+    [72, 97, 108, 108, 111].chrs.should == 'Hallo'
+  end
+end
+
+describe 'String#ords' do
+  it 'unpacks characters' do
+    'Hallo'.ords.should == [72, 97, 108, 108, 111]
+  end
+end

data/spec/regexp_union_spec.rb

@@ -0,0 +1,19 @@
+require 'sugar_refinery/regexp_union'
+using SugarRefinery::RegexpUnion
+
+
+shared_examples_for "Regexp.union operator" do
+  it "creates a Regexp.union of both operands" do
+    (/Ruby\d/ | /test/i | "cheat").should ==
+      Regexp.union( Regexp.union( /Ruby\d/, /test/i ), "cheat" )
+  end
+end
+
+describe 'Regexp#|' do
+  it_should_behave_like 'Regexp.union operator'
+end
+
+describe 'String#|' do
+  it_should_behave_like 'Regexp.union operator'
+end
+