contracts 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e31d0dc3c6a107d0255ab5af8229749e6ce825e6
-  data.tar.gz: 915617473470b5450ee855605380d7d6552d49a8
+  metadata.gz: bb93546d34391727b5f9e866f193cddea67ac952
+  data.tar.gz: c214e45aba01fe36d90b3b74f670ccc3254c4b6b
 SHA512:
-  metadata.gz: 73c20ffc1467c52de7a44f91cf1711049c2db2f47aaf3b8faf517a0ba05030aa891c3748a0287ed6d5be799f96d3eb9b92eb8ea950041b0ff459e63262388a56
-  data.tar.gz: 0343d43d8437dcb11255392d53cb57e06119eb0dbd7f20880c0e0646d40b1abf9888e6b1fd5450464eed6ec4635444f7817b87228b1560eca81f0e4997a79eee
+  metadata.gz: 855e9377f9637943e20ebbf82b522bb915208523bfa3bc6bd23b939b613fe860354e9fabdc4d8d3ef3d61d0cbde7f2aa716c6274055d4d948ec998f92f8185e4
+  data.tar.gz: 20341d6090d35f0abc1bee62d9eccb618530d78a2e68a60bd67c22d85776a0a2dd7afaf9899088c77e03e84aa2b576804d52990ab614546a6a04eb0bf20b67bb

data/CHANGELOG.markdown

@@ -1,3 +1,11 @@
+## v0.14.0
+- Enhancement: Add StrictHash contract - [Fyodor](https://github.com/cbrwizard) [#236](https://github.com/egonSchiele/contracts.ruby/pull/236)
+- Bugfix: dont fail if something other than a hash is passed to a KeywordArgs - [Dan Padilha](https://github.com/dpad) [#234](https://github.com/egonSchiele/contracts.ruby/pull/234)
+- LICENSE ADDED: Simplified BSD (same as what is specified in the readme) - [Charles Dale](https://github.com/chuckd) [#233](https://github.com/egonSchiele/contracts.ruby/pull/233)
+- Bugfix: fix constant looking when including a module that includes contracts (requires removing the check to see if contracts is already included) - [Aditya Bhargava](https://github.com/egonSchiele) [#232](https://github.com/egonSchiele/contracts.ruby/pull/232)
+- Bugfix for err case when KeywordArgs and Proc are used together - [Aditya Bhargava](https://github.com/egonSchiele) [#230](https://github.com/egonSchiele/contracts.ruby/pull/230)
+- Enhancement: Add DescendantOf contract - [Miguel Palhas](https://github.com/naps62) [#227](https://github.com/egonSchiele/contracts.ruby/pull/227)
+
 ## 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)

data/Gemfile

@@ -6,7 +6,7 @@ group :test do
   gem "rspec"
   gem "aruba"
   gem "cucumber", "~> 1.3.20"
-  gem "rubocop", "~> 0.29.1", :platform => [:ruby_20, :ruby_21, :ruby_22]
+  gem "rubocop", "~> 0.29.1", :platform => [:ruby_20, :ruby_21, :ruby_22, :ruby_23]
 end
 
 group :development do

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012-2016 Aditya Bhargava
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -39,6 +39,7 @@ puts Example.new.double("oops")
 
 Save this in a file and run it. Notice we are calling `double` with `"oops"`, which is not a number. The contract fails with a detailed error message:
 
+```
 ParamContractError: Contract violation for argument 1 of 1:
         Expected: Num,
         Actual: "oops"
@@ -46,6 +47,7 @@ ParamContractError: Contract violation for argument 1 of 1:
         With Contract: Num => Num
         At: main.rb:8
         ...stack trace...
+```
 
 Instead of throwing an exception, you could log it, print a clean error message for your user...whatever you want. contracts.ruby is here to help you handle bugs better, not to get in your way.
 

data/TUTORIAL.md

@@ -89,6 +89,7 @@ contracts.ruby comes with a lot of built-in contracts, including the following:
   * [`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 }]`
   * [`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]`
 
@@ -270,7 +271,7 @@ You don't need to put a contract on every key. So this call would succeed:
 person({:name => "Adit", :age => 42, :foo => "bar"})
 ```
 
-even though we don't specify a type for `:foo`.
+even though we don't specify a type for `:foo`. If you need this check though, use `StrictHash` instead.
 
 Peruse this contract on the keys and values of a Hash.
 

data/contracts.gemspec

@@ -9,4 +9,5 @@ Gem::Specification.new do |s|
   s.email       = "bluemangroupie@gmail.com"
   s.files       = `git ls-files`.split("\n")
   s.homepage    = "http://github.com/egonSchiele/contracts.ruby"
+  s.license     = "BSD-2-Clause"
 end

data/lib/contracts.rb

@@ -92,9 +92,9 @@ class Contract < Contracts::Decorator
     last_contract = args_contracts.last
     penultimate_contract = args_contracts[-2]
     @has_options_contract = if @has_proc_contract
-                              penultimate_contract.is_a?(Hash)
+                              penultimate_contract.is_a?(Hash) || penultimate_contract.is_a?(Contracts::Builtin::KeywordArgs)
                             else
-                              last_contract.is_a?(Hash)
+                              last_contract.is_a?(Hash) || last_contract.is_a?(Contracts::Builtin::KeywordArgs)
                             end
     # ===
 
@@ -215,9 +215,9 @@ class Contract < Contracts::Decorator
   # returns true if it appended nil
   def maybe_append_options! args, blk
     return false unless @has_options_contract
-    if @has_proc_contract && args_contracts[-2].is_a?(Hash) && !args[-2].is_a?(Hash)
+    if @has_proc_contract && (args_contracts[-2].is_a?(Hash) || args_contracts[-2].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-2].is_a?(Hash)
       args.insert(-2, {})
-    elsif args_contracts[-1].is_a?(Hash) && !args[-1].is_a?(Hash)
+    elsif (args_contracts[-1].is_a?(Hash) || args_contracts[-1].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-1].is_a?(Hash)
       args << {}
     end
     true

data/lib/contracts/builtin_contracts.rb

@@ -393,6 +393,25 @@ module Contracts
       end
     end
 
+    # Use this to specify the Hash characteristics. This contracts fails
+    # if there are any extra keys that don't have contracts on them.
+    # Example: <tt>StrictHash[{ a: String, b: Bool }]</tt>
+    class StrictHash < CallableClass
+      attr_reader :contract_hash
+
+      def initialize(contract_hash)
+        @contract_hash = contract_hash
+      end
+
+      def valid?(arg)
+        return false unless arg.is_a?(Hash)
+
+        contract_hash.all? do |key, _v|
+          contract_hash.key?(key) && Contract.valid?(arg[key], contract_hash[key])
+        end
+      end
+    end
+
     # Use this for specifying contracts for keyword arguments
     # Example: <tt>KeywordArgs[ e: Range, f: Optional[Num] ]</tt>
     class KeywordArgs < CallableClass
@@ -401,6 +420,7 @@ module Contracts
       end
 
       def valid?(hash)
+        return false unless hash.is_a?(Hash)
         return false unless hash.keys - options.keys == []
         options.all? do |key, contract|
           Optional._valid?(hash, key, contract)
@@ -420,6 +440,30 @@ module Contracts
       attr_reader :options
     end
 
+    # Use this for specifying contracts for class arguments
+    # Example: <tt>Descendant[ e: Range, f: Optional[Num] ]</tt>
+    class DescendantOf < CallableClass
+      def initialize(parent_class)
+        @parent_class = parent_class
+      end
+
+      def valid?(given_class)
+        given_class.is_a?(Class) && given_class.ancestors.include?(parent_class)
+      end
+
+      def to_s
+        "DescendantOf[#{parent_class}]"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      attr_reader :parent_class
+    end
+
     # Use this for specifying optional keyword argument
     # Example: <tt>Optional[Num]</tt>
     class Optional < CallableClass

data/lib/contracts/core.rb

@@ -9,8 +9,6 @@ module Contracts
     end
 
     def self.common(base)
-      return if base.respond_to?(:Contract)
-
       base.extend(MethodDecorators)
 
       base.instance_eval do

data/lib/contracts/version.rb

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

data/spec/builtin_contracts_spec.rb

@@ -3,6 +3,24 @@ RSpec.describe "Contracts:" do
     @o = GenericExample.new
   end
 
+  describe "DescendantOf:" do
+    it "should pass for Array" do
+      expect { @o.enumerable_descendant_test(Array) }.to_not raise_error
+    end
+
+    it "should pass for a hash" do
+      expect { @o.enumerable_descendant_test(Hash) }.to_not raise_error
+    end
+
+    it "should fail for a number class" do
+      expect { @o.enumerable_descendant_test(Integer) }.to raise_error(ContractError)
+    end
+
+    it "should fail for a non-class" do
+      expect { @o.enumerable_descendant_test(1) }.to raise_error(ContractError)
+    end
+  end
+
   describe "Num:" do
     it "should pass for Fixnums" do
       expect { @o.double(2) }.to_not raise_error
@@ -350,6 +368,10 @@ RSpec.describe "Contracts:" do
       expect { @o.hash_keywordargs(:hash => nil) }.to raise_error(ContractError)
       expect { @o.hash_keywordargs(:hash => 1) }.to raise_error(ContractError)
     end
+
+    it "should pass if a method is overloaded with non-KeywordArgs" do
+      expect { @o.person_keywordargs("name", 10) }.to_not raise_error
+    end
   end
 
   describe "Optional:" do
@@ -396,4 +418,44 @@ RSpec.describe "Contracts:" do
       end
     end
   end
+
+  describe "StrictHash:" do
+    context "when given an exact correct input" do
+      it "does not raise an error" do
+        expect do
+          @o.strict_person(:name => "calvin", :age => 10)
+        end.to_not raise_error
+      end
+    end
+
+    context "when given an input with correct keys but wrong types" do
+      it "raises an error" do
+        expect do
+          @o.strict_person(:name => "calvin", :age => "10")
+        end.to raise_error(ContractError)
+      end
+    end
+
+    context "when given an input with missing keys" do
+      it "raises an error" do
+        expect do
+          @o.strict_person(:name => "calvin")
+        end.to raise_error(ContractError)
+      end
+    end
+
+    context "when given an input with extra keys" do
+      it "raises an error" do
+        expect do
+          @o.strict_person(:name => "calvin", :age => "10", :soft => true)
+        end.to raise_error(ContractError)
+      end
+    end
+
+    context "when given not a hash" do
+      it "raises an error" do
+        expect { @o.strict_person(1337) }.to raise_error(ContractError)
+      end
+    end
+  end
 end

data/spec/contracts_spec.rb

@@ -727,5 +727,22 @@ RSpec.describe "Contracts:" do
     it "works correctly with methods with passing contracts" do
       expect { klass.new.foo(42) }.to raise_error(ContractError, /Expected: String/)
     end
+
+    # See the discussion on this issue:
+    # https://github.com/egonSchiele/contracts.ruby/issues/229
+    it "should not fail with 'undefined method 'Contract''" do
+      expect do
+        class ModuleThenContracts
+          include ModuleWithContracts
+          include Contracts::Core
+
+          # fails on this line
+          Contract C::Num => C::Num
+          def double(x)
+            x * 2
+          end
+        end
+      end.to_not raise_error
+    end
   end
 end

data/spec/fixtures/fixtures.rb

@@ -104,6 +104,10 @@ class GenericExample
   def person(data)
   end
 
+  Contract C::StrictHash[{ :name => String, :age => Fixnum }] => nil
+  def strict_person(data)
+  end
+
   Contract ({ :rigged => C::Or[TrueClass, FalseClass] }) => nil
   def hash_complex_contracts(data)
   end
@@ -119,6 +123,11 @@ class GenericExample
   def person_keywordargs(data)
   end
 
+  # Testing overloaded method
+  Contract String, Fixnum => nil
+  def person_keywordargs(name, age)
+  end
+
   Contract C::KeywordArgs[:hash => C::HashOf[Symbol, C::Num]] => nil
   def hash_keywordargs(data)
   end
@@ -263,6 +272,10 @@ class GenericExample
     r.first
   end
 
+  Contract C::DescendantOf[Enumerable] => nil
+  def enumerable_descendant_test(enum)
+  end
+
   Contract C::Bool => nil
   def bool_test(x)
   end
@@ -676,3 +689,18 @@ module ModuleContractExample
     :world
   end
 end
+
+module ModuleWithContracts
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    include Contracts::Core
+
+    Contract C::None => String
+    def foo
+      "bar"
+    end
+  end
+end

data/spec/ruby_version_specific/contracts_spec_2.0.rb

@@ -7,6 +7,11 @@ class GenericExample
   Contract ({foo: C::Nat}) => nil
   def nat_test_with_kwarg(foo: 10)
   end
+
+  Contract C::KeywordArgs[name: C::Optional[String]], C::Func[String => String] => String
+  def keyword_args_hello(name: "Adit", &block)
+    "Hey, #{yield name}!"
+  end
 end
 
 RSpec.describe "Contracts:" do
@@ -37,4 +42,14 @@ RSpec.describe "Contracts:" do
       expect { @o.nat_test_with_kwarg }.to raise_error(ContractError)
     end
   end
+
+  describe "keyword args with defaults, with a block" do
+    it "should work when both keyword args and a block is given" do
+      expect(@o.keyword_args_hello(name: "maggie", &:upcase)).to eq("Hey, MAGGIE!")
+    end
+
+    it "should work even when keyword args aren't given" do
+      expect(@o.keyword_args_hello(&:upcase)).to eq("Hey, ADIT!")
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contracts
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Aditya Bhargava
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-25 00:00:00.000000000 Z
+date: 2016-04-26 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
@@ -24,6 +24,7 @@ files:
 - ".travis.yml"
 - CHANGELOG.markdown
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - TODO.markdown
@@ -101,7 +102,8 @@ files:
 - spec/support_spec.rb
 - spec/validators_spec.rb
 homepage: http://github.com/egonSchiele/contracts.ruby
-licenses: []
+licenses:
+- BSD-2-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []