Adds DescendantOf

[naps62]

This adds the ability to make assertions on the class hierarchy of a class being passed as an argument. It should be useful when using things like the Adapter Pattern or Dependency Injection.

Consider the following example:

class SlackClientAdapter < BaseClient
end

class HipchatClientAdapter < BaseClient
end

Contract C::DescendantOf[BaseClient] => BaseClient
def start_client(client_class)
  @client = client_class.new
end

start_client(SlackClientAdapter)
start_client(HipchatClientAdapter)

This is a demonstration of what I'm actually doing on a real app (although the example itself is totally made up).

I want to be able to assert that the argument is not just a class, but a descendant of BaseClient (this base client serves as an abstract class this example. God, I feel like a Java developer all over again...)

I'm not sure if this is something that's already been proposed and discarded, so I didn't take a lot of care in the organization of the code I added.
Should this be accepted, I'll gladly make any required changes before merging.

[egonSchiele]

Hi @naps62 ,
Actually, that's how things currently work...you don't need DescendantOf for this functionality. For example:

require "contracts"
include Contracts

class Animal; end
class Dog < Animal; end
class Cat < Animal; end

Contract Animal => Any
def foo x
  p x
end

foo Dog.new # works, Dog is an Animal (checked with is_a?)
foo "hello" # fails, String is not an Animal

The check happens here.

If you want to do the opposite (i.e. accept Animal only, not Dog or Cat), use Exactly:

Contract Exactly[Animal] => Any
def foo x
  p x
end

[waterlink]

Not exactly, here the argument is not an instance of class, but class itself.

Dog.new as opposed to just Dog.

Am 23.02.2016 um 11:17 PM schrieb Aditya Bhargava notifications@github.com:

Hi @naps62 ,
Actually, that's how things currently work...you don't need DescendantOf for this functionality. For example:

require "contracts"
include Contracts

class Animal; end
class Dog < Animal; end
class Cat < Animal; end

Contract Animal => Any
def foo x
p x
end

foo Dog.new # works, Dog is an Animal (checked with is_a?)
foo "hello" # fails, String is not an Animal
The check happens here.

If you want to do the opposite (i.e. accept Animal only, not Dog or Cat), use Exactly:

Contract Exactly[Animal] => Any
def foo x
p x
end
—
Reply to this email directly or view it on GitHub.

[naps62]

@waterlink is right. following @egonSchiele's example, the use case for this would be something like:

Contract DescendantOf[Animal] => Animal
def animal_factory(x)
  x.new
end

dog = animal_factory(Dog)

without this, the best thing I can check (as far as I know) is just whether the argument is a Class:

Contract Class => Animal

[egonSchiele]

Oops, I misread! You're right, that is useful. Could you fix ci, then I'll merge it:

lib/contracts/builtin_contracts.rb:431:9: C: Style/RedundantReturn: Redundant return detected.
        return given_class.ancestors.include?(@parent_class)

[naps62]

@egonSchiele ok great. The build is now fixed

[egonSchiele]

Thank you for the PRs!

[PikachuEXE]

Should this line be DescendantOf instead?

[egonSchiele]

You are correct @PikachuEXE. Fix is on master.