object-curly-spacing node type changes [$10]

[jonathanKingston]

It appears common place to have object definitions as without spaces but import statements with spaces:

import { x } from y;

and

var me  = {x: 12};

So I suggest adding in the following properties to this rule to allow granular control:

            "ObjectPattern": {
                "enum": ["always", "never"]
            },
            "ObjectExpression": {
                "enum": ["always", "never"]
            },
            "ImportDeclaration": {
                "enum": ["always", "never"]
            },
            "ExportNamedDeclaration": {
                "enum": ["always", "never"]
            }

This would change the first option to be a default to those specific options. If they are not set, it will default to the first option.

There is a $10 open bounty on this issue. Add to the bounty at Bountysource.

[eslintbot]

Thanks for the issue! If you're reporting a bug, please be sure to include:

1. The version of ESLint you are using (run eslint -v)
2. What you did (the source code and ESLint configuration)
3. The actual ESLint output complete with numbers
4. What you expected to happen instead

Requesting a new rule? Please see Proposing a New Rule for instructions.

[nzakas]

Sounds good. Are you interested in working on this?

[jonathanKingston]

@nzakas already mostly complete 😃 will commit soon.

[gyandeeps]

@jonathanKingston Are you still working on this (Just checking)?

[isnifer]

Hey @jonathanKingston I saw you did it. Do you plan to create PR for this feature?

[anyong]

Any progress on this one?

[kaicataldo]

I started in on this one - something I'm not sure of is what to do with the current exception options. From the rule docs:

These exceptions work in the context of the first option. That is, if "always" is set to enforce spacing and an exception is set to false, it will disallow spacing for cases matching the exception. Likewise, if "never" is set to disallow spacing and an exception is set to true, it will enforce spacing for cases matching the exception.

If we're specifying different values of "always" and "never", how should these options behave? We can't apply the same logic to each node type if they're set to different values (i.e. "objectsInObjects": false, would behave differently on the node types depending on their value). Does this mean we have to replicate the exception rules for each specific node type as well (although I guess not for ImportDeclarations)? Although obviously doable, the configuration for this rule might get a little crazy if we implement these changes.

I think the JSON Schema would like something like this (apologies if it's not quite right - still learning this stuff):

module.exports.schema = [
    {
        oneOf: [
            {
                {
                    enum: ["always", "never"]
                },
                {
                    type: "object",
                    properties: {
                        arraysInObjects: {
                            type: "boolean"
                        },
                        objectsInObjects: {
                            type: "boolean"
                        }
                    },
                    additionalProperties: false
                }
            },
            {
                type: "object",
                properties: {
                    ObjectPattern: {
                        enum: ["always", "never"],
                    {
                        type: "object",
                        properties: {
                            arraysInObjects: {
                                type: "boolean"
                            },
                            objectsInObjects: {
                                type: "boolean"
                            }
                        }
                        additionalProperties: false
                    },
                    ObjectExpression: {
                        enum: ["always", "never"], 
                        {
                            type: "object",
                            properties: {
                                arraysInObjects: {
                                    type: "boolean"
                                },
                                objectsInObjects: {
                                    type: "boolean"
                                }
                            },
                            additionalProperties: false
                        }
                    },
                    ImportDeclaration: {
                        enum: ["always", "never"]
                    },
                    ExportNamedDeclaration: {
                        enum: ["always", "never"],
                         {
                            type: "object",
                            properties: {
                                arraysInObjects: {
                                    type: "boolean"
                                },
                                objectsInObjects: {
                                    type: "boolean"
                                }
                            },
                            additionalProperties: false
                        }
                    }
                },
                additionalProperties: false
            }
        ]
    }
];

[gyandeeps]

Is this issue resolved with #6223 ?
CC: @mysticatea

[mysticatea]

No, I just referenced this issue from #6223.

[kaicataldo]

In that case, thoughts on my last comment? Not sure where to go from here

[kaicataldo]

Closing this issue as it has been open for more than 90 days and doesn't have anyone from the team or the community working on it.