What is this

JavaScript is very verbose when it comes to testing for specific properties or methods in objects. Some times we need some introspection when building an app that generalizes over some of objects pertaining to a specific domain.

Say we're implementing a virtual Zoo:

class Animal {
    constructor(species, family, numberOfLegs, skin) {
        this.species = species;
        this.family = family;
        this.numberOfLegs = numberOfLegs;
        this.skin = skin;
    }
}

class Monkey extends Animal {
    constructor() {
        super("monkey", "mamals", 2, "fur");
    }
    
    bite() {
       	
    }
}

class Dolphin extends Animal {
    constructor() {
        super("dolphin", "mamals", 0, "soft");
    }
    
    swim() {
        
    }
}

class Eagle extends Animal {
    constructor() {
        super("eagle", "birds", 2, "feathers");
    }
    
    beaks() {
        
    }
    
    fly() {
        
    }
}

// ... more animals

And some part of the app draws a profile page on the animal. We will need to test for the class type, some properties and what animals can do. This is how it would go in JavaScript.

(animal) => {
    
   	if(animal.family === "mamals" && typeof animal.layEggs === "function" && animal.haveSpikes) {
        console.log("In this particular order of mamals we can see that females lay eggs. Belonging to this family we have the marsupials and monotremes")
    }
    
    if(animal.contructor.name == "bat" || animal.family === "birds" || (typeof animal.fly === "function" && animal.skin === "feathers")) {
        console.log("This animal can fly");
    }
    
    /// ...
}

This is verbose and might be difficult to follow after a while. Complex cases might pop.

Would be best we could write.

(animal) => {
    if(animal.is_("mamals").do("layEggs").and.have("haveSpikes").true()) {
        //...
    }
    
    if(animal.is_("bat").or.is("birds").or.do("fly").have(a => a.skin === "feathers").true()) {
       //...
    }
}

Configure a domain

To install.

$ npm i is-do-and-have or yarn add is-do-and-have

Require and attach to your class domain.

import IsDoAndHave from 'is-do-and-have'

class Animal {
	// ...
}

IsDoAndHave(Animal, options = {})

Options.

| name | description | default | | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ | | is: Function(Class, instance, something) | If some instance can be said of being a something | It checks for immediate constructor name | | do: Function(Class, instance, someaction, _with = undefined) | If some instance might be able to do someaction and bounded by _with | Checks for the existence of some function on instance | | have: Function(Class, instance, somestuff) | If some instance might be said to possess somestuff. Using a function for somestuff will test an object properties. | It check for some instance property or run through all properties with a test function | | properties: Function(Class, instance) | Gets all object properties used when have. Can be used for filtering or "virtual" properties. | Sends the whole object instance | | before: Function(Class, instance) | Execute everytime before one of other methods and returns the instance they'll get as argument | Sends the whole object instance |

IsDoAndHave(Animal, options = {
    is: (Class, instance, something) => instance.constructor.name === something || instance.family === something,
    do: (Class, instance, someaction) => typeof instance[someaction] === "function" || someaction === "fly" && instance.skin === "feathers"
})

How to conditionals

Configured class will have the following methods attached: is_, do_, have_, not_. You started the query on one of these.

Query is built from.

| method | description | Example | returns | | ------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------- | | is(things: *String) | An object is of "something" | t.is_("hot").is("sour") | Query | | do(stuff: String, with_: Mixed) | And does some stuff with with_ (or just does some stuff) | t.do_("smell tasty").is("tasty") | Query | | have(stuff) | It does have some stuff | t.have("chillies").is("hot").do("sweat") | Query | | not | It negates whatever it comes next | t.have.not("chillies").is("mild").not.do("sweat") | Query | | not(whatever: Mixed) | It negates whatever using the previous query | | Query | | and | Sugar | t.is_("hot").and("sour").and("spicy") | Query | | and(whatever: Mixed) | Uses the previous query in the chain | | Query | | or | Breaks the chain in two OR conditions | t.is_("hot").and("sour").or.is("spicy") | Query | | or(what) | Breaks the chain in three OR conditions starting a new chain | t.have_("chillies").or(t => t.have("ginger")).have("chilly paste") | Query | | true() | Gets the results | t.is(...).do(...).have(...).true() | Boolean | | false() | Negates the results | t.is(...).do(...).have(...).false() | Boolean |

Some particulars:

• Negating an .or statement will negate the whole OR chain
• not.not.is() is is()
• You can not.true()

Testing

$ npm run test and $ yarn test