algorithms 0.5.0 → 1.1.0

data/spec/rb_tree_map_spec.rb

@@ -4,30 +4,30 @@ require 'algorithms'
 shared_examples "empty rbtree" do
   it "should let you push stuff in" do
     100.times { |x| @tree[x] = x }
-    @tree.size.should eql(100)
+    expect(@tree.size).to eql(100)
   end
 
   it "should be empty?" do
-    @tree.empty?.should be_true
+    expect(@tree.empty?).to be true
   end
 
   it "should return 0 for height" do
-    @tree.height.should eql(0)
+    expect(@tree.height).to eql(0)
   end
 
   it "should return 0 for size" do
-    @tree.size.should eql(0)
+    expect(@tree.size).to eql(0)
   end
 
   it "should return nil for max and min" do
-    @tree.min.should be_nil
-    @tree.max.should be_nil
-    @tree.min_key.should be_nil
-    @tree.max_key.should be_nil
+    expect(@tree.min).to be_nil
+    expect(@tree.max).to be_nil
+    expect(@tree.min_key).to be_nil
+    expect(@tree.max_key).to be_nil
   end
 
   it "should not delete" do
-    @tree.delete(:non_existing).should be_nil
+    expect(@tree.delete(:non_existing)).to be_nil
   end
 end
 
@@ -39,52 +39,52 @@ shared_examples "non-empty rbtree" do
   end
 
   it "should return correct size (uniqify items first)" do
-    @tree.should_not be_empty
-    @tree.size.should eql(@random_array.uniq.size)
+    expect(@tree).not_to be_empty
+    expect(@tree.size).to eql(@random_array.uniq.size)
   end
 
   it "should return correct max and min" do
-    @tree.min_key.should eql(@random_array.min)
-    @tree.max_key.should eql(@random_array.max)
-    @tree.min[0].should eql(@random_array.min)
-    @tree.max[0].should eql(@random_array.max)
+    expect(@tree.min_key).to eql(@random_array.min)
+    expect(@tree.max_key).to eql(@random_array.max)
+    expect(@tree.min[0]).to eql(@random_array.min)
+    expect(@tree.max[0]).to eql(@random_array.max)
   end
 
   it "should not #has_key? keys it doesn't have" do
-    @tree.has_key?(100000).should be_false
+    expect(@tree.has_key?(100000)).to be false
   end
 
   it "should #has_key? keys it does have" do
-    @tree.has_key?(@random_array[0]).should be_true
+    expect(@tree.has_key?(@random_array[0])).to be true
   end
 
   it "should remove all keys" do
     ordered = []
     @random_array.uniq.each do |key|
-      @tree.has_key?(key).should eql(true)
+      expect(@tree.has_key?(key)).to eql(true)
       ordered << @tree.delete(key)
-      @tree.has_key?(key).should eql(false)
+      expect(@tree.has_key?(key)).to eql(false)
     end
-    ordered.should eql(@random_array.uniq)
+    expect(ordered).to eql(@random_array.uniq)
   end
 
   it "should delete_min keys correctly" do
     ascending = []
     ascending << @tree.delete_min until @tree.empty?
-    ascending.should eql(@random_array.uniq.sort)
+    expect(ascending).to eql(@random_array.uniq.sort)
   end
 
   it "should delete_max keys correctly" do
     descending = []
     descending << @tree.delete_max until @tree.empty?
-    descending.should eql(@random_array.uniq.sort.reverse)
+    expect(descending).to eql(@random_array.uniq.sort.reverse)
   end
 
   it "should let you iterate with #each" do
     counter = 0
     sorted_array = @random_array.uniq.sort
     @tree.each do |key, val|
-      key.should eql(sorted_array[counter])
+      expect(key).to eql(sorted_array[counter])
       counter += 1
     end
   end

data/spec/search_spec.rb

@@ -8,21 +8,21 @@ describe "search algorithms" do
     n = 1000
     @rand_array = Array.new(n) { rand(n) }.sort
     
-    Algorithms::Search.binary_search(@rand_array, @rand_array.first).should eql(@rand_array.first)
-    Algorithms::Search.binary_search(@rand_array, 999999).should be_nil
-    Algorithms::Search.binary_search(@rand_array, nil).should be_nil
+    expect(Algorithms::Search.binary_search(@rand_array, @rand_array.first)).to eql(@rand_array.first)
+    expect(Algorithms::Search.binary_search(@rand_array, 999999)).to be_nil
+    expect(Algorithms::Search.binary_search(@rand_array, nil)).to be_nil
   end
   
   it "should use kmp_search to find substrings it has" do
     string = "ABC ABCDAB ABCDABCDABDE"
-    Algorithms::Search.kmp_search(string, "ABCDABD").should eql(15)
-    Algorithms::Search.kmp_search(string, "ABCDEF").should be_nil
-    Algorithms::Search.kmp_search(string, nil).should be_nil
-    Algorithms::Search.kmp_search(string, "").should be_nil
-    Algorithms::Search.kmp_search(nil, "ABCD").should be_nil
+    expect(Algorithms::Search.kmp_search(string, "ABCDABD")).to eql(15)
+    expect(Algorithms::Search.kmp_search(string, "ABCDEF")).to be_nil
+    expect(Algorithms::Search.kmp_search(string, nil)).to be_nil
+    expect(Algorithms::Search.kmp_search(string, "")).to be_nil
+    expect(Algorithms::Search.kmp_search(nil, "ABCD")).to be_nil
   end
   
   it "should let you include Search in String to enable instance methods" do
-    "ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD").should eql(15)
+    expect("ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD")).to eql(15)
   end
 end

data/spec/sort_spec.rb

@@ -4,17 +4,18 @@ include Algorithms
 
 describe "sort algorithms" do
   before(:each) do
-    @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort shell_sort quicksort mergesort)
+    @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort 
+      shell_sort quicksort mergesort dualpivotquicksort)
   end
 
   it "should work for empty containers" do
     empty_array = []
-    @sorts.each { |sort| Sort.send(sort, empty_array).should eql([]) }
+    @sorts.each { |sort| expect(Sort.send(sort, empty_array)).to eql([]) }
   end
 
   it "should work for a container of size 1" do
     one_array = [1]
-    @sorts.each { |sort| Sort.send(sort, one_array).should eql(one_array) }
+    @sorts.each { |sort| expect(Sort.send(sort, one_array)).to eql([1]) }
   end
 
   it "should work for random arrays of numbers" do
@@ -22,7 +23,7 @@ describe "sort algorithms" do
     rand_array = Array.new(n) { rand(n) }
     sorted_array = rand_array.sort
 
-    @sorts.each { |sort| Sort.send(sort, rand_array.dup).should eql(sorted_array) }
+    @sorts.each { |sort| expect(Sort.send(sort, rand_array.dup)).to eql(sorted_array) }
   end    
 
-end
+end

data/spec/splay_tree_map_spec.rb

@@ -4,24 +4,24 @@ require 'algorithms'
 shared_examples "empty splaytree" do
   it "should let you push stuff in" do
     100.times { |x| @tree[x] = x }
-    @tree.size.should eql(100)
+    expect(@tree.size).to eql(100)
   end
   
   it "should return 0 for size" do
-    @tree.size.should eql(0)
+    expect(@tree.size).to eql(0)
   end
   
   it "should return nil for #min and #max" do
-    @tree.min.should be_nil
-    @tree.max.should be_nil
+    expect(@tree.min).to be_nil
+    expect(@tree.max).to be_nil
   end
   
   it "should return nil for #delete" do
-    @tree.delete(:non_existing).should be_nil
+    expect(@tree.delete(:non_existing)).to be_nil
   end
   
   it "should return nil for #get" do
-    @tree[4235].should be_nil
+    expect(@tree[4235]).to be_nil
   end
 end
 
@@ -34,40 +34,40 @@ shared_examples "non-empty splaytree" do
   end
   
   it "should return correct size (uniqify items first)" do
-    @tree.size.should eql(@random_array.uniq.size)
+    expect(@tree.size).to eql(@random_array.uniq.size)
   end
   
   it "should have correct height (worst case is when items are inserted in order, and height = num items inserted)" do
     @tree.clear
     10.times { |x| @tree[x] = x }
-    @tree.height.should eql(10)
+    expect(@tree.height).to eql(10)
   end
   
   it "should return correct max and min keys" do
-    @tree.min[0].should eql(@random_array.min)
-    @tree.max[0].should eql(@random_array.max)
+    expect(@tree.min[0]).to eql(@random_array.min)
+    expect(@tree.max[0]).to eql(@random_array.max)
   end
   
   it "should not #has_key? keys it doesn't have" do
-    @tree.has_key?(10000).should be_false
+    expect(@tree.has_key?(10000)).to be false
   end
   
   it "should #has_key? keys it does have" do
-    @tree.has_key?(@random_array[0]).should be_true
+    expect(@tree.has_key?(@random_array[0])).to be true
   end
   
   it "should remove any key" do
     random_key = @random_array[rand(@num_items)]
-    @tree.has_key?(random_key).should be_true
-    @tree.delete(random_key).should eql(random_key)
-    @tree.has_key?(random_key).should be_false
+    expect(@tree.has_key?(random_key)).to be true
+    expect(@tree.delete(random_key)).to eql(random_key)
+    expect(@tree.has_key?(random_key)).to be false
   end
   
   it "should let you iterate with #each" do
     counter = 0
     sorted_array = @random_array.uniq.sort
     @tree.each do |key, val|
-      key.should eql(sorted_array[counter])
+      expect(key).to eql(sorted_array[counter])
       counter += 1
     end
   end

data/spec/stack_spec.rb

@@ -7,20 +7,20 @@ describe "empty stack" do
   end
 
   it "should return nil when sent #pop" do
-    @stack.pop.should be_nil
+    expect(@stack.pop).to be_nil
   end
 
   it "should return a size of 1 when sent #push" do
     @stack.push(1)
-    @stack.size.should eql(1)
+    expect(@stack.size).to eql(1)
   end
 
   it "should return nil when sent #next" do
-    @stack.next.should be_nil
+    expect(@stack.next).to be_nil
   end
 
   it "should return empty?" do
-    @stack.empty?.should be_true
+    expect(@stack.empty?).to be true
   end
 end
 
@@ -32,29 +32,29 @@ describe "non-empty stack" do
   end
 
   it "should return last pushed object" do
-    @stack.pop.should eql("10")
+    expect(@stack.pop).to eql("10")
   end
 
   it "should return the size" do
-    @stack.size.should eql(2)
+    expect(@stack.size).to eql(2)
   end
 
   it "should not return empty?" do
-    @stack.empty?.should be_false
+    expect(@stack.empty?).to be false
   end
 
 
   it "should iterate in LIFO order" do
     arr = []
     @stack.each { |obj| arr << obj }
-    arr.should eql(["10", 10])
+    expect(arr).to eql(["10", 10])
   end
 
   it "should return nil after all pops" do
     @stack.pop
     @stack.pop
-    @stack.pop.should be_nil
-    @stack.next.should be_nil
+    expect(@stack.pop).to be_nil
+    expect(@stack.next).to be_nil
   end
 
 end

data/spec/string_spec.rb

@@ -1,13 +1,15 @@
 $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
 require 'algorithms'
 
-describe "string algorithms" do
-  it "should do levenshtein distance" do    
-    Algorithms::String.levenshtein_dist("Hello", "Hel").should eql(2)
-    Algorithms::String.levenshtein_dist("Hello", "").should eql(5)
-    Algorithms::String.levenshtein_dist("", "Hello").should eql(5)
-    Algorithms::String.levenshtein_dist("Hello", "Hello").should eql(0)
-    Algorithms::String.levenshtein_dist("Hello", "ello").should eql(1)
-    Algorithms::String.levenshtein_dist("Hello", "Mello").should eql(1)
+if defined? Algorithms::String
+  describe "string algorithms" do
+    it "should do levenshtein distance" do    
+      expect(Algorithms::String.levenshtein_dist("Hello", "Hel")).to eql(2)
+      expect(Algorithms::String.levenshtein_dist("Hello", "")).to eql(5)
+      expect(Algorithms::String.levenshtein_dist("", "Hello")).to eql(5)
+      expect(Algorithms::String.levenshtein_dist("Hello", "Hello")).to eql(0)
+      expect(Algorithms::String.levenshtein_dist("Hello", "ello")).to eql(1)
+      expect(Algorithms::String.levenshtein_dist("Hello", "Mello")).to eql(1)
+    end
   end
 end

data/spec/suffix_array_spec.rb

@@ -3,7 +3,7 @@ require 'algorithms'
 
 describe "empty suffix array" do
   it "should not initialize with empty string" do
-    lambda { Containers::SuffixArray.new("") }.should raise_error
+    expect { Containers::SuffixArray.new("") }.to raise_error(ArgumentError)
   end
 end
 
@@ -13,28 +13,28 @@ describe "non-empty suffix array" do
   end
 
   it "should has_substring? each possible substring" do
-    @s_array.has_substring?("a").should be_true
-    @s_array.has_substring?("abra").should be_true
-    @s_array.has_substring?("abracadabra").should be_true
-    @s_array.has_substring?("acadabra").should be_true
-    @s_array.has_substring?("adabra").should be_true
-    @s_array.has_substring?("bra").should be_true
-    @s_array.has_substring?("bracadabra").should be_true
-    @s_array.has_substring?("cadabra").should be_true
-    @s_array.has_substring?("dabra").should be_true
-    @s_array.has_substring?("ra").should be_true
-    @s_array.has_substring?("racadabra").should be_true
+    expect(@s_array.has_substring?("a")).to be true
+    expect(@s_array.has_substring?("abra")).to be true
+    expect(@s_array.has_substring?("abracadabra")).to be true
+    expect(@s_array.has_substring?("acadabra")).to be true
+    expect(@s_array.has_substring?("adabra")).to be true
+    expect(@s_array.has_substring?("bra")).to be true
+    expect(@s_array.has_substring?("bracadabra")).to be true
+    expect(@s_array.has_substring?("cadabra")).to be true
+    expect(@s_array.has_substring?("dabra")).to be true
+    expect(@s_array.has_substring?("ra")).to be true
+    expect(@s_array.has_substring?("racadabra")).to be true
   end
 
   it "should not has_substring? substrings it does not have" do
-    @s_array.has_substring?("nope").should be_false
-    @s_array.has_substring?(nil).should be_false
+    expect(@s_array.has_substring?("nope")).to be false
+    expect(@s_array.has_substring?(nil)).to be false
   end
 
   it "should work with numbers (calls to_s)" do
     number = Containers::SuffixArray.new(123456789)
-    number[1].should be_true
-    number.has_substring?(12).should be_true
-    number.has_substring?(13).should be_false
+    expect(number[1]).to be true
+    expect(number.has_substring?(12)).to be true
+    expect(number.has_substring?(13)).to be false
   end
 end

data/spec/trie_spec.rb

@@ -7,13 +7,13 @@ describe "empty trie" do
   end
 
   it "should not get or has_key?" do
-    @trie.get("anything").should be_nil
-    @trie.has_key?("anything").should be_false
+    expect(@trie.get("anything")).to be_nil
+    expect(@trie.has_key?("anything")).to be false
   end
 
   it "should not have longest_prefix or match wildcards" do
-    @trie.wildcard("an*thing").should eql([])
-    @trie.longest_prefix("an*thing").should eql("")
+    expect(@trie.wildcard("an*thing")).to eql([])
+    expect(@trie.longest_prefix("an*thing")).to eql("")
   end
 end
 
@@ -27,33 +27,33 @@ describe "non-empty trie" do
   end
 
   it "should has_key? keys it has" do
-    @trie.has_key?("Hello").should be_true
-    @trie.has_key?("Hello, brother").should be_true
-    @trie.has_key?("Hello, bob").should be_true
+    expect(@trie.has_key?("Hello")).to be true
+    expect(@trie.has_key?("Hello, brother")).to be true
+    expect(@trie.has_key?("Hello, bob")).to be true
   end
 
   it "should not has_key? keys it doesn't have" do
-    @trie.has_key?("Nope").should be_false
+    expect(@trie.has_key?("Nope")).to be false
   end
 
   it "should get values" do
-    @trie.get("Hello").should eql("World")
+    expect(@trie.get("Hello")).to eql("World")
   end
 
   it "should overwrite values" do
     @trie.push("Hello", "John")
-    @trie.get("Hello").should eql("John")
+    expect(@trie.get("Hello")).to eql("John")
   end
 
   it "should return longest prefix" do
-    @trie.longest_prefix("Hello, brandon").should eql("Hello")
-    @trie.longest_prefix("Hel").should eql("")
-    @trie.longest_prefix("Hello").should eql("Hello")
-    @trie.longest_prefix("Hello, bob").should eql("Hello, bob")
+    expect(@trie.longest_prefix("Hello, brandon")).to eql("Hello")
+    expect(@trie.longest_prefix("Hel")).to eql("")
+    expect(@trie.longest_prefix("Hello")).to eql("Hello")
+    expect(@trie.longest_prefix("Hello, bob")).to eql("Hello, bob")
   end
 
   it "should match wildcards" do
-    @trie.wildcard("H*ll.").should eql(["Hello", "Hilly"])
-    @trie.wildcard("Hel").should eql([])
+    expect(@trie.wildcard("H*ll.")).to eql(["Hello", "Hilly"])
+    expect(@trie.wildcard("Hel")).to eql([])
   end
 end

metadata

@@ -1,39 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: algorithms
 version: !ruby/object:Gem::Version
-  version: 0.5.0
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Kanwei Li
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-25 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &70163289605640 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *70163289605640
-- !ruby/object:Gem::Dependency
-  name: echoe
-  requirement: &70163289605060 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *70163289605060
-description: A library of algorithms and data structures (containers).
+date: 2023-11-11 00:00:00.000000000 Z
+dependencies: []
+description: Heap, Priority Queue, Deque, Stack, Queue, Red-Black Trees, Splay Trees,
+  sorting algorithms, and more
 email: kanwei@gmail.com
 executables: []
 extensions:
@@ -42,35 +19,10 @@ extensions:
 - ext/containers/deque/extconf.rb
 - ext/containers/rbtree_map/extconf.rb
 - ext/containers/splaytree_map/extconf.rb
-extra_rdoc_files:
-- CHANGELOG.markdown
-- README.markdown
-- ext/algorithms/string/extconf.rb
-- ext/algorithms/string/string.c
-- ext/containers/bst/bst.c
-- ext/containers/bst/extconf.rb
-- ext/containers/deque/deque.c
-- ext/containers/deque/extconf.rb
-- ext/containers/rbtree_map/extconf.rb
-- ext/containers/rbtree_map/rbtree.c
-- ext/containers/splaytree_map/extconf.rb
-- ext/containers/splaytree_map/splaytree.c
-- lib/algorithms.rb
-- lib/algorithms/search.rb
-- lib/algorithms/sort.rb
-- lib/algorithms/string.rb
-- lib/containers/deque.rb
-- lib/containers/heap.rb
-- lib/containers/kd_tree.rb
-- lib/containers/priority_queue.rb
-- lib/containers/queue.rb
-- lib/containers/rb_tree_map.rb
-- lib/containers/splay_tree_map.rb
-- lib/containers/stack.rb
-- lib/containers/suffix_array.rb
-- lib/containers/trie.rb
+extra_rdoc_files: []
 files:
 - CHANGELOG.markdown
+- Gemfile
 - Manifest
 - README.markdown
 - Rakefile
@@ -121,35 +73,32 @@ files:
 - spec/string_spec.rb
 - spec/suffix_array_spec.rb
 - spec/trie_spec.rb
-homepage: https://rubygems.org/gems/algorithms
-licenses: []
-post_install_message: 
+homepage: https://github.com/kanwei/algorithms
+licenses:
+- MIT
+metadata: {}
 rdoc_options:
-- --line-numbers
-- --inline-source
-- --title
+- "--line-numbers"
+- "--inline-source"
+- "--title"
 - Algorithms
-- --main
+- "--main"
 - README.markdown
 require_paths:
 - lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '1.2'
+      version: '0'
 requirements: []
-rubyforge_project: algorithms
-rubygems_version: 1.8.15
-signing_key: 
-specification_version: 3
-summary: A library of algorithms and data structures (containers).
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Useful algorithms and data structures for Ruby. Optional C extensions.
 test_files: []