Options are not combined, but executed separately in this order: 1. Disable "all except" via inline comments 2. Disable via inline comments 3. Disable "all except" via settings 4. Disable via settings
548342
function (text, filePath) {

      // ESLint requires a result to be an array of processable text blocks
      var out = [text];

      if (externalProcessor !== null) {
        out = externalProcessor.preprocess(text, filePath);
      }

      // Retrieve settings for current file
      var settings = settingsGetter(filePath);

      // Do nothing if there is no plugins registered
      if (!settings.plugins.length) return out;

      // Reset file options on start
      delete cache[filePath];

      // -----------------------------------------------------------------------
      // 1. Disable "all except" via inline comments
      // -----------------------------------------------------------------------

      var allExceptInlinePlugins = getInlinePlugins(
        text, DISABLE_ALL_EXCEPT_PATTERN, settings.plugins
      );

      if (allExceptInlinePlugins) {

        if (allExceptInlinePlugins.length) {

          // Keep only plugins mentioned inline and disable the rest
          var pluginsToDisable = settings.plugins.filter(function (plugin) {
            return allExceptInlinePlugins.indexOf(plugin) === -1;
          });

          // Only set if there are plugins to disable
          if (pluginsToDisable.length) {
            cache[filePath] = pluginsToDisable;
          }

        } else {
          // Do nothing if no plugins found, it means all plugins are enabled
        }

        // Return the result
        return out;

      } else {
        // Continue to next option if there is no match for this option
      }

      // -----------------------------------------------------------------------
      // 2. Disable via inline comments
      // -----------------------------------------------------------------------

      var inlinePlugins = getInlinePlugins(
        text, DISABLE_PATTERN, settings.plugins
      );

      if (inlinePlugins) {

        // Disable all plugins if no plugins specified
        var pluginsToDisable = inlinePlugins.length
          ? inlinePlugins
          : settings.plugins;

        // Only set if there are plugins to disable
        if (pluginsToDisable.length) {
          cache[filePath] = pluginsToDisable;
        }

        // Return the result
        return out;

      } else {
        // Continue to next option if there is no match for this option
      }

      // -----------------------------------------------------------------------
      // 3. Disable "all except" via settings
      // -----------------------------------------------------------------------

      var settingsAllExceptPlugins = getSettingsPlugins(
        filePath, settings.allExceptPaths, true,
        settings.plugins, settings.pathsOptions
      );

      if (settingsAllExceptPlugins.length) {

        // Keep only plugins matching settings paths and disable the rest
        var pluginsToDisable = settings.plugins.filter(function (plugin) {
          return settingsAllExceptPlugins.indexOf(plugin) === -1;
        });

        // Only set if there are plugins to disable
        if (pluginsToDisable.length) {
          cache[filePath] = pluginsToDisable;
        }

        // Return the result
        return out;

      } else {
        // Continue to next option if there is no match for this option
      }

      // -----------------------------------------------------------------------
      // 4. Disable via settings
      // -----------------------------------------------------------------------

      var settingsPlugins = getSettingsPlugins(
        filePath, settings.paths, false,
        settings.plugins, settings.pathsOptions
      );

      if (settingsPlugins.length) {

        var pluginsToDisable = settingsPlugins;

        // Only set if there are plugins to disable
        if (pluginsToDisable.length) {
          cache[filePath] = pluginsToDisable;
        }

        // Return the result
        return out;

      } else {
        // No options left, proceed to the end
      }

      // ESLint requires a result to be an array of processable text blocks
      return out;
    }
325550
def include_none?(*items)
      items = items.first if items.length == 1 && items.first.kind_of?(Array)
      (self & items).empty?
    end
330450
function checkOptions ( opts ) {
        var isNum, isNumWithUnit;

        if ( opts.direction && !( opts.direction === 'vertical' || opts.direction === 'horizontal' || opts.direction === 'both' ) ) {
            throw new Error( 'Invalid option value: direction = "' + opts.direction + '"' );
        }

        if ( opts.box && !( opts.box === 'border-box' || opts.box === 'content-box' ) ) {
            throw new Error( 'Invalid option value: box = "' + opts.box + '"' );
        }

        if ( opts.tolerance !== undefined ) {
            isNum = isNumber( opts.tolerance );
            isNumWithUnit = isString( opts.tolerance ) && ( /^[+-]?\d*\.?\d+(px|%)?$/.test( opts.tolerance ) );
            if ( ! ( isNum || isNumWithUnit ) ) throw new Error( 'Invalid option value: tolerance = "' + opts.tolerance + '"' );
        }

    }
313297
function toOptions (type, options) {
  if (Types.includes(type)) {
    options = Object.assign({ type: type }, options)
  }
  if (options._validated) {
    delete options._validated
    return options
  }
  if (Object.keys(options).length > 0) {
    options = baseParser._parseDefinition(
      options, { strict: true, userInput: false, _key: 'options' }
    )
  }
  return options
}
189129
def remove_global_options(options, args)
      # TODO: refactor with flipflop, please TJ ! have time to refactor me !
      options.each do |option|
        switches = option[:switches].dup
        next if switches.empty?

        if (switch_has_arg = switches.any? { |s| s =~ /[ =]/ })
          switches.map! { |s| s[0, s.index('=') || s.index(' ') || s.length] }
        end

        switches = expand_optionally_negative_switches(switches)

        past_switch, arg_removed = false, false
        args.delete_if do |arg|
          if switches.any? { |s| s[0, arg.length] == arg }
            arg_removed = !switch_has_arg
            past_switch = true
          elsif past_switch && !arg_removed && arg !~ /^-/
            arg_removed = true
          else
            arg_removed = true
            false
          end
        end
      end
    end
1363574
function normalizeOptions(options, include) {
            _.forEach(options, function (v,k) {
                if(!_.contains(include, k))
                    delete options[k];
            });
            return options;
        }
231619
def fix_config(self, options):
        
        options = super(CombineStorage, self).fix_config(options)

        opt = "format"
        if opt not in options:
            options[opt] = ""
        if opt not in self.help:
            self.help[opt] = "The format to use for generating the combined string; use '@{blah}' for accessing "\
                             "storage item 'blah' (string)."

        return options
77668
def with_options(opts = {}) # :nodoc:
      opts = opts.dup
      opts.delete(:comment)
      @opt_stack.push( @opt_stack.last.merge(opts))
      yield self
      @opt_stack.pop
    end
815974
def uncomment_or_update_or_append_line(filename, prefix, new_line, comment='#',
                                       keep_backup=True,
                                       update_or_append_line=update_or_append_line):
    '''
    '''
    uncommented = update_or_append_line(filename, prefix=comment+prefix,
                                        new_line=new_line,
                                        keep_backup=keep_backup, append=False)
    if not uncommented:
        update_or_append_line(filename, prefix, new_line,
                              keep_backup=keep_backup, append=True)
811644
function removeDuplicateComments(ast) {
    // Some comments are duplicated as both the leadingComment for one node,
    // and the trailing comment for another. Every comment's range is unique,
    // so two comments with the same range are talking about the same comment.
    // So we'll just remove all trailing comments which are also a leading
    // comment somewhere.
    //eslint-disable-next-line no-undef
    const rangesInLeadingComments = new Set();
    estreeWalker.walk(ast, {
        enter: (node) => {
            for (let leadingComment of node.leadingComments || []) {
                rangesInLeadingComments.add(leadingComment.range.join(','));
            }
        }
    });
    estreeWalker.walk(ast, {
        enter: (node) => {
            if (!node.trailingComments) {
                return;
            }
            node.trailingComments = node.trailingComments.filter((comment) => {
                return !rangesInLeadingComments.has(comment.range.join(','));
            });
        }
    });
}
91398
function removeOptions(args, keys) {
    if (!_.isArray(keys)) {
        keys = [ keys ];
    }
    for (var index = 0; index < args.length; index++) {
        var arg = args[index];
        for (var key in arg) {
            if (_.includes(keys, key)) {
                delete arg[key];
            }
        }
    }
}
1072111
public function commentsFilter()
    {
        $post_types = get_post_types();

        foreach ($post_types as &$post_type) {
        	if (post_type_supports($post_type, 'comments')) {
        		$post_type_obj = get_post_type_object($post_type);
        		$post_type = array(
        						'name' => $post_type_obj->name,
        						'label' => $post_type_obj->label
        					);
        	} else {
        		unset($post_types[$post_type]);
        	}
        }

        echo '<select name="post_type"><option value="">' . __('Select post type', 'better-post-ui') . '</option>';
        foreach ($post_types as $post_type) {
            $selected = isset($_GET['post_type']) && $_GET['post_type'] == $post_type['name'] ? 'selected' : '';
            echo '<option value="' . $post_type['name'] . '" ' . $selected . '>' . $post_type['label'] . '</option>';
        }
        echo '</select>';
    }
1123622
function nope(options) {
  options.enabled = false;
  options.modify = modify;
  options.set = set;
  options.use = use;

  return introduce(function diagnopes() {
    return false;
  }, options);
}
471118
private void appendOption(StringBuffer buff, Option option, boolean required)
    {
        if (!required)
        {
            buff.append("[");
        }

        if (option.getOpt() != null)
        {
            buff.append("-").append(option.getOpt());
        }
        else
        {
            buff.append("--").append(option.getLongOpt());
        }
        
        // if the Option has a value and a non blank argname
        if (option.hasArg() && (option.getArgName() == null || option.getArgName().length() != 0))
        {
            buff.append(option.getOpt() == null ? longOptSeparator : " ");
            buff.append("<").append(option.getArgName() != null ? option.getArgName() : getArgName()).append(">");
        }
        
        // if the Option is not a required option
        if (!required)
        {
            buff.append("]");
        }
    }
950093
function getSlidifyOptions( options ) {

		options = options || {};
		options.separator = options.separator || DEFAULT_SLIDE_SEPARATOR;
		options.notesSeparator = options.notesSeparator || DEFAULT_NOTES_SEPARATOR;
		options.attributes = options.attributes || '';

		return options;

	}
630063
def cleanOptions(options):
    
    _reload = options.pop('reload')
    dev = options.pop('dev')
    opts = []
    store_true = [
        '--nocache', '--global_cache', '--quiet', '--loud'
    ]
    store_false = []
    for key, value in options.items():
        key = '--' + key
        if (key in store_true and value) or (key in store_false and not value):
            opts += [key, ]
        elif value:
            opts += [key, str(value)]
    return _reload, opts
969184
function setOptions(newOptions) {
    options = newOptions || {};
    if (typeof options.common === 'string') {
      if (options.common.toLowerCase() === 'first') {
        common = COMMON_FIRST;
      } else if (options.common.toLowerCase() === 'second') {
        common = COMMON_SECOND;
      } else if (options.common.toLowerCase() === 'both') {
        common = COMMON_BOTH;
      } else {
        common = COMMON_NO;
      }
    } else {
      if (options.common === true) {
        common = COMMON_BOTH;
      } else {
        common = COMMON_NO;
      }
    }
    commonFactor = options.commonFactor || commonFactor || 4;

    if (options.widthBottom === undefined) {
      options.widthBottom = widthBottom || 2;
    }
    if (options.widthTop === undefined) {
      options.widthTop = widthTop || 1;
    }
    setTrapezoid(options.widthBottom, options.widthTop);
    setFromTo(options.from || from, options.to || to);
  }