Nutritious Pumpkin Meal

    eslint-plugin-budapestian

    5.0.1 • Public • Published

    eslint-plugin-budapestian

    This plugin supports a bastard variant of Hungarian notation where we write elements in PascalCase and prefix them with a scope:

    • p for parameters
    • l for local variables and constants
    • g for global variables
    • For global constants we use the C convention of ALL_CAPS_SNAKE_CASE.

    This plugin not only supports these rules, it can automatically fix them.

    Why budapestian notation?

    It removes mental stress

    You no longer have to think how to name a local variable with the same meaning as a parameter in the function it occurs in:

    const SOME_GLOBAL_CONST = 3;
    
    function doThingsWithThing(pThing, pCount = SOME_GLOBAL_CONST) {
      let lThing = pThing || "";
    
      return lThing.repeat(pCount);
    }

    If you need to pass something that's also a keyword, you don't have to fret. Pascal case it and slap a prefix in front of it.

    function calculateYield(pLet) {
      // calculate the yield of the let
    }
    
    let gYield = calculateYield(pLet);

    It enhances visual grepping.

    In the next snippet you don't have to scroll up to see that BUFFER_LIMIT is some global constant defined up there. You also see that pString must be a parameter of the current function, and lResult is a local variable.

    {
      //...
      if (pString.length <= BUFFER_LIMIT) {
        lResult = pString;
      } else {
        lResult = "you so big";
      }
      // ..
    }

    It makes some bugs easier to spot

    Budapestian notation avoids variable shadowing. E.g. compare these two snippets, the first one without budapestian notation:

    let index = 3;
    const hipster_array = ["beard", "grammophone", "transistor"];
    // here index is the global variable
    
    function doThing(index) {
      // here 'index' is the parameter, shadowning the global
      for (let index of hipster_array) {
        // here 'index' is the local variable, shadowing the parameter
        // and the global
      }
    }

    and this with budapestian notation:

    let gIndex = 3;
    const HIPSTER_ARRAY = ["beard", "grammophone", "transistor"];
    // here gIndex is the global variable
    
    function doThing(pIndex) {
      // here 'pIndex' is the parameter
      for (let lIndex of HIPSTER_ARRAY) {
        // here 'lIndex' is the local variable
      }
    }

    So, should I use this?

    I use this convention on all my open source projects. This plugin exists primarily to support that. It keeps the code consistent, and it makes it easy for contributors (including myself) to use the convention.

    Installation

    You'll first need to install ESLint:

    $ npm i eslint --save-dev
    

    Next, install eslint-plugin-budapestian:

    $ npm install eslint-plugin-budapestian --save-dev
    

    Note: If you installed ESLint globally (using the -g flag) then you must also install eslint-plugin-budapestian globally.

    Usage

    With the 'recommended' preset

    To use the plugin and the recommended rules for budapestian notation, add plugins:budapestian/recommended to the extends section of your .eslintrc:

    {
      "extends": ["plugin:budapestian/recommended"]
    }

    Manually

    Add budapestian to the plugins section of your .eslintrc configuration file. You can omit the eslint-plugin- prefix:

    {
      "plugins": ["budapestian"]
    }

    Then configure the rules you want to use under the rules section.

    {
      "rules": {
        "budapestian/parameter-pattern": "error",
        "budapestian/global-variable-pattern": "error",
        "budapestian/local-variable-pattern": [
          "error",
          { "exceptions": ["i", "j", "k", "x", "y", "z"] }
        ],
        "budapestian/global-constant-pattern": "error"
      }
    }

    Supported Rules

    auto fixable? rule description
    yes budapestian/parameter-pattern pascal case function parameters and make them start with a p
    yes budapestian/global-variable-pattern pascal case global variables and make them start with a g
    yes budapestian/local-variable-pattern pascal case local variables and make them start with an l
    yes no budapestian/global-constant-pattern makes sure global constants are in snaked upper case.

    Flare'n status section

    linting & test coverage - linux npm stable version MIT licensed

    Install

    npm i eslint-plugin-budapestian

    DownloadsWeekly Downloads

    125

    Version

    5.0.1

    License

    MIT

    Unpacked Size

    24.1 kB

    Total Files

    11

    Last publish

    Collaborators

    • sverweij
    • foureightone