Clarification on iDontAlways/doYouEven

[brandonscript]

In this readme, these two examples are provided:

Intro

var myURL;
Bro(app)
    .iDontAlways('config.environment.buildURL')
    .butWhenIdo(function(buildURL){
        myURL = buildURL('dev');
    });

Calling nested functions

Bro(object)
    .iDontAlways('method')
    .butWhenIdo(function(returnVal) {
        console.log('object.method() returned ', returnVal);
    });

As far as I can tell, both are functionally identical and call a nested method. In the first example, the function is passed as a callback inside butWhenIdo and then called, whereas in the second example, the return value of the function is passed.

Looking at the code, this looks like the pertinent section:

if (returnValue) {
    (callback || function(){}).call(context || this.object, returnValue);
}

Am I correct in interpreting this that if the nested function returns a value, the return value is passed to the callback, and if it does not return a value, the function is passed to the callback?

If so, that seems like it may be of risky design - you're equally likely to call the function twice by accident as you are to expect it to be a function and instead have it be the returned value? If not, perhaps the readme can be improved to clarify the behavior?

[deltreey]

Actually, this is in the tests https://github.com/letsgetrandy/brototype/blob/master/tests.js#L152 and it's based on the logical way that promises work normally.

[brandonscript]

Still, the test doesn't really clarify the behavior. Is my assumption correct?

[deltreey]

the test runs fn, which does not have a return value, though foo does...so I built a test

    var fired,
        success,
        param,
        context,
        obj = {
            "foo": function() {
                fired = true;
                context = this;
                return 91;
            },
            "bar": 3,
            "fooey": function() {
                    fired = true;
                    context = this;
            }
        },
        fn = function(p) {
            success = true;
            param = p;
        };

    beforeEach(function() {
        fired = false;
        success = false;
        param = null;
        context = null;
    });

    it('should run the requested method if a function without a return value', function() {
        var bro = Bro(obj);
        bro.iDontAlways('fooey').butWhenIdo(fn);
        assert.equal(fired, true);
    });

it passes. It does not require a return value for the function to fire.

[brandonscript]

So are you saying that it always calls the function if it's a function and returns the value?

[deltreey]

that's correct. This also passes, the parameter passed to the function is the non-existent return value.

    it('should run the requested method if a function without a return value', function() {
        var bro = Bro(obj);
        bro.iDontAlways('fooey').butWhenIdo(fn);
        assert.equal(fired, true);
        assert.equal(param, null);
    });

[brandonscript]

Alright. Thanks for the info. The only other thing I'm wondering now is the benefit of having that first example in the readme; if the nested function is always called, that example is only possible if the nested function returns a function. Perhaps the example could be improved to avoid confusion?

[deltreey]

wow, that is confusing now that I'm looking at the readme. @letsgetrandy I'm gonna need your help on this one.

How about specifying the nature of the function in the readme?

var buildUrl = function(env) {
    if (!env) {
        return buildUrl;
    }
    return urlsForBuilds[env];
}

I assume this is some standard pattern that @letsgetrandy has encountered. I suppose it could make sense.