maybe not worth polluting
195441
private String getValueTypeDotString() {
        PlanNodeType pnt = getPlanNodeType();
        if (isInline()) {
            return "fontcolor=\"white\" style=\"filled\" fillcolor=\"red\"";
        }
        if (pnt == PlanNodeType.SEND || pnt == PlanNodeType.RECEIVE || pnt == PlanNodeType.MERGERECEIVE) {
            return "fontcolor=\"white\" style=\"filled\" fillcolor=\"black\"";
        }
        return "";
    }
1183616
private void clean(Instances cleanAgainst, Instances toClean, boolean onlyLast) {
		if (cleanAgainst.numInstances() > this.kOption.getValue() && toClean.numInstances() > 0){
			if (onlyLast){
				cleanSingle(cleanAgainst, (cleanAgainst.numInstances()-1), toClean);
			}else{
				for (int i=0; i < cleanAgainst.numInstances(); i++){
					cleanSingle(cleanAgainst, i, toClean);
				}
			}
		}
	}
1196280
function clean(post) {
  return reject({
    title: post.title,
    contentFormat: post.contentFormat,
    content: post.content,
    tags: post.tags,
    canonicalUrl: post.canonicalUrl,
    publishStatus: post.publishStatus,
    license: post.license
  });
}
1121130
def clean(self, value):
        """"""

        for parameter_obj in self.types:
            try:
                return parameter_obj.clean(value)
            except ParameterNotValidError:
                continue

        raise ParameterNotValidError
1028574
static boolean hasEnvironmentVariable(String variable) {
        final String value = System.getenv(variable);
        if (value != null) {
            return true;
        }
        return false;
    }
854911
def accept(self):
        '''
        
        '''
        result = FieldSet.accept(self)
        self.clean_value = result[self.name]
        return self.clean_value
1041757
void recycle(HttpConnection connection)
    {
        super.recycle(connection);
        _status=__200_OK;
        _reason=null;
        _httpContext=null;
    }
1130850
public void clean() {
        if (!remove(this))
            return;
        try {
            thunk.run();
        } catch (final Throwable x) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        if (System.err != null)
                            new Error("Cleaner terminated abnormally", x)
                                .printStackTrace();
                        System.exit(1);
                        return null;
                    }});
        }
    }
139288
private void pessimisticFindFirst(
                                     DeleteStack    stack)
    {
        Object q = null;
        int v1 = 0;
        int x1 = 0;

        synchronized(_index)
        {
            q = getFirst(stack);
            v1 = _index.vno();
            x1 = _index.xno();
            _pessimisticFindFirsts++;
        }

        _current1.setLocation(q, v1, x1);
    }
675777
void recycle() {
        for (int i = 0 ; i < size; i ++) {
            array[i] = null;
        }
        size = 0;
        insertSinceRecycled = false;

        recycler.recycle(this);
    }
1049383
function clean (args, cb) {
  if (!cb) cb = args, args = []
  if (!args) args = []
  args = args.join("/").split("@").join("/")
  if (args.substr(-1) === "/") args = args.substr(0, args.length - 1)
  rm(path.join(npm.cache, path.normalize(args)), cb)
}
33070
function validateEnvironment(environment, envContext, source = null) {

    // not having an environment is ok
    if (!environment) {
        return;
    }

    Object.keys(environment).forEach(env => {
        if (!envContext.get(env)) {
            const message = `${source}:\n\tEnvironment key "${env}" is unknown\n`;

            throw new Error(message);
        }
    });
}
28972
def clean_inconcs(self):
        
        for item in self.data:
            if (item.inconclusive or item.get_verdict() == "unknown") and not item.retries_left > 0:
                return True
        return False
136959
def dirty?(path = Dir.pwd)
      g = MiniGit.new(path)
      a = g.capturing.diff :shortstat => true
      #ap a
      !a.empty?
    end
220293
function onEmpty (data, env) {
  let message = `SassDoc could not find anything to document.\n
  * Are you still using \`/**\` comments ? They're no more supported since 2.0.
    See <http://sassdoc.com/upgrading/#c-style-comments>.\n`

  if (!data.length && env.verbose) {
    env.emit('warning', new errors.Warning(message))
  }
}
377176
def discard(self, value):
        """"""
        # Raise TypeError if value is not hashable
        hash(value)

        self.redis.srem(self.key, self._pickle(value))
1062791
private void pessimisticGetNext(
                                   DeleteStack    stack)
    {
        synchronized(_index)
        {
            internalGetNext(stack, _index.vno(), _index.xno());
            _pessimisticGetNexts++;
        }
    }