contracts 0.12.0 → 0.13.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MzAzMDEzNDY4MjVjYWM2Njk2ZWViYTI0MTQ4MTI5ZGZiMGZhOTNhNA==
-  data.tar.gz: !binary |-
-    NDFhYTJmODVkY2FlNWE3ZGI2ZjcxM2JiODMyODBlZjM4MmRjZDkwZQ==
+SHA1:
+  metadata.gz: e31d0dc3c6a107d0255ab5af8229749e6ce825e6
+  data.tar.gz: 915617473470b5450ee855605380d7d6552d49a8
 SHA512:
-  metadata.gz: !binary |-
-    ZjNmODA2MDM5NGI0MjVjMzI0MDNlYmRjZWMzOTUxNmFhYmE0NWU1OGIwNzEz
-    ZDAwMmNhZWVkMTMxMDZkZTUwOGMwN2VhYjBlOTg2MGFhNmEzNjM1N2Q0NTJi
-    YzMzN2Y1ZTBiMWIwZDgyYWM0MmM5N2IyMjQ3ZWVmZGMwYzQxZDE=
-  data.tar.gz: !binary |-
-    ZTI2OWM5ZTNmYjFmMTI1NjU5ODUwNzM4MTg3NDBjYjkxM2RkZDJiYTBjNTcy
-    ZGY4NzYzZWU2NmM3Njc2ZmFlZjAzYzBkZDdhYTQ3ZmViNDYyMDY5Yzc2N2M3
-    Y2U5NTczYjdiODZjZjAxMzNiOGVjYTkyNzlhY2UyYmM3NDQzOWQ=
+  metadata.gz: 73c20ffc1467c52de7a44f91cf1711049c2db2f47aaf3b8faf517a0ba05030aa891c3748a0287ed6d5be799f96d3eb9b92eb8ea950041b0ff459e63262388a56
+  data.tar.gz: 0343d43d8437dcb11255392d53cb57e06119eb0dbd7f20880c0e0646d40b1abf9888e6b1fd5450464eed6ec4635444f7817b87228b1560eca81f0e4997a79eee

data/CHANGELOG.markdown

@@ -1,3 +1,9 @@
+## v0.13.0
+
+- Enhancement: Add support for Ruby 2.3 - [Oleksii Fedorov](https://github.com/waterlink) [#216](https://github.com/egonSchiele/contracts.ruby/pull/216)
+- Enhancement: Added Int, Nat and NatPos builtin contracts - [Simon George](https://github.com/sfcgeorge) [#212](https://github.com/egonSchiele/contracts.ruby/pull/212)
+- Bugfix: Allow contracts on singleton of subclass - [Oleksii Federov](https://github.com/waterlink) [#211](https://github.com/egonSchiele/contracts.ruby/pull/211)
+
 ## v0.12.0
 
 - Feature: add `Regexp` validator - [Gert Goet](https://github.com/eval) [#196](https://github.com/egonSchiele/contracts.ruby/pull/196)

data/TUTORIAL.md

@@ -68,42 +68,44 @@ This can be useful if you're in a REPL and want to figure out how a function sho
 contracts.ruby comes with a lot of built-in contracts, including the following:
 
 * Basic types
-  * [`Num`](http://www.rubydoc.info/gems/contracts/Contracts/Num) – checks that the argument is `Numeric`
-  * [`Pos`](http://www.rubydoc.info/gems/contracts/Contracts/Pos) – checks that the argument is a positive number
-  * [`Neg`](http://www.rubydoc.info/gems/contracts/Contracts/Neg) – checks that the argument is a negative number
-  * [`Nat`](http://www.rubydoc.info/gems/contracts/Contracts/Nat) – checks that the argument is a natural number (>= 0)
-  * [`Bool`](http://www.rubydoc.info/gems/contracts/Contracts/Bool) – checks that the argument is `true` or `false`
-  * [`Any`](http://www.rubydoc.info/gems/contracts/Contracts/Any) – Passes for any argument. Use when the argument has no constraints.
-  * [`None`](http://www.rubydoc.info/gems/contracts/Contracts/None) – Fails for any argument. Use when the method takes no arguments.
+  * [`Num`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Num) – checks that the argument is `Numeric`
+  * [`Pos`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Pos) – checks that the argument is a positive number
+  * [`Neg`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Neg) – checks that the argument is a negative number
+  * [`Int`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Int) – checks that the argument is an integer
+  * [`Nat`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Nat) – checks that the argument is a natural number (>= 0)
+  * [`NatPos`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/NatPos) – checks that the argument is a positive natural number (> 0)
+  * [`Bool`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Bool) – checks that the argument is `true` or `false`
+  * [`Any`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Any) – Passes for any argument. Use when the argument has no constraints.
+  * [`None`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/None) – Fails for any argument. Use when the method takes no arguments.
 
 * Logical combinations
-  * [`Maybe`](http://www.rubydoc.info/gems/contracts/Contracts/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/Or) – passes if any of the given contracts pass, e.g. `Or[Fixnum, Float]`
-  * [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Fixnum, Float]`
-  * [`And`](http://www.rubydoc.info/gems/contracts/Contracts/And) – passes if all contracts pass, e.g. `And[Nat, -> (n) { n.even? }]`
-  * [`Not`](http://www.rubydoc.info/gems/contracts/Contracts/Not) – passes if all contracts fail for the given argument, e.g. `Not[nil]`
+  * [`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]`
+  * [`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/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/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/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]`
-  * [`RangeOf`](http://www.rubydoc.info/gems/contracts/Contracts/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/Enum) – checks that the argument is part of a given collection of objects, e.g. `Enum[:a, :b, :c]`
+  * [`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]`
+  * [`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]`
 
 * Keyword arguments
-  * [`KeywordArgs`](http://www.rubydoc.info/gems/contracts/Contracts/KeywordArgs) – checks that the argument is an options hash, and all required keyword arguments are present, and all values pass their respective contracts, e.g. `KeywordArgs[:number => Num, :description => Optional[String]]`
-  * [`Optional`](http://www.rubydoc.info/gems/contracts/Contracts/Optional) – checks that the keyword argument is either not present or pass the given contract, can not be used outside of `KeywordArgs` contract, e.g. `Optional[Num]`
+  * [`KeywordArgs`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/KeywordArgs) – checks that the argument is an options hash, and all required keyword arguments are present, and all values pass their respective contracts, e.g. `KeywordArgs[:number => Num, :description => Optional[String]]`
+  * [`Optional`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Optional) – checks that the keyword argument is either not present or pass the given contract, can not be used outside of `KeywordArgs` contract, e.g. `Optional[Num]`
 
 * Duck typing
-  * [`RespondTo`](http://www.rubydoc.info/gems/contracts/Contracts/RespondTo) – checks that the argument responds to all of the given methods, e.g. `RespondTo[:password, :credit_card]`
-  * [`Send`](http://www.rubydoc.info/gems/contracts/Contracts/Send) – checks that all named methods return a truthy value, e.g. `Send[:valid?]`
+  * [`RespondTo`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/RespondTo) – checks that the argument responds to all of the given methods, e.g. `RespondTo[:password, :credit_card]`
+  * [`Send`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Send) – checks that all named methods return a truthy value, e.g. `Send[:valid?]`
 
 * Miscellaneous
-  * [`Exactly`](http://www.rubydoc.info/gems/contracts/Contracts/Exactly) – checks that the argument has the given type, not accepting sub-classes, e.g. `Exactly[Numeric]`.
-  * [`Eq`](http://www.rubydoc.info/gems/contracts/Contracts/Eq) – checks that the argument is precisely equal to the given value, e.g. `Eq[String]` matches the class `String` and not a string instance.
-  * [`Func`](http://www.rubydoc.info/gems/contracts/Contracts/Func) – specifies the contract for a proc/lambda e.g. `Contract ArrayOf[Num], Func[Num => Num] => ArrayOf[Num]`. See section "Contracts On Functions".
+  * [`Exactly`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Exactly) – checks that the argument has the given type, not accepting sub-classes, e.g. `Exactly[Numeric]`.
+  * [`Eq`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Eq) – checks that the argument is precisely equal to the given value, e.g. `Eq[String]` matches the class `String` and not a string instance.
+  * [`Func`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Func) – specifies the contract for a proc/lambda e.g. `Contract ArrayOf[Num], Func[Num => Num] => ArrayOf[Num]`. See section "Contracts On Functions".
 
-To see all the built-in contracts and their full descriptions, check out the [RDoc](http://rubydoc.info/gems/contracts/Contracts).
+To see all the built-in contracts and their full descriptions, check out the [RDoc](http://rubydoc.info/gems/contracts/Contracts/Builtin).
 
 It is recommended to use shortcut for referring builtin contracts:
 

data/features/builtin_contracts/args.feature

@@ -1 +1,80 @@
-Feature: Args (TODO)
+Feature: Args
+
+  Used for `*args` (variadic functions). Takes contract and uses it to validate
+  every element passed in through `*args`.
+
+  ```ruby
+  Contract C::Args[C::Num] => C::Bool
+  def example(*args)
+  ```
+
+  This example contract will validate all arguments passed through `*args` to
+  accept only numbers.
+
+  Background:
+    Given a file named "args_usage.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      Contract C::Args[C::Num] => C::Bool
+      def only_nums(*args)
+        args.inspect
+      end
+    end
+    """
+
+  Scenario: Accepts no arguments
+    Given a file named "accepts_no_arguments.rb" with:
+    """ruby
+    require "./args_usage"
+    puts Example.new.only_nums
+    """
+    When I run `ruby accepts_no_arguments.rb`
+    Then the output should contain:
+    """
+    []
+    """
+
+  Scenario: Accepts one valid argument
+    Given a file named "accepts_one_argument.rb" with:
+    """ruby
+    require "./args_usage"
+    puts Example.new.only_nums(42)
+    """
+    When I run `ruby accepts_one_argument.rb`
+    Then the output should contain:
+    """
+    [42]
+    """
+
+  Scenario: Accepts many valid arguments
+    Given a file named "accepts_many_arguments.rb" with:
+    """ruby
+    require "./args_usage"
+    puts Example.new.only_nums(42, 45, 17, 24)
+    """
+    When I run `ruby accepts_many_arguments.rb`
+    Then the output should contain:
+    """
+    [42, 45, 17, 24]
+    """
+
+  Scenario: Rejects invalid argument
+    Given a file named "rejects_invalid_argument.rb" with:
+    """ruby
+    require "./args_usage"
+    puts Example.new.only_nums(42, "foo", 17, 24)
+    """
+    When I run `ruby rejects_invalid_argument.rb`
+    Then the output should contain:
+    """
+    : Contract violation for argument 1 of 4: (ParamContractError)
+            Expected: (Args[Contracts::Builtin::Num]),
+            Actual: "foo"
+            Value guarded in: Example::only_nums
+            With Contract: Args => Bool
+    """

data/features/builtin_contracts/int.feature

@@ -0,0 +1,93 @@
+Feature: Int
+
+  Checks that an argument is an integer.
+
+  ```ruby
+  Contract C::Int => C::Int
+  ```
+
+  Background:
+    Given a file named "int_usage.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Integr
+      include Contracts::Core
+
+      Contract C::Int => C::Int
+      def prev(number)
+        number - 1
+      end
+    end
+    """
+
+  Scenario: Accepts positive integers
+    Given a file named "accepts_positive_integers.rb" with:
+    """ruby
+    require "./int_usage"
+    puts Integr.new.prev(7)
+    """
+    When I run `ruby accepts_positive_integers.rb`
+    Then output should contain:
+    """
+    6
+    """
+
+  Scenario: Accepts zero
+    Given a file named "accepts_zero.rb" with:
+    """ruby
+    require "./int_usage"
+    puts Integr.new.prev(1)
+    """
+    When I run `ruby accepts_zero.rb`
+    Then output should contain:
+    """
+    0
+    """
+
+  Scenario: Accepts negative integers
+    Given a file named "accepts_negative_integers.rb" with:
+    """ruby
+    require "./int_usage"
+    puts Integr.new.prev(-1)
+    """
+    When I run `ruby accepts_negative_integers.rb`
+    Then output should contain:
+    """
+    -2
+    """
+
+  Scenario: Rejects floats
+    Given a file named "rejects_floats.rb" with:
+    """ruby
+    require "./int_usage"
+    puts Integr.new.prev(3.43)
+    """
+    When I run `ruby rejects_floats.rb`
+    Then output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: Int,
+            Actual: 3.43
+            Value guarded in: Integr::prev
+            With Contract: Int => Int
+    """
+    And output should contain "int_usage.rb:8"
+
+  Scenario: Rejects other values
+    Given a file named "rejects_others.rb" with:
+    """ruby
+    require "./int_usage"
+    puts Integr.new.prev("foo")
+    """
+    When I run `ruby rejects_others.rb`
+    Then output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: Int,
+            Actual: "foo"
+            Value guarded in: Integr::prev
+            With Contract: Int => Int
+    """
+    And output should contain "int_usage.rb:8"

data/features/builtin_contracts/nat_pos.feature

@@ -0,0 +1,119 @@
+Feature: NatPos
+
+  Checks that an argument is a positive natural number.
+
+  ```ruby
+  Contract C::NatPos => C::NatPos
+  ```
+
+  Background:
+    Given a file named "nat_pos_usage.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class NaturalPositive
+      include Contracts::Core
+
+      Contract C::NatPos => C::NatPos
+      def prev(number)
+        number - 1
+      end
+    end
+    """
+
+  Scenario: Accepts positive integers
+    Given a file named "accepts_positive_integers.rb" with:
+    """ruby
+    require "./nat_pos_usage"
+    puts NaturalPositive.new.prev(7)
+    """
+    When I run `ruby accepts_positive_integers.rb`
+    Then output should contain:
+    """
+    6
+    """
+
+  Scenario: Rejects zero
+    Given a file named "rejects_zero.rb" with:
+    """ruby
+    require "./nat_pos_usage"
+    puts NaturalPositive.new.prev(0)
+    """
+    When I run `ruby rejects_zero.rb`
+    Then output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: NatPos,
+            Actual: 0
+            Value guarded in: NaturalPositive::prev
+            With Contract: NatPos => NatPos
+    """
+
+  Scenario: Rejects negative integers
+    Given a file named "rejects_negative_integers.rb" with:
+    """ruby
+    require "./nat_pos_usage"
+    puts NaturalPositive.new.prev(-1)
+    """
+    When I run `ruby rejects_negative_integers.rb`
+    Then output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: NatPos,
+            Actual: -1
+            Value guarded in: NaturalPositive::prev
+            With Contract: NatPos => NatPos
+    """
+    And output should contain "nat_pos_usage.rb:8"
+
+  Scenario: Rejects negative integers as a return value
+    Given a file named "rejects_negative_integers.rb" with:
+    """ruby
+    require "./nat_pos_usage"
+    puts NaturalPositive.new.prev(1)
+    """
+    When I run `ruby rejects_negative_integers.rb`
+    Then output should contain:
+    """
+    : Contract violation for return value: (ReturnContractError)
+            Expected: NatPos,
+            Actual: 0
+            Value guarded in: NaturalPositive::prev
+            With Contract: NatPos => NatPos
+    """
+    And output should contain "nat_pos_usage.rb:8"
+
+  Scenario: Rejects floats
+    Given a file named "rejects_floats.rb" with:
+    """ruby
+    require "./nat_pos_usage"
+    puts NaturalPositive.new.prev(3.43)
+    """
+    When I run `ruby rejects_floats.rb`
+    Then output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: NatPos,
+            Actual: 3.43
+            Value guarded in: NaturalPositive::prev
+            With Contract: NatPos => NatPos
+    """
+    And output should contain "nat_pos_usage.rb:8"
+
+  Scenario: Rejects other values
+    Given a file named "rejects_others.rb" with:
+    """ruby
+    require "./nat_pos_usage"
+    puts NaturalPositive.new.prev("foo")
+    """
+    When I run `ruby rejects_others.rb`
+    Then output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: NatPos,
+            Actual: "foo"
+            Value guarded in: NaturalPositive::prev
+            With Contract: NatPos => NatPos
+    """
+    And output should contain "nat_pos_usage.rb:8"

data/lib/contracts/builtin_contracts.rb

@@ -41,13 +41,27 @@ module Contracts
       end
     end
 
-    # Check that an argument is a natural number.
+    # Check that an argument is an +Integer+.
+    class Int
+      def self.valid? val
+        val && val.is_a?(Integer)
+      end
+    end
+
+    # Check that an argument is a natural number (includes zero).
     class Nat
       def self.valid? val
         val && val.is_a?(Integer) && val >= 0
       end
     end
 
+    # Check that an argument is a positive natural number (excludes zero).
+    class NatPos
+      def self.valid? val
+        val && val.is_a?(Integer) && val > 0
+      end
+    end
+
     # Passes for any argument.
     class Any
       def self.valid? val

data/lib/contracts/decorators.rb

@@ -4,6 +4,10 @@ module Contracts
       Engine.apply(klass)
     end
 
+    def inherited(subclass)
+      Engine.fetch_from(subclass).set_eigenclass_owner
+    end
+
     def method_added(name)
       MethodHandler.new(name, false, self).handle
       super

data/lib/contracts/engine/eigenclass.rb

@@ -18,6 +18,10 @@ module Contracts
         return Engine.fetch_from(eigenclass) if Engine.applied?(eigenclass)
 
         Target.new(eigenclass).apply(Eigenclass)
+        eigenclass.extend(MethodDecorators)
+        # FIXME; this should detect what user uses `include Contracts` or
+        # `include Contracts;;Core`
+        eigenclass.send(:include, Contracts)
         Engine.fetch_from(owner).set_eigenclass_owner
         Engine.fetch_from(eigenclass)
       end

data/lib/contracts/engine/target.rb

@@ -53,6 +53,8 @@ module Contracts
 
         self.class.new(eigenclass).apply(Eigenclass)
         eigenclass.extend(MethodDecorators)
+        # FIXME; this should detect what user uses `include Contracts` or
+        # `include Contracts;;Core`
         eigenclass.send(:include, Contracts)
       end
 

data/lib/contracts/version.rb

@@ -1,3 +1,3 @@
 module Contracts
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/spec/contracts_spec.rb

@@ -141,32 +141,6 @@ RSpec.describe "Contracts:" do
       end.to raise_error(ContractError, /Expected: String/)
     end
 
-    context "when owner class does not include Contracts" do
-      let(:error) do
-        # NOTE Unable to support this user-friendly error for ruby
-        # 1.8.7 and jruby 1.8, 1.9 it has much less support for
-        # singleton inheritance hierarchy
-        if Contracts::Support.eigenclass_hierarchy_supported?
-          [Contracts::ContractsNotIncluded, Contracts::ContractsNotIncluded::DEFAULT_MESSAGE]
-        else
-          [NoMethodError, /undefined method `Contract'/]
-        end
-      end
-
-      it "fails with descriptive error" do
-        expect do
-          Class.new(GenericExample) do
-            class << self
-              Contract String => String
-              def hoge(name)
-                "super#{name}"
-              end
-            end
-          end
-        end.to raise_error(*error)
-      end
-    end
-
     describe "builtin contracts usage" do
       it "allows to use builtin contracts without namespacing and redundant Contracts inclusion" do
         expect do
@@ -176,6 +150,14 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "usage in the singleton class of a subclass" do
+    subject { SingletonInheritanceExampleSubclass }
+
+    it "should work with a valid contract on a singleton method" do
+      expect(subject.num(1)).to eq(1)
+    end
+  end
+
   describe "no contracts feature" do
     it "disables normal contract checks" do
       object = NoContractsSimpleExample.new

data/spec/fixtures/fixtures.rb

@@ -621,6 +621,12 @@ class SingletonInheritanceExample
 end
 
 class SingletonInheritanceExampleSubclass < SingletonInheritanceExample
+  class << self
+    Contract Integer => Integer
+    def num(int)
+      int
+    end
+  end
 end
 
 class BareOptionalContractUsed

data/spec/override_validators_spec.rb

@@ -120,7 +120,7 @@ RSpec.describe Contract do
       end.to raise_error(ContractError)
 
       expect(obj.greet(double("name"))).to match(
-        /hello, #\[Double "name"\]/
+        /hello, #\[.*Double.*"name"\]/
       )
     end
 

data/spec/validators_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe "Contract validators" do
     it "passes when value is in range" do
       expect do
         o.method_with_range_contract(5)
-      end.not_to raise_error(ContractError)
+      end.not_to raise_error
     end
 
     it "fails when value is not in range" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contracts
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Aditya Bhargava
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-20 00:00:00.000000000 Z
+date: 2016-01-25 00:00:00.000000000 Z
 dependencies: []
 description: This library provides contracts for Ruby. Contracts let you clearly express
   how your code behaves, and free you from writing tons of boilerplate, defensive
@@ -18,10 +18,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .rubocop.yml
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - CHANGELOG.markdown
 - Gemfile
 - README.md
@@ -49,9 +49,11 @@ files:
 - features/builtin_contracts/exactly.feature
 - features/builtin_contracts/func.feature
 - features/builtin_contracts/hash_of.feature
+- features/builtin_contracts/int.feature
 - features/builtin_contracts/keyword_args.feature
 - features/builtin_contracts/maybe.feature
 - features/builtin_contracts/nat.feature
+- features/builtin_contracts/nat_pos.feature
 - features/builtin_contracts/neg.feature
 - features/builtin_contracts/none.feature
 - features/builtin_contracts/not.feature
@@ -107,17 +109,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Contracts for Ruby.