Remove properties that will confuse LB
425248
function getSettings (def) {
  var settings = {}
  for (var s in def) {
    if (def.hasOwnProperty(s)) {
      if (s !== 'name' || s !== 'properties') {
        settings[ s ] = def[ s ]
      }
    }
  }
  return settings
}
1194328
private void cleanProperties(Map<String, String> props) {
        if (props != null) {
            props.remove(StorageProvider.PROPERTIES_CONTENT_MD5);
            props.remove(StorageProvider.PROPERTIES_CONTENT_CHECKSUM);
            props.remove(StorageProvider.PROPERTIES_CONTENT_MODIFIED);
            props.remove(StorageProvider.PROPERTIES_CONTENT_SIZE);
            props.remove(HttpHeaders.CONTENT_LENGTH);
            props.remove(HttpHeaders.CONTENT_TYPE);
            props.remove(HttpHeaders.LAST_MODIFIED);
            props.remove(HttpHeaders.DATE);
            props.remove(HttpHeaders.ETAG);
            props.remove(HttpHeaders.CONTENT_LENGTH.toLowerCase());
            props.remove(HttpHeaders.CONTENT_TYPE.toLowerCase());
            props.remove(HttpHeaders.LAST_MODIFIED.toLowerCase());
            props.remove(HttpHeaders.DATE.toLowerCase());
            props.remove(HttpHeaders.ETAG.toLowerCase());
        }
    }
1007318
function clean(obj) {
  var ret = {};

  // Remove traits/properties that are already represented
  // outside of the data container
  // TODO: Refactor into `omit` call
  var excludeKeys = ['id', 'name', 'firstName', 'lastName'];
  each(excludeKeys, function(omitKey) {
    clear(obj, omitKey);
  });

  // Flatten nested hierarchy, preserving arrays
  obj = flatten(obj);

  // Discard nulls, represent arrays as comma-separated strings
  // FIXME: This also discards `undefined`s. Is that OK?
  for (var key in obj) {
    if (has.call(obj, key)) {
      var val = obj[key];
      if (val == null) {
        continue;
      }

      if (is.array(val)) {
        ret[key] = val.toString();
        continue;
      }

      ret[key] = val;
    }
  }

  return ret;
}
1101454
function removeUnusedProperties(node) {
    if (typeof node !== "object") {
        return;
    }
    ["position"].forEach(function (key) {
        if (node.hasOwnProperty(key)) {
            delete node[key];
        }
    });
}
1055822
function _fnSortingClasses( settings )
	{
		var oldSort = settings.aLastSort;
		var sortClass = settings.oClasses.sSortColumn;
		var sort = _fnSortFlatten( settings );
		var features = settings.oFeatures;
		var i, ien, colIdx;
	
		if ( features.bSort && features.bSortClasses ) {
			// Remove old sorting classes
			for ( i=0, ien=oldSort.length ; i<ien ; i++ ) {
				colIdx = oldSort[i].src;
	
				// Remove column sorting
				$( _pluck( settings.aoData, 'anCells', colIdx ) )
					.removeClass( sortClass + (i<2 ? i+1 : 3) );
			}
	
			// Add new column sorting
			for ( i=0, ien=sort.length ; i<ien ; i++ ) {
				colIdx = sort[i].src;
	
				$( _pluck( settings.aoData, 'anCells', colIdx ) )
					.addClass( sortClass + (i<2 ? i+1 : 3) );
			}
		}
	
		settings.aLastSort = sort;
	}
444448
def remove_object(self, obj):
        """"""
        self._objects.remove(obj)
        self._pairs.difference_update((obj, p) for p in self._properties)
100492
def clean(self, value):
        """"""

        if isinstance(value, six.string_types) and value.lower() == 'false':
            return False

        return bool(value)
502000
private void removeUseless() {
    Set<Map.Entry<String, PropertyNode>> entries = _children.entrySet();
    for (Iterator<Map.Entry<String, PropertyNode>> it = entries.iterator(); it.hasNext(); ) {
      Map.Entry<String, PropertyNode> entry = it.next();
      PropertyNode child = entry.getValue();
      child.removeUseless();
      if (child.isUseless()) {
        it.remove();
      }
    }
  }
664110
function reduceModifiers (previousValue, currentValue) {
    return previousValue + currentValue[property].replace(modifierPlaceholder, currentValue.className);
  }
1196793
private void removeUnnecessaryHasManyToSelf() {
		model.getPrimaryAttributes();
		String[] hasMany = model.getHasMany();
		String[] hasManyLocalColumn = model.getHasManyLocalColumn();
		String[] hasManyReferencedColumn = model.getHasManyReferencedColumn();


		for(int i = 0; i < hasMany.length; i++){
			boolean hasManyLocalInPrimary = CStringUtils.inArray(model.getPrimaryAttributes(), hasManyLocalColumn[i]);
			boolean hasManyReferencedInPrimary = CStringUtils.inArray(model.getPrimaryAttributes(), hasManyReferencedColumn[i]);

			if(hasMany[i].equals(model.getTableName()) && hasManyLocalColumn[i].equals(hasManyReferencedColumn[i]) &&
					hasManyLocalInPrimary && hasManyReferencedInPrimary ){
				model = removeFromHasMany(model, hasMany[i]);
			}
		}

	}
3388
public void removeLast() {
		if (this.numTypesProperty.get()>0) {
			switch(this.types[this.numTypesProperty.get()-1]) {
			case CLOSE:
				// no coord to remove
				break;
			case MOVE_TO:
			case LINE_TO:
				this.numCoordsProperty.set(this.numCoordsProperty.get()-3);
				break;
			case CURVE_TO:
				this.numCoordsProperty.set(this.numCoordsProperty.get()-9);
				this.isPolylineProperty = null;
				break;
			case QUAD_TO:
				this.numCoordsProperty.set(this.numCoordsProperty.get()-6);
				this.isPolylineProperty = null;
				break;
			default:
				throw new IllegalStateException();
			}
			this.numTypesProperty.set(this.numTypesProperty.get()-1);
			this.isEmptyProperty = null;
			this.graphicalBounds = null;
			this.logicalBounds = null;
		}
	}
590813
private void clear() {
        boolPropertySet = null;
        databaseInputDir = null;
        databaseOutputDir = null;
        IO.close(project);
    }
22625
def cleanupversion(ver):
    """"""
    lst = ver.split(".")
    if len(lst) == 1:
        lst.extend(['0', '0'])
    elif len(lst) == 2:
        lst.extend(['0'])
    elif len(lst) > 2:
        lst = lst[:3]
    lst[2] = '0' # ensure the 3rd number is 0    
    cleanver = '.'.join(lst)
    return cleanver
834739
def remove_ctx(properties):
    
    result = {}

    for name in properties:
        elt_properties = properties[name]
        result[name] = []
        for _, value in elt_properties:
            result[name].append(value)

    return result
1011650
def remove_properties(self):
        
        node_prop = self.node.find('properties')
        if node_prop is not None:
            self.node.remove(node_prop)
182565
def _replace_bbox_none(self, bbox):
        """"""

        (bb_top, bb_left), (bb_bottom, bb_right) = bbox

        if bb_top is None:
            bb_top = 0

        if bb_left is None:
            bb_left = 0

        if bb_bottom is None:
            bb_bottom = self.code_array.shape[0] - 1

        if bb_right is None:
            bb_right = self.code_array.shape[1] - 1

        return (bb_top, bb_left), (bb_bottom, bb_right)
1011314
def clear(self):
        """"""
        # Adapted from http://stackoverflow.com/a/13103617/1198772
        for i in reversed(list(range(self.extra_keywords_layout.count()))):
            self.extra_keywords_layout.itemAt(i).widget().setParent(None)
        self.widgets_dict = OrderedDict()