options: skipTargetFilter = true: don't filter out target attributes from input attributes. I don't know why you'd want to do this.
336661
function arffToInputs(arffData, targetAttributes, patternAttributes, options = {}) {
  // set the target to the last attribute if no target attributes are given
  if (!Array.isArray(targetAttributes) || targetAttributes.length === 0) {
    targetAttributes = [arffData.attributes[arffData.attributes.length - 1]];
  }
  // get all the columns that represent the targets and place them in one place
  let targetColumns = targetAttributes.map((attribute) => {
    return arffData.data.map((dataRow) => {
      return dataRow[attribute];
    });
  });
  
  // set the patternAttributes to all
  if (!Array.isArray(patternAttributes) || patternAttributes.length === 0) {
    patternAttributes = arffData.attributes;
  }
  if (!options.skipTargetFilter) {
    // filter out the target attributes to get the input attributes
    patternAttributes = patternAttributes.filter((attribute) => {
      return targetAttributes.indexOf(attribute) === -1;
    });
  }
  
  // grab all the input attributes out of each data row to form the set of inputs/patterns
  let patterns = arffData.data.map((dataRow) => {
    return patternAttributes.map((attribute) => {
      return dataRow[attribute];
    });
  });
  
  return {
    targetColumns: targetColumns,
    patterns: patterns,
    patternAttributes: patternAttributes,
    targetAttributes: targetAttributes
  };
}
246149
function skipIndex() {
		if( childType && childType.indexOf('[]') === childType.length-2 ) {
			childType = childType.substring(0, childType.length-2);
		}
	}
406120
public static void skip(DataInput in) throws IOException {
        int length = WritableUtils.readVInt(in);
        WritableUtils.skipFully(in, length);
    }
505574
function() {

            // Build filter if filtering OR case insensitive filtering is enabled and the number of options exceeds (or equals) enableFilterLength.
            if (this.options.enableFiltering || this.options.enableCaseInsensitiveFiltering) {
                var enableFilterLength = Math.max(this.options.enableFiltering, this.options.enableCaseInsensitiveFiltering);

                if (this.$select.find('option').length >= enableFilterLength) {

                    this.$filter = $(this.options.templates.filter);
                    $('input', this.$filter).attr('placeholder', this.options.filterPlaceholder);

                    // Adds optional filter clear button
                    if(this.options.includeFilterClearBtn){
                        var clearBtn = $(this.options.templates.filterClearBtn);
                        clearBtn.on('click', $.proxy(function(event){
                            clearTimeout(this.searchTimeout);
                            this.$filter.find('.multiselect-search').val('');
                            $('li', this.$ul).show().removeClass("filter-hidden");
                            this.updateSelectAll();
                        }, this));
                        this.$filter.find('.input-group').append(clearBtn);
                    }

                    this.$ul.prepend(this.$filter);

                    this.$filter.val(this.query).on('click', function(event) {
                        event.stopPropagation();
                    }).on('input keydown', $.proxy(function(event) {
                        // Cancel enter key default behaviour
                        if (event.which === 13) {
                            event.preventDefault();
                        }

                        // This is useful to catch "keydown" events after the browser has updated the control.
                        clearTimeout(this.searchTimeout);

                        this.searchTimeout = this.asyncFunction($.proxy(function() {

                            if (this.query !== event.target.value) {
                                this.query = event.target.value;

                                var currentGroup, currentGroupVisible;
                                $.each($('li', this.$ul), $.proxy(function(index, element) {
                                    var value = $('input', element).length > 0 ? $('input', element).val() : "";
                                    var text = $('label', element).text();

                                    var filterCandidate = '';
                                    if ((this.options.filterBehavior === 'text')) {
                                        filterCandidate = text;
                                    }
                                    else if ((this.options.filterBehavior === 'value')) {
                                        filterCandidate = value;
                                    }
                                    else if (this.options.filterBehavior === 'both') {
                                        filterCandidate = text + '\n' + value;
                                    }

                                    if (value !== this.options.selectAllValue && text) {
                                        // By default lets assume that element is not
                                        // interesting for this search.
                                        var showElement = false;

                                        if (this.options.enableCaseInsensitiveFiltering && filterCandidate.toLowerCase().indexOf(this.query.toLowerCase()) > -1) {
                                            showElement = true;
                                        }
                                        else if (filterCandidate.indexOf(this.query) > -1) {
                                            showElement = true;
                                        }

                                        // Toggle current element (group or group item) according to showElement boolean.
                                        $(element).toggle(showElement).toggleClass('filter-hidden', !showElement);

                                        // Differentiate groups and group items.
                                        if ($(element).hasClass('multiselect-group')) {
                                            // Remember group status.
                                            currentGroup = element;
                                            currentGroupVisible = showElement;
                                        }
                                        else {
                                            // Show group name when at least one of its items is visible.
                                            if (showElement) {
                                                $(currentGroup).show().removeClass('filter-hidden');
                                            }

                                            // Show all group items when group name satisfies filter.
                                            if (!showElement && currentGroupVisible) {
                                                $(element).show().removeClass('filter-hidden');
                                            }
                                        }
                                    }
                                }, this));
                            }

                            this.updateSelectAll();
                        }, this), 300, this);
                    }, this));
                }
            }
        }
1354821
function negationSelector(selectorContext) {
    // If no properties currently selected, select them all first.
    if (isEmpty(selectorContext.sourceKeys)) {
        extendSourceKeys(selectorContext.sourceKeys, selectorContext.source);
    }
    // Then remove the negated property.
    if (selectorContext.sourceKeys[selectorContext.sourceKey] !== undefined) {
        delete selectorContext.sourceKeys[selectorContext.sourceKey];

    } else {
        // Throw error if negated property not found.
        errorManager.propertyNotFound(selectorContext.sourceKey, selectorContext.source);
    }
}
1123370
function modifyTarget(target, source, sourceKeys, filters, overrideKeys) {

    // Arguments available to each filter.
    var filterContext = {
        target: target, // readonly
        source: source, // readonly
        sourceKey: null, // readonly
        targetKey: null,
        sourceValue: null
    };

    // For each property, send it through the filter pipeline and
    // then apply it to the target object.
    for (var sourceKey in sourceKeys) {
        filterContext.sourceKey = sourceKey;
        filterContext.targetKey = sourceKeys[sourceKey];

        // Throw an error if the source property name doesn't refer to a value.
        if (!(sourceKey in source)) {
            errorManager.propertyNotFound(sourceKey, source);
        }
        filterContext.sourceValue = source[sourceKey];

        // Apply the filters to the property.
        for (var i = 0; i < filters.length; i++) {
            if (!filters[i](filterContext)) {
                // Don't apply this property to the target.
                filterContext.targetKey = null;
                break;
            }
        }

        // Apply property to target.
        if (filterContext.targetKey !== null) {
            // Allow overwrite to take place. Developer can ignore error.
            var overwritten = filterContext.targetKey in target;

            target[filterContext.targetKey] = filterContext.sourceValue;

            if (overwritten && !overrideKeys[sourceKey]) {
                errorManager.propertyOverride(filterContext.targetKey, target);
            }
        }
    }
}
494727
def _filter_attribute(mcs, attribute_name, attribute_value):
        
        if attribute_name == '__module__':
            return True
        elif hasattr(attribute_value, '_trace_disable'):
            return True
        return False
176819
private static VisitorAttributes checkAttributes(VirtualFileFilter filter, VisitorAttributes attributes) {
        if (filter == null) {
            throw MESSAGES.nullArgument("filter");
        }
        // Specified
        if (attributes != null) { return attributes; }
        // From the filter
        if (filter instanceof VirtualFileFilterWithAttributes) { return ((VirtualFileFilterWithAttributes) filter).getAttributes(); }
        // It will use the default
        return null;
    }
1015826
function _handleEditFilter(e) {
        var filterSets  = PreferencesManager.get("fileFilters") || [],
            filterIndex = $(e.target).parent().data("index") - FIRST_FILTER_INDEX;

        // Don't let the click bubble upward.
        e.stopPropagation();

        // Close the dropdown first before opening the edit filter dialog
        // so that it will restore focus to the DOM element that has focus
        // prior to opening it.
        _picker.closeDropdown();

        editFilter(filterSets[filterIndex], filterIndex);
    }
1122797
function() {
    var tok = this.expect('filter');
    var block,
      attrs = [];

    if (this.peek().type === 'start-attributes') {
      attrs = this.attrs();
    }

    if (this.peek().type === 'text') {
      var textToken = this.advance();
      block = this.initBlock(textToken.line, [
        {
          type: 'Text',
          val: textToken.val,
          line: textToken.line,
          filename: this.filename
        }
      ]);
    } else if (this.peek().type === 'filter') {
      block = this.initBlock(tok.line, [this.parseFilter()]);
    } else {
      block = this.parseTextBlock() || this.emptyBlock(tok.line);
    }

    return {
      type: 'Filter',
      name: tok.val,
      block: block,
      attrs: attrs,
      line: tok.line,
      filename: this.filename
    };
  }
489511
def filter_params(self, value):
        
        if value is None:
            return {}
        target = ".".join(self.field.source_attrs)
        return { '__raw__': { target + ".$id": value } }
910318
function cleanAttrs (el, attrs, styles) {  // attrs === false - remove all, attrs === true - allow all
  if (attrs === true) { return; }

  Array.prototype.slice.call(el.attributes)
    .forEach(function (attr) {
      // remove if it is not style nor on attrs  whitelist
      // keeping attributes that are also styles because attributes override
      if (attr.specified) {
        if (attrs === '' || attrs === false || (isUndefined(styles[attr.name]) && attrs.indexOf(attr.name) < 0)) {
          el.removeAttribute(attr.name);
        }
      }
    });
}
894338
function(target, attribute) {
            var self    = this,
                value   = '';

            value = target.dom.el.getAttribute('data-' + attribute);

            if (value === null) {
                if (self.config.debug.showWarnings) {
                    // Encourage users to assign values to all targets to avoid erroneous sorting
                    // when types are mixed

                    console.warn(mixitup.messages.warningInconsistentSortingAttributes({
                        attribute: 'data-' + attribute
                    }));
                }
            }

            // If an attribute is not present, return 0 as a safety value

            return self.callFilters('valueGetAttributeValue', value || 0, arguments);
        }
1202506
function filterFunc(inputValue, optionValue) {
  if (inputValue && optionValue) {
    return optionValue.toLowerCase().indexOf(inputValue.toLowerCase()) > -1;
  }

  return false;
}
290179
@Override
    public void addSourceTargetSet(UnicodeSet inputFilter, UnicodeSet sourceSet, UnicodeSet targetSet) {
        UnicodeSet myFilter = getFilterAsUnicodeSet(inputFilter);
        if (myFilter.size() > 0) {
            sourceSet.addAll(myFilter);
            targetSet.addAll('0', '9')
            .addAll('A', 'Z')
            .add('-')
            .add(' ')
            .addAll(OPEN_DELIM)
            .add(CLOSE_DELIM)
            .addAll('a', 'z') // for controls
            .add('<').add('>') // for controls
            .add('(').add(')') // for controls
            ;
        }
    }
928951
function(attr, options) {
      if (!(attr in this.attributes)) return this;
      options || (options = {});
      var value = this.attributes[attr];

      // Run validation.
      var validObj = {};
      validObj[attr] = void 0;
      if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;

      // Remove the attribute.
      delete this.attributes[attr];
      delete this._escapedAttributes[attr];
      if (attr == this.idAttribute) delete this.id;
      this._changed = true;
      if (!options.silent) {
        this.trigger('change:' + attr, this, void 0, options);
        this.change(options);
      }
      return this;
    }
303806
function(attrs, first) {
      if (!attrs || !Object.keys(attrs).length) return first ? void 0 : [];
      return this[first ? 'find' : 'filter'](function(model) {
        for (var key in attrs) {
          if (attrs[key] !== model.get(key)) return false;
        }
        return true;
      });
    }