functional-ruby 0.7.7 → 1.0.0

data/spec/functional/search_spec.rb

@@ -1,187 +0,0 @@
-require 'spec_helper'
-
-module Functional
-
-  describe Search do
-
-    context '#linear_search' do
-
-      let(:sample) do
-        [3, 5, 6, 7, 8, 11, 15, 21, 22, 28, 30, 32, 33, 34, 40].freeze
-      end
-
-      it 'returns nil for a nil sample' do
-        Search.linear_search(nil, 1).should be_nil
-      end
-
-      it 'returns nil for an empty sample' do
-        Search.linear_search([].freeze, 1).should be_nil
-      end
-
-      it 'returns the index of the item when found' do
-        index = Search.linear_search(sample, 11)
-        index.should eq 5
-      end
-
-      it 'returns the index of the item when using a block' do
-        sample = [
-          {:count => 11}, 
-          {:count => 12},
-          {:count => 13},
-          {:count => 14},
-          {:count => 16},
-          {:count => 17},
-          {:count => 18},
-          {:count => 19},
-          {:count => 20},
-          {:count => 21}
-        ].freeze
-
-        index = Search.linear_search(sample, 14){|item| item[:count]}
-        index.should eq 3
-      end
-
-      it 'returns nil when not found' do
-        index = Search.linear_search(sample, 13)
-        index.should be_nil
-      end
-
-      it 'supports an :imin option for an alternate low index' do
-        index = Search.linear_search(sample, 11, :imin => 3)
-        index.should eq 5
-
-        index = Search.linear_search(sample, 11, :imin => 10)
-        index.should be_nil
-      end
-
-      it 'supports an :imax option for an alternate high index' do
-        index = Search.linear_search(sample, 11, :imax => 10)
-        index.should eq 5
-
-        index = Search.linear_search(sample, 11, :imax => 4)
-        index.should be_nil
-      end
-
-      it 'behaves consistently when :imin equals :imax' do
-        index = Search.linear_search(sample, 3, :imin => 5, :imax => 5)
-        index.should be_nil
-
-        index = Search.linear_search(sample, 11, :imin => 5, :imax => 5)
-        index.should eq 5
-
-        index = Search.linear_search(sample, 30, :imin => 5, :imax => 5)
-        index.should be_nil
-      end
-
-      it 'sets :imin to zero (0) when given a negative number' do
-        index = Search.linear_search(sample, 11, :imin => -1)
-        index.should eq 5
-      end
-
-      it 'sets :imax to the uppermost index when :imax is out of range' do
-        index = Search.linear_search(sample, 11, :imax => 100)
-        index.should eq 5
-      end
-
-      it 'returns nil when :imin is greater than :imax' do
-        index = Search.linear_search(sample, 1, :imin => 10, :imax => 5)
-        index.should be_nil
-      end
-    end
-
-    context '#binary_search' do
-
-      let(:sample) do
-        [3, 5, 6, 7, 8, 11, 15, 21, 22, 28, 30, 32, 33, 34, 40].freeze
-      end
-
-      it 'returns nil for a nil sample' do
-        Search.binary_search(nil, 1).should be_nil
-      end
-
-      it 'returns nil for an empty sample' do
-        Search.binary_search([].freeze, 1).should be_nil
-      end
-
-      it 'returns the index of the item when found as [index, index]' do
-        index = Search.binary_search(sample, 11)
-        index.should eq [5, 5]
-      end
-
-      it 'returns the index of the item when using a block' do
-        sample = [
-          {:count => 11}, 
-          {:count => 12},
-          {:count => 13},
-          {:count => 14},
-          {:count => 16},
-          {:count => 17},
-          {:count => 18},
-          {:count => 19},
-          {:count => 20},
-          {:count => 21}
-        ].freeze
-
-        index = Search.binary_search(sample, 14){|item| item[:count]}
-        index.should eq [3, 3]
-      end
-
-      it 'returns the indexes above and below when not found - below, above' do
-        index = Search.binary_search(sample, 13)
-        index.should eq [5, 6]
-      end
-
-      it 'returns nil and the low index when the item is out of range on the low end - [nil, low]' do
-        index = Search.binary_search(sample, 1)
-        index.should eq [nil, 0]
-      end
-
-      it 'returns the high index and nil when the item is out of range on the high end - [high, nil]' do
-        index = Search.binary_search(sample, 41)
-        index.should eq [14, nil]
-      end
-
-      it 'supports an :imin option for an alternate low index' do
-        index = Search.binary_search(sample, 11, :imin => 3)
-        index.should eq [5, 5]
-
-        index = Search.binary_search(sample, 11, :imin => 10)
-        index.should eq [nil, 10]
-      end
-
-      it 'supports an :imax option for an alternate high index' do
-        index = Search.binary_search(sample, 11, :imax => 10)
-        index.should eq [5, 5]
-
-        index = Search.binary_search(sample, 11, :imax => 4)
-        index.should eq [4, nil]
-      end
-
-      it 'behaves consistently when :imin equals :imax' do
-        index = Search.binary_search(sample, 3, :imin => 5, :imax => 5)
-        index.should eq [nil, 5]
-
-        index = Search.binary_search(sample, 11, :imin => 5, :imax => 5)
-        index.should eq [5, 5]
-
-        index = Search.binary_search(sample, 30, :imin => 5, :imax => 5)
-        index.should eq [5, nil]
-      end
-
-      it 'sets :imin to zero (0) when given a negative number' do
-        index = Search.binary_search(sample, 1, :imin => -1)
-        index.should eq [nil, 0]
-      end
-
-      it 'sets :imax to the uppermost index when :imax is out of range' do
-        index = Search.binary_search(sample, 41, :imax => 100)
-        index.should eq [14, nil]
-      end
-
-      it 'returns nil when :imin is greater than :imax' do
-        index = Search.binary_search(sample, 1, :imin => 10, :imax => 5)
-        index.should be_nil
-      end
-    end
-  end
-end

data/spec/functional/sort_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-module Functional
-
-  describe Sort do
-
-    context '#insertion_sort!' do
-
-      it 'returns nil for a nil sample' do
-        Sort.insertion_sort!(nil).should be_nil
-      end
-
-      it 'returns the sample when the sample is empty' do
-        Sort.insertion_sort!([]).should be_empty
-      end
-
-      it 'returns the sample when the sample has one element' do
-        Sort.insertion_sort!([100]).should eq [100]
-      end
-
-      it 'sorts an unsorted collection' do
-        sample = [31, 37, 26, 30, 2, 30, 1, 33, 5, 14, 11, 13, 17, 35, 4]
-        count = sample.count
-        sorted = Sort.insertion_sort!(sample)
-        Functional.ascending?(sorted).should be_true
-        sorted.count.should eq count
-      end
-
-      it 'does not modify an unsorted collection' do
-        sample = [1, 2, 4, 5, 11, 13, 14, 17, 26, 30, 30, 31, 33, 35, 37]
-        control = sample.dup
-        sorted = Sort.insertion_sort!(sample)
-        sorted.should eq control
-      end
-
-      it 'it sorts a collection with a block' do
-        sample = [
-          {:count => 31},
-          {:count => 37},
-          {:count => 26},
-          {:count => 30},
-          {:count => 2},
-          {:count => 30},
-          {:count => 1}
-        ]
-
-        count = sample.count
-        sorted = Sort.insertion_sort!(sample){|item| item[:count]}
-        Functional.ascending?(sorted){|item| item[:count]}.should be_true
-        sorted.count.should eq count
-      end
-
-      it 'performs the sort in place' do
-        lambda {
-          sample = [31, 37, 26, 30, 2, 30, 1, 33, 5, 14, 11, 13, 17, 35, 4].freeze
-          Sort.insertion_sort!(sample)
-        }.should raise_error
-      end
-    end
-  end
-end

data/spec/functional/utilities_spec.rb

@@ -1,277 +0,0 @@
-require 'spec_helper'
-require 'fakefs/safe'
-require 'rbconfig'
-
-describe 'utilities' do
-
-  context '#delta' do
-
-    it 'computes the delta of two positive values' do
-      delta(10.5, 5.0).should be_within(0.01).of(5.5)
-    end
-
-    it 'computes the delta of two negative values' do
-      delta(-10.5, -5.0).should be_within(0.01).of(5.5)
-    end
-
-    it 'computes the delta of a positive and negative value' do
-      delta(10.5, -5.0).should be_within(0.01).of(15.5)
-    end
-
-    it 'computes the delta of two positive values with a block' do
-      v1 = {:count => 10.5}
-      v2 = {:count => 5.0}
-      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(5.5)
-    end
-
-    it 'computes the delta of two negative values with a block' do
-      v1 = {:count => -10.5}
-      v2 = {:count => -5.0}
-      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(5.5)
-    end
-
-    it 'computes the delta of a positive and negative value with a block' do
-      v1 = {:count => 10.5}
-      v2 = {:count => -5.0}
-      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(15.5)
-    end
-  end
-
-  context '#repeatedly' do
-
-    it 'returns an empty array when requested times is zero' do
-      expected = repeatedly(0){ 1 }
-      expected.should be_empty
-    end
-
-    it 'returns an array with all nil values when no block is given' do
-      expected = repeatedly(10)
-      expected.length.should eq 10
-      expected.each do |elem|
-        elem.should be_nil
-      end
-    end
-
-    it 'iterates the requested number of times and puts the results into an array' do
-      expected = repeatedly(10){ 5 }
-      expected.length.should eq 10
-      expected.each do |elem|
-        elem.should eq 5
-      end
-    end
-
-    it 'passes the initial value to the first iteration' do
-      @expected = nil
-      repeatedly(1,100){|previous| @expected = previous }
-      @expected.should eq 100
-    end
-
-    it 'passes the result of each iteration to the next iteration' do
-      expected = repeatedly(10, 1){|previous| previous * 2 }
-      expected.should eq [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
-    end
-  end
-
-  context '#retro' do
-
-    it 'does not run the block if requested times is zero' do
-      @expected = true
-      retro(0){ @expected = false }
-      @expected.should be_true
-    end
-
-    it 'passes all arguments to the block' do
-      @expected = nil
-      retro(1, ?a, ?b, ?c){|*args| @expected = args }
-      @expected.should eq [?a, ?b, ?c]
-    end
-
-    it 'calls the block once if the first pass is successful' do
-      @expected = 0
-      retro(5){ @expected += 1 }
-      @expected.should eq 1
-    end
-
-    it 'calls the block more than once if the first pass fails' do
-      @expected = 0
-      retro(5) do
-        @expected += 1
-        raise StandardError if @expected < 3
-      end
-      @expected.should eq 3
-    end
-
-    it 'calls the block no more than the requested number of times' do
-      @expected = 0
-      retro(5) do
-        @expected += 1
-        raise StandardError
-      end
-      @expected.should eq 5
-    end
-
-    it 'returns true if any attempt succeeds' do
-      expected = retro(1){ nil }
-      expected.should be_true
-    end
-
-    it 'returns false if all attempts fail' do
-      expected = retro(1){ raise StandardError }
-      expected.should be_false
-    end
-
-    it 'returns false if no block is given' do
-      expected = retro(10)
-      expected.should eq false
-    end
-  end
-
-  if RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
-    context '#safe' do
-
-      it 'allows safe operations' do
-        lambda {
-          safe{ 1 + 1 }
-        }.should_not raise_error
-      end
-
-      it 'returns the value of the block when safe' do
-        safe{ 1 + 1 }.should eq 2
-      end
-
-      it 'passes all arguments to the block' do
-        safe(1, 2, 3){|x, y, z| x + y + z }.should eq 6
-      end
-
-      it 'rejects unsafe operations on tainted objects' do
-        lambda {
-          safe{ Signal.trap('INT'.taint) }
-        }.should raise_error(SecurityError)
-      end
-
-      it 'rejects the use of #eval' do
-        lambda {
-          safe{ eval 'puts 1' }
-        }.should raise_error(SecurityError)
-      end
-    end
-  end
-
-  context '#slurp' do
-
-    unless Functional::PLATFORM.rbx?
-
-      before(:all) { FakeFS.activate! }
-      after(:all) { FakeFS.deactivate! }
-
-      let!(:path){ 'slurp.txt' }
-      let!(:text){ 'Hello, world!' }
-
-      it 'returns the contents of the file' do
-        File.open(path, 'w+') {|f| f.write(text) }
-        slurp(path).should eq text
-      end
-
-      it 'raises an exception when the file does not exist' do
-        lambda {
-          slurp('path/does/not/exist')
-        }.should raise_error(Errno::ENOENT)
-      end
-    end
-  end
-
-  context '#slurpee' do
-
-    unless Functional::PLATFORM.rbx?
-
-      before(:all) { FakeFS.activate! }
-      after(:all) { FakeFS.deactivate! }
-
-      let!(:path){ 'slurp.txt' }
-      let!(:text){ 'You are number 6.' }
-      let!(:erb) { 'You are number <%= 2 * 3 %>.' }
-
-      it 'returns the processed contents of the file' do
-        File.open(path, 'w+') {|f| f.write(erb) }
-        slurpee(path).should eq text
-      end
-
-      it 'raises an exception when the file does not exist' do
-        lambda {
-          slurpee('path/does/not/exist')
-        }.should raise_error(Errno::ENOENT)
-      end
-    end
-  end
-
-  context '#repl?' do
-
-    before(:each) do
-      @dollar_zero = $0
-    end
-
-    after(:each) do
-      $0 = @dollar_zero
-    end
-
-    def set_dollar_zero(val)
-      $0 = val
-    end
-
-    it 'recognizes IRB' do
-      set_dollar_zero('irb')
-      repl?.should be_true
-    end
-
-    it 'recognizes Pry' do
-      set_dollar_zero('pry')
-      repl?.should be_true
-    end
-
-    it 'recognizes Rails Console' do
-      set_dollar_zero('script/rails')
-      repl?.should be_true
-    end
-
-    it 'recognizes Bundle Console' do
-      set_dollar_zero('bin/bundle')
-      repl?.should be_true
-    end
-
-    it 'returns false when not in a REPL' do
-      set_dollar_zero(__FILE__)
-      repl?.should be_false
-    end
-  end
-
-  context '#timer' do
-
-    it 'returns [0, nil] if no block is given' do
-      duration, result = timer()
-      duration.should eq 0
-      result.should be_nil
-    end
-
-    it 'yields to the block' do
-      @expected = false
-      duration, result = timer{ @expected = true }
-      @expected.should be_true
-    end
-
-    it 'passes all arguments to the block' do
-      @expected = nil
-      duration, result = timer(1,2,3){|a,b,c| @expected = [a,b,c]}
-      @expected.should eq [1,2,3]
-    end
-
-    it 'returns the duration as the first return value' do
-      duration, result = timer{ sleep(0.1) }
-      duration.should > 0
-    end
-
-    it 'returns the block result as the second return value' do
-      duration, result = timer{ 42 }
-      result.should eq 42
-    end
-  end
-end