Pass through to provider CommentLookupSession.use_isolated_book_view
173598
def use_isolated_book_view(self):
        """"""
        self._book_view = ISOLATED
        # self._get_provider_session('comment_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_isolated_book_view()
            except AttributeError:
                pass
535569
function () {
            var me = this;
            if (!me.lastBk) {
                me.lastBk = me.selection.getRange().createBookmark(true);
            }
            me.container.style.display = 'none'
        }
1157444
def use_plenary_gradebook_column_view(self):
        """"""
        self._object_views['gradebook_column'] = PLENARY
        # self._get_provider_session('gradebook_column_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_plenary_gradebook_column_view()
            except AttributeError:
                pass
1176947
function executeInitHooks(currentView, tView, creationMode) {
    if (currentView[FLAGS] & 16 /* RunInit */) {
        executeHooks(currentView[DIRECTIVES], tView.initHooks, tView.checkHooks, creationMode);
        currentView[FLAGS] &= ~16 /* RunInit */;
    }
}
301783
def use_plenary_book_view(self):
        """"""
        self._book_view = PLENARY
        # self._get_provider_session('comment_book_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_plenary_book_view()
            except AttributeError:
                pass
130643
def use_isolated_objective_bank_view(self):
        """"""
        self._objective_bank_view = ISOLATED
        # self._get_provider_session('objective_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_isolated_objective_bank_view()
            except AttributeError:
                pass
1154317
function permittedOptions(methodName) {
        var options = ghostBookshelf.Model.permittedOptions.call(this, methodName),

            // whitelists for the `options` hash argument on methods, by method name.
            // these are the only options that can be passed to Bookshelf / Knex.
            validOptions = {
                findOne: ['columns', 'importing', 'withRelated', 'require', 'filter'],
                findPage: ['status', 'staticPages'],
                findAll: ['columns', 'filter'],
                destroy: ['destroyAll', 'destroyBy'],
                edit: ['filter']
            };

        // The post model additionally supports having a formats option
        options.push('formats');

        if (validOptions[methodName]) {
            options = options.concat(validOptions[methodName]);
        }

        return options;
    }
189390
def access_view(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('access:view', **{
        'unicorn': ctx.repo.create_secure_service('unicorn'),
        'service': name,
    })
125324
function (source) {
        var tocStartIndex = source.indexOf(TOC_COMMENT),
            tocEndIndex = source.indexOf(TOC_END_COMMENT, tocStartIndex);

        if (tocStartIndex === -1 || tocEndIndex === -1) return source;

        return source.substring(0, tocStartIndex + TOC_COMMENT.length) +
                source.substring(tocEndIndex + TOC_END_COMMENT.length);
    }
305080
function attachCommentReply(comment) {
    return function reply(body, callback) {
        github.replyToReviewComment(this.repo.data.owner.login, this.repo.data.name, this.data.number, comment.id, body, callback);
    }.bind(this);
}
1001624
public void _doInclude(PageSource[] sources, boolean runOnce, Object cachedWithin) throws PageException {
	if (cachedWithin == null) {
	    _doInclude(sources, runOnce);
	    return;
	}

	// ignore call when runonce an it is not first call
	if (runOnce) {
	    Page currentPage = PageSourceImpl.loadPage(this, sources);
	    if (runOnce && includeOnce.contains(currentPage.getPageSource())) return;
	}

	// get cached data
	String cacheId = CacheHandlerCollectionImpl.createId(sources);
	CacheHandler cacheHandler = config.getCacheHandlerCollection(Config.CACHE_TYPE_INCLUDE, null).getInstanceMatchingObject(cachedWithin, null);

	if (cacheHandler instanceof CacheHandlerPro) {

	    CacheItem cacheItem = ((CacheHandlerPro) cacheHandler).get(this, cacheId, cachedWithin);

	    if (cacheItem instanceof IncludeCacheItem) {
		try {
		    write(((IncludeCacheItem) cacheItem).getOutput());
		    return;
		}
		catch (IOException e) {
		    throw Caster.toPageException(e);
		}
	    }
	}
	else if (cacheHandler != null) { // TODO this else block can be removed when all cache handlers implement CacheHandlerPro

	    CacheItem cacheItem = cacheHandler.get(this, cacheId);

	    if (cacheItem instanceof IncludeCacheItem) {
		try {
		    write(((IncludeCacheItem) cacheItem).getOutput());
		    return;
		}
		catch (IOException e) {
		    throw Caster.toPageException(e);
		}
	    }
	}

	// cached item not found, process and cache result if needed
	long start = System.nanoTime();
	BodyContent bc = pushBody();

	try {
	    _doInclude(sources, runOnce);
	    String out = bc.getString();

	    if (cacheHandler != null) {
		CacheItem cacheItem = new IncludeCacheItem(out, ArrayUtil.isEmpty(sources) ? null : sources[0], System.nanoTime() - start);
		cacheHandler.set(this, cacheId, cachedWithin, cacheItem);
		return;
	    }
	}
	finally {
	    BodyContentUtil.flushAndPop(this, bc);
	}
    }
383665
public Object doSetHandle(Object bookmark, int iOpenMode, String strFields, int iHandleType) throws DBException, RemoteException
    {
        return this.seek(null, 0, null, strFields, bookmark);
    }
754722
def get_form_kwargs(self, **kwargs):
        '''
        
        '''
        kwargs = super(BookPrivateLessonView, self).get_form_kwargs(**kwargs)
        kwargs['user'] = self.request.user if hasattr(self.request,'user') else None
        return kwargs
843700
def use_isolated_bank_view(self):
        """"""
        self._bank_view = ISOLATED
        # self._get_provider_session('item_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_isolated_bank_view()
            except AttributeError:
                pass
103377
function parseIgnore(book) {
    if (book.isLanguageBook()) {
        return Promise.reject(new Error('Ignore files could be parsed for language books'));
    }

    var fs = book.getFS();
    var ignore = book.getIgnore();

    ignore = ignore.add(DEFAULT_IGNORES);

    return Promise.serie(IGNORE_FILES, function(filename) {
        return fs.readAsString(filename)
        .then(function(content) {
            ignore = ignore.add(content.toString().split(/\r?\n/));
        }, function(err) {
            return Promise();
        });
    })

    .then(function() {
        return book.setIgnore(ignore);
    });
}
1149132
def use_comparative_gradebook_column_view(self):
        """"""
        self._object_views['gradebook_column'] = COMPARATIVE
        # self._get_provider_session('gradebook_column_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_gradebook_column_view()
            except AttributeError:
                pass
312540
def _set_gradebook_view(self, session):
        """"""
        if self._gradebook_view == FEDERATED:
            try:
                session.use_federated_gradebook_view()
            except AttributeError:
                pass
        else:
            try:
                session.use_isolated_gradebook_view()
            except AttributeError:
                pass