* Update all references to Fixnum to Integer

Deprecated in ruby 2.4

Author: PikachuEXE

.rubocop.yml

@@ -64,7 +64,7 @@ Style/Documentation:
 Layout/LineLength:
   Enabled: false
 
-# triggered by Contract ({ :name => String, :age => Fixnum }) => nil
+# triggered by Contract ({ :name => String, :age => Integer }) => nil
 Lint/ParenthesesAsGroupedExpression:
   Enabled: false
 

TUTORIAL.md

@@ -80,16 +80,16 @@ contracts.ruby comes with a lot of built-in contracts, including the following:
 
 * Logical combinations
   * [`Maybe`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Maybe) – specifies that a value _may be_ nil, e.g. `Maybe[String]` (equivalent to `Or[String,nil]`)
-  * [`Or`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Or) – passes if any of the given contracts pass, e.g. `Or[Fixnum, Float]`
-  * [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Fixnum, Float]`
+  * [`Or`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Or) – passes if any of the given contracts pass, e.g. `Or[Integer, Float]`
+  * [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Integer, Float]`
   * [`And`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/And) – passes if all contracts pass, e.g. `And[Nat, -> (n) { n.even? }]`
   * [`Not`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Not) – passes if all contracts fail for the given argument, e.g. `Not[nil]`
 
 * Collections
   * [`ArrayOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/ArrayOf) – checks that the argument is an array, and all elements pass the given contract, e.g. `ArrayOf[Num]`
   * [`SetOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/SetOf) – checks that the argument is a set, and all elements pass the given contract, e.g. `SetOf[Num]`
   * [`HashOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/HashOf) – checks that the argument is a hash, and all keys and values pass the given contract, e.g. `HashOf[Symbol => String]` or `HashOf[Symbol,String]`
-  * [`StrictHash`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/StrictHash) – checks that the argument is a hash, and every key passed is present in the given contract, e.g. `StrictHash[{ :description => String, :number => Fixnum }]`
+  * [`StrictHash`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/StrictHash) – checks that the argument is a hash, and every key passed is present in the given contract, e.g. `StrictHash[{ :description => String, :number => Integer }]`
   * [`RangeOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/RangeOf) – checks that the argument is a range whose elements (#first and #last) pass the given contract, e.g. `RangeOf[Date]`
   * [`Enum`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Enum) – checks that the argument is part of a given collection of objects, e.g. `Enum[:a, :b, :c]`
 
@@ -152,7 +152,7 @@ end
 
 You always need to specify a contract for the return value. In this example, `hello` doesn't return anything, so the contract is `nil`. Now you know that you can use a constant like `nil` as the end of a contract. Valid values for a contract are:
 
-- the name of a class (like `String` or `Fixnum`)
+- the name of a class (like `String` or `Integer`)
 - a constant (like `nil` or `1`)
 - a `Proc` that takes a value and returns true or false to indicate whether the contract passed or not
 - a class that responds to the `valid?` class method (more on this later)
@@ -161,32 +161,32 @@ You always need to specify a contract for the return value. In this example, `he
 ### A Double Function
 
 ```ruby
-Contract C::Or[Fixnum, Float] => C::Or[Fixnum, Float]
+Contract C::Or[Integer, Float] => C::Or[Integer, Float]
 def double(x)
   2 * x
 end
 ```
 
 Sometimes you want to be able to choose between a few contracts. `Or` takes a variable number of contracts and checks the argument against all of them. If it passes for any of the contracts, then the `Or` contract passes.
-This introduces some new syntax. One of the valid values for a contract is an instance of a class that responds to the `valid?` method. This is what `Or[Fixnum, Float]` is. The longer way to write it would have been:
+This introduces some new syntax. One of the valid values for a contract is an instance of a class that responds to the `valid?` method. This is what `Or[Integer, Float]` is. The longer way to write it would have been:
 
 ```ruby
-Contract C::Or.new(Fixnum, Float) => C::Or.new(Fixnum, Float)
+Contract C::Or.new(Integer, Float) => C::Or.new(Integer, Float)
 ```
 
 All the built-in contracts have overridden the square brackets (`[]`) to give the same functionality. So you could write
 
 ```ruby
-Contract C::Or[Fixnum, Float] => C::Or[Fixnum, Float]
+Contract C::Or[Integer, Float] => C::Or[Integer, Float]
 ```
 
 or
 
 ```ruby
-Contract C::Or.new(Fixnum, Float) => C::Or.new(Fixnum, Float)
+Contract C::Or.new(Integer, Float) => C::Or.new(Integer, Float)
 ```
 
-whichever you prefer. They both mean the same thing here: make a new instance of `Or` with `Fixnum` and `Float`. Use that instance to validate the argument.
+whichever you prefer. They both mean the same thing here: make a new instance of `Or` with `Integer` and `Float`. Use that instance to validate the argument.
 
 ### A Product Function
 
@@ -455,7 +455,7 @@ Now you can use `Person` wherever you would have used `Or[Hash, nil]`. Your code
 
 Contracts are very easy to define. To re-iterate, there are 5 kinds of contracts:
 
-- the name of a class (like `String` or `Fixnum`)
+- the name of a class (like `String` or `Integer`)
 - a constant (like `nil` or `1`)
 - a `Proc` that takes a value and returns true or false to indicate whether the contract passed or not
 - a class that responds to the `valid?` class method (more on this later)
@@ -511,7 +511,7 @@ The `Or` contract takes a sequence of contracts, and passes if any of them pass.
 This class inherits from `CallableClass`, which allows us to use `[]` when using the class:
 
 ```ruby
-Contract C::Or[Fixnum, Float] => C::Num
+Contract C::Or[Integer, Float] => C::Num
 def double(x)
   2 * x
 end
@@ -520,7 +520,7 @@ end
 Without `CallableClass`, we would have to use `.new` instead:
 
 ```ruby
-Contract C::Or.new(Fixnum, Float) => C::Num
+Contract C::Or.new(Integer, Float) => C::Num
 def double(x)
 # etc
 ```
@@ -723,7 +723,7 @@ class MyBirthday < Struct.new(:day, :month)
   invariant(:day) { 1 <= day && day <= 31 }
   invariant(:month) { 1 <= month && month <= 12 }
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def silly_next_day!
     self.day += 1
   end

lib/contracts/builtin_contracts.rb

@@ -95,7 +95,7 @@ def self.[](*vals)
 
     # Takes a variable number of contracts.
     # The contract passes if any of the contracts pass.
-    # Example: <tt>Or[Fixnum, Float]</tt>
+    # Example: <tt>Or[Integer, Float]</tt>
     class Or < CallableClass
       def initialize(*vals)
         super()
@@ -120,7 +120,7 @@ def to_s
 
     # Takes a variable number of contracts.
     # The contract passes if exactly one of those contracts pass.
-    # Example: <tt>Xor[Fixnum, Float]</tt>
+    # Example: <tt>Xor[Integer, Float]</tt>
     class Xor < CallableClass
       def initialize(*vals)
         super()
@@ -146,7 +146,7 @@ def to_s
 
     # Takes a variable number of contracts.
     # The contract passes if all contracts pass.
-    # Example: <tt>And[Fixnum, Float]</tt>
+    # Example: <tt>And[Integer, Float]</tt>
     class And < CallableClass
       def initialize(*vals)
         super()

spec/builtin_contracts_spec.rb

@@ -30,7 +30,7 @@ def passes(&some)
   end
 
   describe "Num:" do
-    it "should pass for Fixnums" do
+    it "should pass for Integers" do
       passes { @o.double(2) }
     end
 

spec/fixtures/fixtures.rb

@@ -100,11 +100,11 @@ def sum_three(vals)
     end
   end
 
-  Contract ({ :name => String, :age => Fixnum }) => nil
+  Contract ({ :name => String, :age => Integer }) => nil
   def person(data)
   end
 
-  Contract C::StrictHash[{ :name => String, :age => Fixnum }] => nil
+  Contract C::StrictHash[{ :name => String, :age => Integer }] => nil
   def strict_person(data)
   end
 
@@ -119,7 +119,7 @@ def hash_complex_contracts(data)
   def nested_hash_complex_contracts(data)
   end
 
-  Contract C::KeywordArgs[:name => String, :age => Fixnum] => nil
+  Contract C::KeywordArgs[:name => String, :age => Integer] => nil
   def person_keywordargs(name: "name", age: 10)
   end
 
@@ -529,30 +529,30 @@ def initialize(day, month)
     @month = month
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def silly_next_day!
     self.day += 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def silly_next_month!
     self.month += 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def clever_next_day!
     return clever_next_month! if day == 31
     self.day += 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def clever_next_month!
     return next_year! if month == 12
     self.month += 1
     self.day = 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def next_year!
     self.month = 1
     self.day = 1
@@ -610,7 +610,7 @@ def on_response(status, body)
       body + "!"
     end
 
-    Contract Fixnum, String => String
+    Contract Integer, String => String
     def on_response(status, body)
       "error #{status}: #{body}"
     end