combinatorics 0.4.3 → 0.5.0

data/spec/extensions/math_spec.rb

@@ -12,89 +12,89 @@ describe Math do
 
   describe "sigma" do
     it "should return 6 for sigma(1..3)" do
-      subject.sigma(1..3).should == 6
+      expect(subject.sigma(1..3)).to eq(6)
     end
 
     it "should return 60 for sigma(3..5)" do
-      subject.sigma(3..5).should == 12
+      expect(subject.sigma(3..5)).to eq(12)
     end
 
     it "should take an optional block argument" do
       result = subject.sigma(1..5) { |i| i * 2 }
 
-      result.should == (1 * 2) + (2 * 2) + (3 * 2) + (4 * 2) + (5 * 2)
+      expect(result).to eq((1 * 2) + (2 * 2) + (3 * 2) + (4 * 2) + (5 * 2))
     end
   end
 
   describe "pi" do
     it "should return 24 for pi(1..4)" do
-      subject.pi(1..4).should == 24
+      expect(subject.pi(1..4)).to eq(24)
     end
 
     it "should return 30 for pi(5..6)" do
-      subject.pi(5..6).should == 30
+      expect(subject.pi(5..6)).to eq(30)
     end
 
     it "should take an optional block argument" do
       result = subject.pi(1..3) { |i| i * 2 }
 
-      result.should == (1 * 2) * (2 * 2) * (3 * 2)
+      expect(result).to eq((1 * 2) * (2 * 2) * (3 * 2))
     end
   end
 
   describe "factorial" do
     it "should return 1 for factorial(0)" do
-      subject.factorial(0).should == 1
+      expect(subject.factorial(0)).to eq(1)
     end
 
     it "should return 1 for factorial(1)" do
-      subject.factorial(1).should == 1
+      expect(subject.factorial(1)).to eq(1)
     end
 
     it "should return 2 for factorial(2)" do
-      subject.factorial(2).should == 2
+      expect(subject.factorial(2)).to eq(2)
     end
 
     it "should return 6 for factorial(3)" do
-      subject.factorial(3).should == 6
+      expect(subject.factorial(3)).to eq(6)
     end
     
     it "should return 3628800 for factorial(10)" do
-      subject.factorial(10).should == 3628800
+      expect(subject.factorial(10)).to eq(3628800)
     end
 
     it "should raise RangeError for factorial(-1)" do
-      lambda { subject.factorial(-1) }.should raise_error(RangeError)
+      expect { subject.factorial(-1) }.to raise_error(RangeError)
     end
   end
 
   describe "subfactorial" do
     it "should return 1 for subfactorial(0)" do
-      subject.subfactorial(0).should == 1
+      expect(subject.subfactorial(0)).to eq(1)
     end
 
     it "should return 0 for subfactorial(1)" do
-      subject.subfactorial(1).should == 0
+      expect(subject.subfactorial(1)).to eq(0)
     end
 
     it "should return 1 for subfactorial(2)" do
-      subject.subfactorial(2).should == 1
+      expect(subject.subfactorial(2)).to eq(1)
     end
 
     it "should return 2 for subfactorial(3)" do
-      subject.subfactorial(3).should == 2
+      expect(subject.subfactorial(3)).to eq(2)
     end
 
     it "should return 9 for subfactorial(4)" do
-      subject.subfactorial(4).should == 9
+      expect(subject.subfactorial(4)).to eq(9)
     end
 
     it "should return 44 for subfactorial(5)" do
-      subject.subfactorial(5).should == 44
+      expect(subject.subfactorial(5)).to eq(44)
     end
 
     it "should raise RangeError for subfactorial(-1)" do
-      lambda { subject.subfactorial(-1) }.should raise_error(RangeError)
+      expect { subject.subfactorial(-1) }.to raise_error(RangeError)
     end
   end
 end

data/spec/extensions/range_spec.rb

@@ -4,11 +4,11 @@ require 'combinatorics/extensions/range'
 describe Range do
   describe "&" do
     it "should pick the maximum beginning value" do
-      ((100..200) & (150..200)).first.should == 150
+      expect(((100..200) & (150..200)).first).to eq(150)
     end
 
     it "should pick the minimum ending value" do
-      ((100..150) & (100..200)).last.should == 150
+      expect(((100..150) & (100..200)).last).to eq(150)
     end
   end
 
@@ -16,28 +16,28 @@ describe Range do
     subject { 1..10 }
 
     it "should iterate over every beginning value" do
-      subject.upto(5..10).to_a.should == [
+      expect(subject.upto(5..10).to_a).to eq([
         (1..10),
         (2..10),
         (3..10),
         (4..10),
         (5..10)
-      ]
+      ])
     end
 
     it "should iterate over every ending value" do
-      subject.upto(1..15).to_a.should == [
+      expect(subject.upto(1..15).to_a).to eq([
         (1..10),
         (1..11),
         (1..12),
         (1..13),
         (1..14),
         (1..15)
-      ]
+      ])
     end
 
     it "should not iterate up to lower bounding ranges" do
-      subject.upto(0..5).to_a.should be_empty
+      expect(subject.upto(0..5).to_a).to be_empty
     end
   end
 
@@ -45,28 +45,28 @@ describe Range do
     subject { 5..15 }
 
     it "should iterate over every beginning value" do
-      subject.downto(1..15).to_a.should == [
+      expect(subject.downto(1..15).to_a).to eq([
         (5..15),
         (4..15),
         (3..15),
         (2..15),
         (1..15)
-      ]
+      ])
     end
 
     it "should iterate over every ending value" do
-      subject.downto(5..10).to_a.should == [
+      expect(subject.downto(5..10).to_a).to eq([
         (5..15),
         (5..14),
         (5..13),
         (5..12),
         (5..11),
         (5..10)
-      ]
+      ])
     end
 
     it "should not iterate down to upward bounding ranges" do
-      subject.downto(10..20).to_a.should be_empty
+      expect(subject.downto(10..20).to_a).to be_empty
     end
   end
 end

data/spec/generator_spec.rb

@@ -3,6 +3,6 @@ require 'combinatorics/generator'
 
 describe Combinatorics::Generator do
   it "should auto-detect the Generator class" do
-    Combinatorics::Generator.should_not be_nil
+    expect(Combinatorics::Generator).not_to be_nil
   end
 end

data/spec/list_comprehension_spec.rb

@@ -6,46 +6,46 @@ describe "Array#comprehension" do
   it "should return an Enumerator object if no block is given" do
     a = [1..5]
 
-    a.comprehension.should_not be_kind_of(Array)
+    expect(a.comprehension).not_to be_kind_of(Array)
   end
 
   it "should yield iterations to the given block" do
     range = (1..5)
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[4],[5]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[4],[5]])
   end
 
   it "should do nothing an Array of all non-enumerable objects" do
     a = [1,2,3]
 
-    a.comprehension.to_a.should == [a]
+    expect(a.comprehension.to_a).to eq([a])
   end
 
   it "should pass through an empty Array" do
     a = []
 
-    a.comprehension.to_a.should == [a]
+    expect(a.comprehension.to_a).to eq([a])
   end
 
   it "should iterate over the values within an enumerable value" do
     range = (1..5)
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[4],[5]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[4],[5]])
   end
 
   it "should iterate over repeating values" do
     range = [1,2,3,1,2,4]
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[1],[2],[4]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[1],[2],[4]])
   end
 
   it "should iterate over values from a generator" do
     a = [Combinatorics::Generator.new { |g| 5.times { |i| g.yield i } }]
 
-    a.comprehension.to_a.should == [[0],[1],[2],[3],[4]]
+    expect(a.comprehension.to_a).to eq([[0],[1],[2],[3],[4]])
   end
 
   it "should iterate over values from a non-repeating generator" do
@@ -58,16 +58,16 @@ describe "Array#comprehension" do
       }
     ]
 
-    a.comprehension.to_a.should == [
+    expect(a.comprehension.to_a).to eq([
       [1,0],[1,1],[1,2],[1,3],[1,4],
       [2,0],[2,2],[2,4],[2,6],[2,8]
-    ]
+    ])
   end
 
   it "should ignore non-enumerable values" do
     range = (1..5)
     a = [1,range]
 
-    a.comprehension.to_a.should == [[1,1],[1,2],[1,3],[1,4],[1,5]]
+    expect(a.comprehension.to_a).to eq([[1,1],[1,2],[1,3],[1,4],[1,5]])
   end
 end

data/spec/permute/cardinality_spec.rb

@@ -1,122 +1,120 @@
 require 'spec_helper'
 require 'combinatorics/permute'
 
-describe Permute do
-  subject { Permute }
-
+describe Combinatorics::Permute do
   describe "cardinality" do
     it "should raise RangeError if n is negative without passing r" do
-      lambda { subject.cardinality(-1) }.should raise_error(RangeError)
+      expect { subject.cardinality(-1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if n is negative when r is provided" do
-      lambda { subject.cardinality(-1, 1) }.should raise_error(RangeError)
+      expect { subject.cardinality(-1, 1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if r is negative" do
-      lambda { subject.cardinality(1, -1) }.should raise_error(RangeError)
+      expect { subject.cardinality(1, -1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if r is greater than n" do
-      lambda { subject.cardinality(2, 3) }.should raise_error(RangeError)
+      expect { subject.cardinality(2, 3) }.to raise_error(RangeError)
     end
 
     it "should return 1 for subject.cardinality(0)" do
-      subject.cardinality(0).should == 1
+      expect(subject.cardinality(0)).to eq(1)
     end
 
     it "should return 1 for subject.cardinality(1)" do
-      subject.cardinality(1).should == 1
+      expect(subject.cardinality(1)).to eq(1)
     end
 
     it "should return 2 for subject.cardinality(2)" do
-      subject.cardinality(2).should == 2
+      expect(subject.cardinality(2)).to eq(2)
     end
 
     it "should return 6 for subject.cardinality(3)" do
-      subject.cardinality(3).should == 6
+      expect(subject.cardinality(3)).to eq(6)
     end
 
     it "should return 24 for subject.cardinality(4)" do
-      subject.cardinality(4).should == 24
+      expect(subject.cardinality(4)).to eq(24)
     end
 
     it "should return 0 for subject.cardinality(1, 0)" do
-      subject.cardinality(1, 0).should == 0
+      expect(subject.cardinality(1, 0)).to eq(0)
     end
 
     it "should return 1 for subject.cardinality(1, 1)" do
-      subject.cardinality(1, 1).should == 1
+      expect(subject.cardinality(1, 1)).to eq(1)
     end
 
     it "should return 2 for subject.cardinality(2, 1)" do
-      subject.cardinality(2, 1).should == 2
+      expect(subject.cardinality(2, 1)).to eq(2)
     end
 
     it "should return 1 for subject.cardinality(2, 2)" do
-      subject.cardinality(2, 2).should == 2
+      expect(subject.cardinality(2, 2)).to eq(2)
     end
 
     it "should return 3 for subject.cardinality(3, 1)" do
-      subject.cardinality(3, 1).should == 3
+      expect(subject.cardinality(3, 1)).to eq(3)
     end
 
     it "should return 3 for subject.cardinality(3, 2)" do
-      subject.cardinality(3, 2).should == 6
+      expect(subject.cardinality(3, 2)).to eq(6)
     end
 
     it "should return 1 for subject.cardinality(3, 3)" do
-      subject.cardinality(3, 3).should == 6
+      expect(subject.cardinality(3, 3)).to eq(6)
     end
 
     it "should return 4 for subject.cardinality(4, 1)" do
-      subject.cardinality(4, 1).should == 4
+      expect(subject.cardinality(4, 1)).to eq(4)
     end
 
     it "should return 12 for subject.cardinality(4, 2)" do
-      subject.cardinality(4, 2).should == 12
+      expect(subject.cardinality(4, 2)).to eq(12)
     end
 
     it "should return 24 for subject.cardinality(4, 3)" do
-      subject.cardinality(4, 3).should == 24
+      expect(subject.cardinality(4, 3)).to eq(24)
     end
 
     it "should return 1 for subject.cardinality(4, 4)" do
-      subject.cardinality(4, 4).should == 24
+      expect(subject.cardinality(4, 4)).to eq(24)
     end
 
     it "should return 360 for subject.cardinality(6, 4)" do
-      subject.cardinality(6, 4).should == 360
+      expect(subject.cardinality(6, 4)).to eq(360)
     end
 
     it "should return 3628800 for subject.cardinality(10)" do
-      subject.cardinality(10).should == 3628800
+      expect(subject.cardinality(10)).to eq(3628800)
     end
   end
 
   describe "cardinality_all" do
     it "should return [] for cardinality_all(0)" do
-      subject.cardinality_all(0).should be_empty
+      expect(subject.cardinality_all(0)).to be_empty
     end
 
     it "should return [1] for cardinality_all(1)" do
-      subject.cardinality_all(1).should == [1]
+      expect(subject.cardinality_all(1)).to eq([1])
     end
 
     it "should return [2, 1] for cardinality_all(2)" do
-      subject.cardinality_all(2).should == [2, 2]
+      expect(subject.cardinality_all(2)).to eq([2, 2])
     end
 
     it "should return [3, 6, 1] for cardinality_all(3)" do
-      subject.cardinality_all(3).should == [3, 6, 6]
+      expect(subject.cardinality_all(3)).to eq([3, 6, 6])
     end
 
     it "should return [4, 12, 24, 1] for cardinality_all(4)" do
-      subject.cardinality_all(4).should == [4, 12, 24, 24]
+      expect(subject.cardinality_all(4)).to eq([4, 12, 24, 24])
     end
 
     it "should raise RangeError for cardinality_all(-1)" do
-      lambda { subject.cardinality_all(-1) }.should raise_error(RangeError)
+      expect { subject.cardinality_all(-1) }.to raise_error(RangeError)
     end
 
     it "should wrap cardinality with Permute.N" do

data/spec/permute/mixin_examples.rb

@@ -8,35 +8,35 @@ shared_examples_for "Permute::Mixin" do
       set     = subject[]
       results = set.permute(0).to_a
       
-      results.should == [[]]
+      expect(results).to eq([[]])
     end
 
     it "should return [[]] for [1].permute(0).to_a" do
       set     = subject[1]
       results = set.permute(0).to_a
       
-      results.should == [[]]
+      expect(results).to eq([[]])
     end
 
     it "should return [[1]] for [1].permute(1).to_a" do
       set     = subject[1]
       results = set.permute(1).to_a
       
-      results.should == [[1]]
+      expect(results).to eq([[1]])
     end
 
     it "should return [[1], [2]] for [1, 2].permute(1).to_a" do
       set     = subject[1, 2]
       results = set.permute(1).to_a
       
-      results.should =~ [[1], [2]]
+      expect(results).to match_array([[1], [2]])
     end
 
     it "should return [[1, 2]] for [1, 2].permute(2).to_a" do
       set     = subject[1, 2]
       results = set.permute(2).to_a
       
-      results.should =~ [[1, 2], [2, 1]]
+      expect(results).to match_array([[1, 2], [2, 1]])
     end
   end
 end

data/spec/power_set/cardinality_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 require 'combinatorics/power_set'
 
-describe PowerSet do
-  subject { PowerSet }
-
+describe Combinatorics::PowerSet do
   describe "cardinality" do
     it "should return 1 for cardinality(0)" do 
       subject.cardinality(0) == 1

data/spec/power_set/mixin_examples.rb

@@ -8,13 +8,13 @@ shared_examples_for "PowerSet::Mixin" do
   it "the powerset of an empty Set should only contain the empty Set" do
     set = subject[]
 
-    set.powerset.to_a.should == [empty_set]
+    expect(set.powerset.to_a).to eq([empty_set])
   end
 
   it "the powerset of a single Set should contain that Set" do
     set = subject[1]
 
-    set.powerset.to_a.should == [empty_set, Set[*set]]
+    expect(set.powerset.to_a).to eq([empty_set, Set[*set]])
   end
 
   it "the powerset of a Set should all be subsets" do
@@ -23,12 +23,12 @@ shared_examples_for "PowerSet::Mixin" do
 
     set.powerset { |subset| superset += subset }
 
-    superset.should == Set[*set]
+    expect(superset).to eq(Set[*set])
   end
 
   it "should alias powerset to power_set" do
     set = subject[1]
 
-    set.should respond_to(:power_set)
+    expect(set).to respond_to(:power_set)
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,3 @@
-gem 'rspec', '~> 2.4'
 require 'rspec'
-
-require 'combinatorics/version'
-
-include Combinatorics
+require 'simplecov'
+SimpleCov.start

metadata

@@ -1,65 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: combinatorics
 version: !ruby/object:Gem::Version
-  version: 0.4.3
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - Postmodern
 - Duper
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-05-28 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rubygems-tasks
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.4'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '2.0'
 description: A collection of modules and methods for performing Combinatoric calculations.
 email:
 - postmodern.mod3@gmail.com
@@ -72,13 +37,14 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- .document
-- .gemtest
-- .gitignore
-- .rspec
-- .yardopts
+- ".document"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
 - Benchmarks.md
 - ChangeLog.md
+- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -157,26 +123,28 @@ files:
 homepage: https://github.com/postmodern/combinatorics#readme
 licenses:
 - MIT
-post_install_message: 
+metadata:
+  documentation_uri: https://rubydoc.info/gems/combinatorics
+  source_code_uri: https://github.com/postmodern/combinatorics.rb
+  bug_tracker_uri: https://github.com/postmodern/combinatorics.rb/issues
+  changelog_uri: https://github.com/postmodern/combinatorics.rb/blob/master/ChangeLog.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
 summary: Bringing (more) Combinatorics to Ruby
 test_files: []