| # suppress inspection "UnusedProperty" for whole file |
| intention.category.groovy=Groovy |
| intention.category.conversions=Groovy/Expression conversions |
| intention.category.closures=Groovy/Closures |
| intention.category.comments=Groovy/Comments |
| intention.category.groovy.style=Groovy/Groovy-style |
| intention.category.control.flow=Groovy/Control Flow |
| intention.category.groovy.declaration=Groovy/Declaration |
| intention.category.groovy.other=Groovy/Other |
| demorgans.law.intention.family.name=DeMorgan's Law |
| demorgans.intention.name1=Replace '\\&\\&' with '||' |
| demorgans.intention.name2=Replace '||' with '\\&\\&' |
| merge.if.and.intention.name=Merge if's |
| merge.if.and.intention.family.name=Merge Nested Ifs To ANDed Condition |
| make.closure.call.explicit.intention.name=Make closure call explicit |
| make.closure.call.explicit.intention.family.name=Make Closure Call Explicit |
| make.closure.call.implicit.intention.name=Make closure call implicit |
| make.closure.call.implicit.intention.family.name=Make Closure Call Implicit |
| convert.closure.arg.to.it.intention.name=Convert closure arg to 'it' |
| convert.closure.arg.to.it.intention.family.name=Convert Closure Arg To 'it' |
| flip.conjunction.intention.family.name=Flip Conjunction Operands |
| flip.comparison.intention.family.name=Flip Comparison Operands |
| negate.comparison.intention.family.name=Negate Comparison |
| expand.boolean.intention.name=Expand boolean use to if-else |
| expand.boolean.intention.family.name=Expand Boolean |
| for.to.each.intention.name=Replace with ".each" |
| for.to.each.intention.family.name=Replace For-In With Each |
| each.to.for.intention.name=Replace with For-In |
| each.to.for.intention.family.name=Replace Each With For-In |
| convert.integer.to.hex.intention.name=Convert to hex |
| convert.integer.to.hex.intention.family.name=Convert To Hexadecimal |
| convert.integer.to.decimal.intention.name=Convert to decimal |
| convert.integer.to.decimal.intention.family.name=Convert To Decimal |
| convert.integer.to.octal.intention.name=Convert to octal |
| convert.integer.to.octal.intention.family.name=Convert To Octal |
| convert.integer.to.binary.intention.name=Convert to binary |
| convert.integer.to.binary.intention.family.name=Convert To Binary |
| flip.comparison.intention.name=Flip ''{0}'' to ''{1}'' |
| negate.comparison.intention.name=Negate ''{0}'' to ''{1}'' |
| flip.smth.intention.name=Flip ''{0}'' |
| merge.else.if.intention.name=Merge else-if |
| merge.else.if.intention.family.name=Merge Else If |
| split.else.if.intention.name=Split else-if |
| split.else.if.intention.family.name=Split Else If |
| split.if.intention.name=Split into 2 if's |
| split.if.intention.family.name=Split into 2 if's |
| invert.if.intention.name=Invert If Condition |
| invert.if.intention.family.name=Invert If Condition |
| replace.ternary.with.if.else.intention.name=Replace ''?:'' with if else |
| replace.ternary.with.if.else.intention.family.name=Replace ''?:'' with if else |
| simplify.ternary.operator.intention.name=Simplify Conditional Expression |
| simplify.ternary.operator.intention.family.name=Simplify Conditional Expression |
| flip.conditional.intention.name=Flip ''?:'' |
| flip.conditional.intention.family.name=Flip Conditional |
| conditional.to.elvis.intention.name=Convert Conditional to Elvis |
| conditional.to.elvis.intention.family.name=Convert Conditional |
| change.to.end.of.line.comment.intention.name=Replace with end-of-line comment |
| change.to.end.of.line.comment.intention.family.name=Replace With End Of Line Comment |
| change.to.c.style.comment.intention.name=Replace with C-style comment |
| change.to.c.style.comment.intention.family.name=Replace With C-Style Comment |
| convert.string.to.g.string.intention.name=Convert to GString |
| convert.string.to.g.string.intention.family.name=Convert String To GString |
| convert.g.string.to.string.intention.name=Convert to String |
| convert.g.string.to.string.intention.family.name=Convert GString To String |
| indexing.method.conversion.intention.name=Convert to [] form |
| indexing.method.conversion.intention.family.name=Convert Indexing Method To [] Form |
| indexed.expression.conversion.intention.name=Convert [] access to method form |
| indexed.expression.conversion.intention.family.name=Convert [] Form To Index Method |
| dynamic.property.dialog.class=&Class\: |
| dynamic.property.dialog.type=&Type of property |
| remove.parentheses.from.method.call.intention.family.name=Remove Unnecessary Parentheses from Method Call |
| remove.parentheses.from.method.call.intention.name=Remove Unnecessary Parentheses |
| java.style.properties.invocation.intention.family.name=Change Java-style accessor invocation to Groovy-style property reference |
| java.style.properties.invocation.intention.name=Change to Groovy-style property reference |
| replace.abstract.class.instance.by.map.intention.family.name=Change anonymous class to dynamic instantiation |
| replace.abstract.class.instance.by.map.intention.name=Change to dynamic instantiation |
| remove.unnecessary.braces.in.g.string.intention.family.name=Remove Unnecessary Braces in GString |
| remove.unnecessary.braces.in.g.string.intention.name=Remove unnecessary braces in GString |
| convert.concatenation.to.gstring.intention.family.name=Convert String Concatenation to GString |
| convert.concatenation.to.gstring.intention.name=Convert to GString |
| convert.closure.to.method.intention.name=Convert to method |
| convert.closure.to.method.intention.family.name=Convert property to method |
| convert.method.to.closure.intention.name=Convert to closure property |
| convert.method.to.closure.intention.family.name=Convert method to property of closure type |
| convert.string.to.multiline.intention.name=Convert to Multiline |
| convert.string.to.multiline.intention.family.name=Convert literal to multiline literal |
| convert.junit.assertion.to.assert.statement.intention.name=Convert JUnit assertion to assert statement |
| convert.junit.assertion.to.assert.statement.intention.family.name=Convert JUnit assertion to assert statement |
| ########################################################################################################### |
| # Convert parameter to map entry refactoring |
| ########################################################################################################### |
| convert.parameter.to.map.entry.intention.family.name=Convert method or closure parameters to map entries |
| convert.parameter.to.map.entry.intention.name=Convert parameter to map entry |
| find.method.ro.closure.usages.0=Searching for usages of enclosing {0} in project files |
| conversion.not.allowed.in.non.groovy.files=Refactoring is not allowed for {0}s which have occurrences in non-Groovy files: |
| wrong.first.parameter.type={0} ''{1}'' is used with named arguments, but its first parameter ''{2}'' does not conform to Map type. |
| create.first.new=&Create new parameter for named arguments |
| do.not.create.first.new=Use &existing first parameter as map for named arguments |
| convert.cannot.itself=Refactoring is not available for map parameter itself |
| perform.refactoring=Performing refactoring |
| map.param.name=Map parameter &name: |
| convert.param.to.map.entry=Convert Parameter to Map Entry |
| |
| convert.java.style.array.intention.name=Convert java-style array creation |
| convert.java.style.array.intention.family.name=Convert Java-Style Array Creation to Groovy Syntax |
| |
| create.parameter.for.field.intention.name = Add constructor parameter for field |
| create.parameter.for.field.intention.family.name = Add constructor parameter for field |
| cannot.suggest.parameter.name=Cannot suggest parameter name |
| create.parameter.for.field=Add parameter for field ''{0}'' |
| create.parameter.for.fields=Add parameter for field... |
| closure.used.as.variable=Closure is passed as argument. Refactoring can break semantic. |
| |
| convert.map.to.class.intention.name=Convert to Class |
| convert.map.to.class.intention.family.name=Convert Groovy native map to class instances |
| do.you.want.to.change.method.return.type=Do you want to change return type of ''{0}'' method |
| do.you.want.to.change.variable.type=Do you want to change type of ''{0}'' |
| |
| closure.is.accessed.outside.of.groovy=Field <b>{0}</b> is accessed outside of Groovy |
| write.access.to.closure.variable=Write access to field <b>{0}</b> |
| field.is.used.in.argument.label=Field <b>{0}</b> is used in argument label |
| method.with.signature.already.exists=Method with signature {0} already exists |
| field.already.exists=Field <b>{0}</b> already exists |
| method.is.used.outside.of.groovy=Method is used outside of Groovy |
| |
| do.you.want.to.change.type.of.parameter.in.method=Do you want to change type of parameter ''{0}'' in method ''{1}'' |
| |
| rename.file.with.class.intention.name=Rename file to class name |
| rename.file.with.class.intention.family.name=Rename file to corresponding class name |
| |
| move.class.to.new.file.intention.name=Move to separate file |
| move.class.to.new.file.intention.family.name=Move class to separate file |
| |
| file.exists=File ''{0}'' already exists in directory ''{1}'' |
| intention.crete.test.groovy=Groovy |
| |
| import.static.intention.name=Add static import |
| import.static.intention.family.name=Add Single-Member Static Import in Groovy |
| import.on.demand.intention.name=Add import on demand |
| import.on.demand.intention.family.name=Add On Demand Static Import in Groovy |
| replace.qualified.reference.with.import.intention.name=Replace with import |
| replace.qualified.reference.with.import.intention.family.name=Replace qualified reference with import |
| move.to.correct.dir.family.name=Move File to Correct Package |
| move.to.correct.dir=Move to ''{0}'' |
| convert.to.geese.braces.intention.name=Format braces in one line |
| convert.to.geese.braces.intention.family.name=Format closing closure braces in one line |
| |
| convert.from.geese.braces.intention.name=Format braces in separate lines |
| convert.from.geese.braces.intention.family.name=Format braces in separate lines |
| remove.unnecessary.semicolons.name=Remove unnecessary semicolons |
| remove.unnecessary.semicolons.family.name=Remove unnecessary semicolons from selected text |
| no.unnecessary.semicolons.found=No unnecessary semicolons found |
| add.return.type=Add return type |
| add.return.type.to.method.declaration=Add return type to method declaration |
| replace.with.wrapper=Replace with {0} |
| replace.primitive.type.with.wrapper=Replace primitive type with wrapper |
| split.into.declaration.and.assignment=Split into declaration and assignment |
| split.into.separate.declaration=Split into separate declaration |
| gr.split.declaration.intention.family.name=Split Variable Declaration |
| remove.parameter.0=Remove parameter ''{0}'' |
| remove.unused.parameter=Remove unused parameter |
| remove.exception=Remove exception |
| remove.catch.block=Remove catch block |
| try.catch.fix=Try-catch fix |
| gr.convert.string.to.char.intention.name=Cast to char |
| gr.convert.string.to.char.intention.family.name=Cast to char |
| create.field.for.parameter.0 = Create Field for Parameter {0} |
| create.field.for.parameter=Create Field for Parameter |
| gr.set.strong.type.intention.name=Declare explicit type |
| gr.set.strong.type.intention.family.name=Declare explicit type |
| remove.unnecessary.escape.characters.intention.name=Remove unnecessary escape characters |
| remove.unnecessary.escape.characters.intention.family.name=Remove unnecessary escape characters |
| gr.break.string.on.line.breaks.intention.name=Break string on '\\n' |
| gr.break.string.on.line.breaks.intention.family.name=Break string on '\\n' |
| gr.create.missing.switch.branches.intention.name=Create missing 'switch' branches |
| gr.create.missing.switch.branches.intention.family.name=Create missing 'switch' branches |
| remove.redundant.class.property.intention.name=Remove redundant .class |
| remove.redundant.class.property.intention.family.name=Remove redundant .class |
| convert.simple.getter.to.property.intention.name=Convert to property |
| convert.simple.getter.to.property.intention.family.name=Convert simple getter to property |
| remove.unnecessary.return.intention.name=Remove 'return' keyword |
| remove.unnecessary.return.intention.family.name=Remove unnecessary 'return' keyword |
| gr.alias.import.intention.name=Alias import |
| gr.alias.import.intention.family.name=Alias import statically imported member |
| gr.copy.string.concatenation.content.intention.name=Copy string concatenation text to clipboard |
| gr.copy.string.concatenation.content.intention.family.name=Copy string concatenation text to clipboard |
| gr.make.member.private.intention.name=Make 'private' |
| gr.make.member.private.intention.family.name=Make 'private' |
| gr.make.member.public.intention.name=Make 'public' |
| gr.make.member.public.intention.family.name=Make 'public' |
| gr.make.member.protected.intention.name=Make 'protected' |
| gr.make.member.protected.intention.family.name=Make 'protected' |
| convert.multiline.string.to.single.line.intention.name=Convert to Singleline Literal |
| convert.multiline.string.to.single.line.intention.family.name=Convert multiline string to single-line |
| gr.convert.type.cast.to.safe.cast.intention.name=Convert to safe cast |
| gr.convert.type.cast.to.safe.cast.intention.family.name=Convert cast expression to safe cast expression |
| cannot.create.class=Cannot create class |
| gr.introduce.local.variable.intention.name=Introduce local variable |
| gr.introduce.local.variable.intention.family.name=Groovy Introduce local variable |
| flip.if.intention.name=Flip if statements |
| flip.if.intention.family.name=Flip if statements |
| replace.if.with.ternary.intention.name=Replace with ?: |
| replace.if.with.ternary.intention.family.name=Replace if-statement with ternary operator |
| gr.redundant.else.intention.name=Remove redundant 'else' keyword |
| gr.redundant.else.intention.family.name=Remove redundant 'else' keyword |
| convert.to.regex.intention.name=Convert to Regular Expression |
| convert.to.regex.intention.family.name=Convert string literal to regular expression |
| convert.to.dollar.slash.regex.intention.name=Convert to Dollar-Slashy String |
| convert.to.dollar.slash.regex.intention.family.name=Convert string literal to dollar-slashy string |
| gr.remove.explicit.type.declaration.intention.name=Remove explicit type |
| gr.remove.explicit.type.declaration.intention.family.name=Remove explicit type declaration |
| rename.file.to.0=Rename file to ''{0}'' |
| gr.sort.map.keys.intention.name=Sort alphabetically |
| gr.sort.map.keys.intention.family.name=Sort map entries alphabetically |
| gr.remove.annotation.intention.name=Remove |
| gr.remove.annotation.intention.family.name=Remove annotation |
