Coverage report for lib/src/rule/argument.dart

// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file

// for details. All rights reserved. Use of this source code is governed by a

// BSD-style license that can be found in the LICENSE file.

library dart_style.src.rule.argument;

import '../chunk.dart';

import 'rule.dart';

/// Base class for a rule that handles argument or parameter lists.

abstract class ArgumentRule extends Rule {

  /// The chunks prior to each positional argument.

  final List<Chunk> _arguments = [];

  /// The rule used to split collections in the argument list, if any.

  Rule _collectionRule;

  /// The number of leading collection arguments.

  ///

  /// This and [_trailingCollections] cannot both be positive. If every

  /// argument is a collection, this will be [_arguments.length] and

  /// [_trailingCollections] will be 0.

  final int _leadingCollections;

  /// The number of trailing collections.

  ///

  /// This and [_leadingCollections] cannot both be positive.

  final int _trailingCollections;

  /// If true, then inner rules that are written will force this rule to split.

  ///

  /// Temporarily disabled while writing collection arguments so that they can

  /// be multi-line without forcing the whole argument list to split.

  bool _trackInnerRules = true;

  /// Don't split when an inner collection rule splits.

      this._trailingCollections);

  }

    }

  }

  /// Remembers [chunk] as containing the split that occurs right before an

  /// argument in the list.

  }

  /// Disables tracking inner rules while a collection argument is written.

  }

  /// Re-enables tracking inner rules.

  }

}

/// Rule for handling positional argument lists.

///

/// The number of values is based on the number of arguments and whether or not

/// there are bodies. The first two values are always:

///

/// * 0: Do not split at all.

/// * 1: Split only before the first argument.

///

/// Then there is a value for each argument, to split before that argument.

/// These values work back to front. So, for a two-argument list, value 2 splits

/// after the second argument and value 3 splits after the first.

///

/// Then there is a value that splits before every argument.

///

/// Finally, if there are collection arguments, there is another value that

/// splits before all of the non-collection arguments, but does not split

/// before the collections, so that they can split internally.

class PositionalRule extends ArgumentRule {

  /// If there are named arguments following these positional ones, this will

  /// be their rule.

  Rule _namedArgsRule;

  /// Creates a new rule for a positional argument list.

  ///

  /// If [_collectionRule] is given, it is the rule used to split the collection

  /// arguments in the list.

      Rule collectionRule, int leadingCollections, int trailingCollections)

    // Can split before any one argument or none.

    // If there are multiple arguments, can split before all of them.

    // When there are collection arguments, there are two ways we can split on

    // "all" arguments:

    //

    // - Split on just the non-collection arguments, and force the collection

    //   arguments to split internally.

    // - Split on all of them including the collection arguments, and do not

    //   allow the collection arguments to split internally.

    return result;

  }

  }

    }

  }

    // Split only before the first argument. Keep the entire argument list

    // together on the next line.

    // Split before a single argument. Try later arguments before earlier ones

    // to try to keep as much on the first line as possible.

    }

    // Only split before the non-collection arguments.

      }

      }

      return true;

    }

    // Split before all of the arguments, even the collections.

    return true;

  }

  /// Remembers that [rule] is the [Rule] immediately following this positional

  /// positional argument list.

  ///

  /// This is normally a [NamedRule] but [PositionalRule] is also used for the

  /// property accesses at the beginning of a call chain, in which case this

  /// is just a [SimpleRule].

  }

  /// Constrains the named argument list to at least move to the next line if

  /// there are any splits in the positional arguments. Prevents things like:

  ///

  ///      function(

  ///          argument,

  ///          argument, named: argument);

    if (constrained != null) return constrained;

    // Handle the relationship between the positional and named args.

      // If the positional args are one-per-line, the named args are too.

      // Otherwise, if there is any split in the positional arguments, don't

      // allow the named arguments on the same line as them.

    }

    // Decide how to constrain the collection rule.

    // If all of the collections are in the named arguments, [_collectionRule]

    // will not be null, but we don't have to handle it.

    // If we aren't splitting any args, we can split the collection.

    // Split only before the first argument.

        // We are splitting before a collection, so don't let it split

        // internally.

        return Rule.unsplit;

      } else {

        // The split is outside of the collections so they can split or not.

        return null;

      }

    }

    // Split before a single argument. If it's in the middle of the collection

    // arguments, don't allow them to split.

        return Rule.unsplit;

      }

      return null;

    }

    // Only split before the non-collection arguments. This case only comes into

    // play when we do want to split the collection, so force that here.

    // Split before all of the arguments, even the collections. We'll allow

    // them to split but indent their bodies if they do.

    return null;

  }

}

/// Splitting rule for a list of named arguments or parameters. Its values mean:

///

/// * Do not split at all.

/// * Split only before first argument.

/// * Split before all arguments.

class NamedRule extends ArgumentRule {

      Rule collectionRule, int leadingCollections, int trailingCollections)

    // Move all arguments to the second line as a unit.

    // Otherwise, split before all arguments.

    return true;

  }

    if (constrained != null) return constrained;

    // Decide how to constrain the collection rule.

    // If all of the collections are in the named arguments, [_collectionRule]

    // will not be null, but we don't have to handle it.

    // If we aren't splitting any args, we can split the collection.

    // Split only before the first argument. Don't allow the collections to

    // split.

    // Split before all of the arguments, even the collections. We'll allow

    // them to split but indent their bodies if they do.

    return null;

  }

}