CodeMap.sublime-settings

{
    "close_empty_group_on_closing_map": true,
    "show_in_new_group": true,
    // width percentage of the screen
    "codemap_width": 0.17,

    // some extensions can cause trouble if they aren't defined in advance, or
    // even if you try to define them. Extensions in this list will be ignored.
    "exclusions":   [
                        "json"
                    ],

    // Map depth is remembered per view, so if you change depth in one file,
    // the others will still use the global setting below.
    // Depth doesn't work for custom mappers in User/CodeMap/custom_mappers,
    // unless you make a mapper that supports it by reading this setting.
    "depth": 1,

    ////////////////////////////////////////////////////////////////////
    //                IMPORTANT - READ CAREFULLY                      //
    //                                                                //
    //             Order of preference for mappers is:                //
    //                                                                //
    //    1. defined mappers below, except "universal"                //
    //    2. mappers in User/CodeMap/custom_mappers                   //
    //    3. "universal" mapper (as a fallback)                       //
    //                                                                //
    //                                                                //
    //    If a file extension is defined in "syntaxes" below, it WILL //
    //    override custom mappers. To avoid this, if you want         //
    //    to use a custom mapper for an extension defined there       //
    //    (in "syntaxes"), you must comment out or delete the         //
    //    extension from the "syntaxes" items below.                  //
    //                                                                //
    ////////////////////////////////////////////////////////////////////

    // defined mappers with preferred extension, universal is used as a backup
    // for undefined syntaxes; to use the defined mappers below, they must be
    // present in this list. Don't put anything in this list that isn't
    // defined below.
    "syntaxes":     [
                        ["universal",     ""],
                        ["text",          "txt"],
                        ["Rexx",          "rex"],
                        ["python",        "py"],
                        ["ruby",          "rb"],
                        ["Settings",      "sublime-settings"],
                        ["Syntax",        "sublime-syntax"],
                        ["Ini",           "ini"],
                ],

    ///////////////////////////////////////////////////////////////////
    // For each defined mapper:                                      //
    ///////////////////////////////////////////////////////////////////
    //
    // "regex": patterns to recognize, the inner list has elements:
    //      [0]: what to search in the line
    //      [1]: pattern to strip from [0]
    //      [2]: optional substitution for [1]
    //      [3]: whether the every pattern, in case of multiple patterns will be 
    //           applied on the same original document line or to the result of 
    //           previous regex match/transformation step. 
    //
    // These elements are themselves in a list, because you can define more
    // substitution patterns. So you have a list of patterns to recognize, and
    // each of them has 4 elements. The different match/substitution patterns
    // are evaluated independently, and the longest match is accepted,
    // therefore try not to enter patterns that are very generic together with
    // other that are more specifc. If [3] is true, the regex will be
    // reapplied to the same line, if you need so.
    //
    ////////////////////////////////////////////////////
    // The other elements are:                        //
    ////////////////////////////////////////////////////
    //
    //   "obligatory indent":        lines that aren't indented are ignored
    //   "indent":                   base indent for Code Map view
    //   "empty line in map before": empty line in the Code Map before this
    //                               pattern, after regexes have been applied
    //   "line numbers before":      write numbers at the beginning of the line
    //   "prefix"/"suffix":          applied to each line
    //   "syntax":                   syntax for Code Map

    "universal": {
                "regex":
                [
                    [
                        "^(?!if)\\S+? \\S+?[\\(\\[\\{].*?:",
                        "[\\(\\[\\{].*$",
                        "",
                        false
                    ]
                ],
                "indent": 2,
                "obligatory indent": false,
                "empty line in map before": "class",
                "line numbers before": false,
                "prefix": "",
                "suffix": "",
                "syntax": "Packages/Python/Python.tmLanguage"
            },
    "text": {
                "regex":
                [
                    [
                        "",
                        "",
                        "",
                        false
                    ]
                ],
                "indent": 2,
                "obligatory indent": true,
                "empty line in map before": "",
                "line numbers before": true,
                "prefix": "",
                "suffix": "",
                "syntax": "Packages/Text/Plain text.tmLanguage"
            },
    "python": {
                "regex":
                [
                    [
                        "^(class |def ).*$",
                        "[(:].*$",
                        "",
                        false
                    ]
                ],
                "indent": 4,
                "obligatory indent": false,
                "empty line in map before": "class",
                "line numbers before": false,
                "prefix": "",
                "suffix": "()",
                "syntax": "Packages/Python/Python.tmLanguage"
            },
    "ruby": {
                "regex":
                [
                    [
                        "^(class |def ).*$",
                        "[(:].*$",
                        "",
                        false
                    ]
                ],
                "indent": 2,
                "obligatory indent": false,
                "empty line in map before": "class",
                "line numbers before": false,
                "prefix": "",
                "suffix": "()",
                "syntax": "Packages/Ruby/Ruby.tmLanguage"
            },
    "Settings": {
                "regex":
                [
                    [
                        "^\".+\":",
                        "\"(.+)\":",
                        "\\g<1>:",
                        false
                    ],
                    [
                        ": +true,",
                        "true",
                        "True",
                        true
                    ],
                    [
                        ": +false,",
                        "false",
                        "False",
                        true
                    ],
                    [
                        ": +\\[$",
                        "\\[",
                        "[]",
                        true
                    ],
                    [
                        ": +\\{$",
                        "\\{",
                        "{}",
                        true
                    ],
                ],
                "indent": 0,
                "obligatory indent": false,
                "empty line in map before": "",
                "line numbers before": false,
                "prefix": "",
                "suffix": "",
                "syntax": "Packages/Python/Python.tmLanguage"
            },
    "Syntax": {
                "regex":
                [
                    [
                        "^(contexts:|\\w+:)$",
                        "",
                        "",
                        false
                    ]
                ],
                "indent": 2,
                "obligatory indent": false,
                "empty line in map before": "",
                "line numbers before": false,
                "prefix": "",
                "suffix": "",
                "syntax": "Packages/YAML/YAML.sublime-syntax"
            },
    "Ini": {
                "regex":
                [
                    [
                        "^\\[.*$",
                        "",
                        "",
                        false
                    ]
                ],
                "indent": 0,
                "obligatory indent": false,
                "empty line in map before": "class",
                "line numbers before": false,
                "prefix": "",
                "suffix": "",
                "syntax": "Packages/Text/Plain text.tmLanguage"
            },
      "Rexx"  : {
                "regex":
                [
                    [
                        "^(?!')(\\S+:)\\s.*$",
                        "[(:].*$",
                        "",
                        false
                    ]
                ],
                "indent": 4,
                "obligatory indent": false,
                "empty line in map before": "",
                "line numbers before": false,
                "prefix": "",
                "suffix": "()",
                "syntax": "Packages/Text/Plain text.tmLanguage"
    },

}