diff --git a/.gitattributes b/.gitattributes deleted file mode 100644 index dfe07704..00000000 --- a/.gitattributes +++ /dev/null @@ -1,2 +0,0 @@ -# Auto detect text files and perform LF normalization -* text=auto diff --git a/.gitignore b/.gitignore index 130f7e96..a83e773d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,23 +1,10 @@ -# See https://help.github.com/ignore-files/ for more about ignoring files. +*.DS_Store -# dependencies -/node_modules +/.idea/ +*.iml +/out/ +/build/ -# testing -/coverage - -# production -/build - -# misc -.DS_Store -.env.local -.env.development.local -.env.test.local -.env.production.local - -npm-debug.log* -yarn-debug.log* -yarn-error.log* - -package-lock.json \ No newline at end of file +.gradle/ +gradle.properties +/.sandbox/ diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index e7e3f9ad..00000000 --- a/Dockerfile +++ /dev/null @@ -1,17 +0,0 @@ -# build environment -FROM node:9.6.1 as builder -RUN mkdir -p /usr/src/app -WORKDIR /usr/src/app -ENV PATH /usr/src/app/node_modules/.bin:$PATH -COPY package.json /usr/src/app/package.json -RUN npm install --silent -RUN npm install react-scripts@1.1.1 -g --silent -COPY . /usr/src/app -RUN npm run build - - -# production environment -FROM nginx:1.13.9-alpine -COPY --from=builder /usr/src/app/build /usr/share/nginx/html -EXPOSE 80 -CMD ["nginx", "-g", "daemon off;"] diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 6ce4e73d..00000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2018 Jungwon Seo - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 00000000..e06d2081 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,202 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/README.md b/README.md index 2fae463b..401d3ccf 100644 --- a/README.md +++ b/README.md @@ -1,64 +1,351 @@ -# Simple React +# Custom Postfix Templates for Intellij IDEA -Sample React.js application for the Docker environment. +**Custom Postfix Templates** is an Intellij IDEA plugin that allows you to define your own custom [postfix completion templates](https://blog.jetbrains.com/idea/2014/03/postfix-completion/). +At the moment it supports the following programming languages with : Java, Scala, SQL, PHP, Go, Groovy, Python, LaTeX, Kotlin (untyped templates), Dart (untyped templates), JavaScript (untyped templates), and Rust (untyped templates). -## Getting Started -![Screen Shopt](images/screenshot.png?raw=true "Screen Shot") -App with one container. Reading from external open API. No storage. No secrets. Dynamic web page - including information from external API. +## So what is the difference to IDEA's postfix templates? -### Prerequisites +Since IDEA 2018 you are now able to define your own postfix templates in the settings UI (*Editor → General → Postfix Templates*). However, this is a pretty new feature and it's less functional than this plugin. Here are some of the **advantages of this plugin**: -Make sure you have already installed Docker Engine. -You don’t need to install Nginx or NPM, as both are provided by Docker images. +* You can **define different template rules for the same template name**, e.g. .toList should behave differently for arrays and for sets. +* You can **use template variables** (e.g. `$varName$`) which are filled by the user while applying the template. +* You can **use live template macros** to automatically fill some of the template variables (e.g. `$var:suggestVariableName()$`) as well as you can define default values. +* You can **restrict the availability of templates or template rules to the availability of certain classes or libraries** (e.g. expand `"test".val` to `val s = "test"` if Lombok is available). +* It allows you to **use static imports instead of class imports** (e.g. `array.toList` can be expanded to `asList(array)` instead of `Arrays.asList(array)` if you add `[USE_STATIC_IMPORTS]` to the rule). +* It **comes with more than 500 editable postfix templates** with more than 700 template rules, e.g. + * `string.toInt` → `Integer.parse(string)` + * `array.toList` → `Arrays.asList(array)` + * `file.lines` → `Files.readAllLines(file.toPath(), Charset.forName("UTF-8"))` + * `file.getName().val` → `final String name = file.getName();` +* The text based format for defining your templates allows you to **easily share** them via copy and paste. -``` -$ docker -v -Docker version 18.03.1-ce, build 9ee9f40 -``` +## Screencast + +![Screen Cast](https://github.com/xylo/intellij-postfix-templates/blob/master/videos/vid1/vid1.png) + +## Download + +You can download the plugin **Custom Postfix Templates** via *Settings → Plugins → Browse Repositories*. + +## Usage + +The plugin comes with a predefined set of templates for Java and Scala (see below) which can be immediatly applied in Java/Scala files. +For instance, write + + "1".toInt + +in a Java file. If the completion popup does not automatically show up, press *Ctrl+SPACE*. +Select the `.toInt` template and see how it is expanded. + +And if you want to see the template definition, just press *Alt+ENTER* in the completiion popup and select *Edit '.toInt' template*. + +## Kinds of template files + +There are three different types of template files: +* User template files: use them to define your own templates and/or override local or web template rules +* Local template files: loaded from the local file system, read-only, and updated automatically when an IDEA project is opened +* Web template files: loaded from the web, read-only, and updated automatically once a day +## Order of template files/rules -### Installing +Template rules are applied in a first-come-first-serve manner, i.e., more specific rules/files should be placed above more general rules/files. +Reorder files in the tree by selecting them and by using the up/down buttons. +## Predefined web templates files + +The plugin comes with a set of so-called "web template files" which provide in total [more than 200 useful templates](https://github.com/xylo/intellij-postfix-templates/wiki). +While web template files are read-only and shall not be edited by the user because of automatic updates, you can still edit or deactivate templates of these files. + +To change or deactivate a predefined template you just have to start the template name completion with *Ctrl+Space* and then press *ALT+Enter* and select the third item (*Edit .TEMPLATE_NAME template*). The corresponding web template file is opened and you see the definition of the template rule. Since you cannot this template file directly you have to override the template rule by pressing *Alt+Enter* and selecting *Override template rule*. This overriding works in a way that your template rule needs to be loaded before the predefined template gets loaded. This is done by adding your rule to a user template file which is placed above the predefined web template file in the plugin settings. In case that you don't have a user template file which is loaded before, you are offered to create one. After you selected an existing user template or created a new one the template rule to override is automatically added to this file and you can start adapting it. To deactivate a template rule, replace the rigth side of the rule with *[SKIP]*. + +## Edit the templates + +Press *Shift+Alt+P* (or go to menu *Tools → Custom Postfix Templates → Edit Templates of Current Language*) +to open the custom postfix templates for the programming language in your current editor. +Here you can easily change, remove, or add new templates matching your needs. +Note that you have to save the template file explicitly (via *Ctrl+S*) in order to update the postfix templates in the IDE. + +### Template definitions + +The file may contain multiple template definitions of the form: ``` -git clone https://github.com/thejungwon/docker-reactjs.git -cd docker-reactjs -docker build -t docker-reactjs . -docker run -p 80:80 docker-reactjs +.TEMPLATE_NAME : TEMPLATE_DESCRIPTION + TEMPLATE_RULE1 + TEMPLATE_RULE2 + ... +``` +Each template definition consists of a template name, a template description and an arbitrary number of template rules. The template name is used as key in the code completion and the template description is shown as hint in the code completion popup. The template rules define on which types the template can be applied and how the application is performed. + +### Simple template rules +A simple template rule has the form +``` + MATCHING_TYPE → TEMPLATE_CODE ``` -Go to [http://localhost](http://localhost) +whereas +* *[`MATCHING_TYPE`](#matching_type)* defines the type the template can be applied to, and +* *[`TEMPLATE_CODE`](#template_code)* defines how the template is applied (how the expression is replaced). + +#### MATCHING_TYPE + +The options for *MATCHING_TYPE* may differ from programming language to programming language: +* In **Java** the *MATCHING_TYPE* can be either a Java class name or one of the following special types: + * `ANY` - any expression + * `VOID` - any void expression + * `NON_VOID` - any non-void expression + * `ARRAY` - any Java array + * `BOOLEAN` - boxed or unboxed boolean expressions + * `ITERABLE_OR_ARRAY` - any iterable or array + * `NOT_PRIMITIVE` - any non-primitive value + * `NUMBER` - any boxed or unboxed number + * `BYTE` - a boxed or unboxed byte value + * `SHORT` - a boxed or unboxed short value + * `CHAR` - a boxed or unboxed char value + * `INT` - a boxed or unboxed int value + * `LONG` - a boxed or unboxed long value + * `FLOAT` - a boxed or unboxed float value + * `DOUBLE` - a boxed or unboxed double value + * `NUMBER_LITERAL` - any number literal + * `BYTE_LITERAL` - a byte literal + * `SHORT_LITERAL` - a short literal + * `CHAR_LITERAL` - a char literal + * `INT_LITERAL` - an int literal + * `LONG_LITERAL` - a long literal + * `FLOAT_LITERAL` - a float literal + * `DOUBLE_LITERAL` - a double literal + * `STRING_LITERAL` - a String literal + * `CLASS` - any class reference +* In **Scala** the *MATCHING_TYPE* can be either a Java class name or one of the following special types: + * `ANY` - any expression + * `VOID` - any void (Unit) expression + * `NON_VOID` - any non-void (non-Unit) expression + * `BOOLEAN` - scala.Boolean or java.lang.Boolean + * `NUMBER` - any Scala or Java number value + * `BYTE` - scala.Byte or java.lang.Byte + * `SHORT` - scala.Short or java.lang.Short + * `CHAR` - scala.Char or java.lang.Char + * `INT` - scala.Int or java.lang.Integer + * `LONG` - scala.Long or java.lang.Long + * `FLOAT` - scala.Float or java.lang.Float + * `DOUBLE` - scala.Double or java.lang.Double +* In **SQL** the *MATCHING_TYPE* can be either a Java class name or one of the following special types: + * `ANY` - any expression + * `UNKNOWN` - unknown expression + * `DEFAULT` - ? + * `INTEGER` - integer expression + * `REAL` - real expression + * `STRING` - string expression + * `BOOLEAN` - boolean expression + * `DATE_TIME` - date-time expression + * `DATE` - date expression + * `TIME` - time expression + * `TIMESTAMP` - timestamp expression + * `INTERVAL` - interval expression + * `BYTES` - bytes expression + * `REFERENCE` - ? + * `ARRAY` - array expression + * `COLLECTION` - collection expression + * `TABLE` - table reference + * `RECORD` - ? + * `SETO` - ? +* In **PHP** the *MATCHING_TYPE* can be either a PHP class name or one of the following special types: + * `ANY` - any expression + * `empty` + * `null` + * `string` + * `boolean` + * `int` + * `float` + * `object` + * `callable` + * `resource` + * `array` + * `iterable` + * `number` + * `void` + * `unset` + * `static` + * `\Closure` + * `\Exception` + * `\Throwable` +* In **Go** the *MATCHING_TYPE* can be one of the following special types: + * `ANY` - any expression + * `ARRAY` - any array + * `BOOLEAN` - any boolean expression + * `STRING` - any string expression + * `INT` - any integer expression + * `INT64` - any 64 bit integer expression + * `UINT` - any unsigned integer expression + * `FLOAT` - any floating point expression + * `FLOAT32` - any 32 bit floating point expression + * `FLOAT64` - any 64 bit floating point expression + * `BYTESLICE` - any byte slice expression + * `ERROR` - any error expression + * `COMPLEX` - ??? + * `NIL` - any expression of type Nil +* In **Groovy** the *MATCHING_TYPE* can be either a Java/Groovy class name or one of the following special types: + * `ANY` - any expression + * `ARRAY` - any Java array + * `BOOLEAN` - boxed or unboxed boolean expressions + * `ITERABLE_OR_ARRAY` - any iterable or array + * `NUMBER` - any boxed or unboxed number + * `BYTE` - a boxed or unboxed byte value + * `SHORT` - a boxed or unboxed short value + * `CHAR` - a boxed or unboxed char value + * `INT` - a boxed or unboxed int value + * `LONG` - a boxed or unboxed long value + * `FLOAT` - a boxed or unboxed float value + * `DOUBLE` - a boxed or unboxed double value + * `CLASS` - any class reference +* In **Python** the *MATCHING_TYPE* can be one of the following special types: + * `ANY` - any expression + * `object` + * `list` + * `dict` + * `set` + * `tuple` + * `int` + * `float` + * `complex` + * `str` + * `unicode` + * `bytes` + * `bool` + * `classmethod` + * `staticmethod` + * `type` +* In **Kotlin** the *MATCHING_TYPE* has to be `ANY`. +* In **Dart** the *MATCHING_TYPE* has to be `ANY`. +* In **JavaScript** the *MATCHING_TYPE* has to be `ANY`. +* In **Rust** the *MATCHING_TYPE* has to be `ANY` +* In **Latex** the *MATCHING_TYPE* can be one of the following types: + * `ANY` - any expression in any context + * `TEXT` - any expression that is *not* within a math environment + * `MATH` - any expression that *is* within a math environment -## Running the tests +#### TEMPLATE_CODE -TBD +The *TEMPLATE_CODE* can be any text which may also contain template variables used as placeholder. +* Simple template variables have the format `$NAME$`. +* The following template variables have a special meaning: + * `$expr$` - the expression the template shall be applied to + * `$END$` - the final cursor position after the template application +* All other variables will be replaced interactively during the template expansion. +* If you want to change the order of variables, set default values or use live template macros for filling the variables automatically, you can use the following variable format: + ``` + $NAME#NO:EXPRESSION:DEFAULT_VALUE$ + ``` + * *NAME* - name of the variable; use a `*` at the end of the name to skip user interaction + * *NO* (optional) - number of the variable (defining in which order the variables are expanded) + * *EXPRESSION* (optional) - a live template macro used to generate a replacement (e.g. `suggestVariableName()`) + * *DEFAULT_VALUE* (optional) - a default value that may be used by the macro +* If you want to create multi-line templates you can use a backslash (`\`) at the end of a line to indicate that the template code continues at the next line. -### Break down into end to end tests +#### Template Examples -TBD +* Artificial example showing variable reordering, variable reusage, interaction skipping, macros, and default values: + ``` + .test : test + NON_VOID → "$user*#1:user()$: $second#3:className()$ + $first#2::"1st"$ + $first$" + $expr$ + ``` +* Real world example: Write a variable to the debug log, including the developer name, the class name, and method name: + ``` + .logd : log a variable + NON_VOID → Log.d("$user*:user():"MyTag"$", "$className*:className()$ :: $methodName*:methodName()$): $expr$="+$expr$); + ``` +* Multi-line template: + ``` + .for : iterate over ... + ITERABLE_OR_ARRAY → for ($ELEMENT_TYPE:iterableComponentType(expr):"java.lang.Object"$ $VAR:suggestVariableName()$ : $expr$) {\ + $END$\ + } + ``` -### And coding style tests +While writing the templates you can use the code completion for completing class names, variable names, template macros and arrows (→). -TBD +### Advanced template rules +In the chapter above some options have been omitted for simplicity. If you need more functionality here is the full format of template rules including two optional parameters: +``` + MATCHING_TYPE [REQUIRED_CLASS] → TEMPLATE_CODE [FLAG] +``` +* *REQUIRED_CLASS* (optional) is a name of a class that needs to be available in the module to activate the template rule (see next section for a detailed explaination) +* *FLAG* (optional) can be one of the following flags: + * [`SKIP`](#skip) - skips the rule + * [`USE_STATIC_IMPORTS`](#use_static_imports) - adds static method imports automatically if possible (Java only) + * [`IMPORT` ...](#import) - adds an import to the file header (Scala only) + +#### Writing library specific template rules via REQUIRED_CLASS + +Sometimes you may want to write library specific template rules, i.e. rules that shall be only applied when a certain library is included in the project. For instance, take a look at the `.val` template provided with this plugin: +``` +.val : extract as value + NON_VOID [lombok.val] → val $var:suggestVariableName()$ = $expr$; + NON_VOID → final $type*:expressionType(expr))$ $var:suggestVariableName()$ = $expr$; +``` +It can be applied to any non-void expression and expands either to +``` +val myVar = myExpression; +``` +if lombok is available, or to +``` +final MyType myVar = myExpression; +``` +if you're using Java without lombok. + +In this exmaple template the `[lombok.val]` part after the matching type is used to restrict the rule appliction to those cases where the class `lombok.val` is available in the class path. -## Built With +In general you can use any class name between the square brackets you want to define a restriction on. -* [Nginx](https://nginx.org/en/) - Web server -* [React.js](https://reactjs.org/) - The front-end framework used -* [Docker](https://www.docker.com/) - Containerization -* [Materialize](https://materializecss.com/) - Front-end framework +#### FLAGs +##### SKIP -## Authors +You can use the `[SKIP]` flag for deactivating the template rule for a given matching type. -* **Jungwon Seo** - *Initial work* - [thejungwon](https://github.com/thejungwon) +Example: +``` +.sort : sort naturally + de.endrullis.lazyseq.LazySeq → [SKIP] + java.util.List → java.util.Collections.sort($expr$) +``` + +In this example a postfix template `.sort` is defined. +The first rule tells the plugin that there shall be no completition for expressions of type `LazySeq`. +The second rule defines how `List` expressions shall be completed. +##### USE_STATIC_IMPORTS -## License +If you tag a template rule for Java with `[USE_STATIC_IMPORTS]` all static methods that are used will be automatically imported and your code gets more compact. For instance, lets take the following template rule: +``` +.toList : convert to List + ARRAY → java.util.Arrays.asList($expr$) [USE_STATIC_IMPORTS] +``` +Since the rule is tagged with `[USE_STATIC_IMPORTS]` expanding of `array.toList` does not lead to `Arrays.asList(array)` but to `asList(array)` and the following line is added to your import statements: +``` +import static java.util.Arrays.asList; +``` + +##### IMPORT + +If you tag a template rule for Scala with `[IMPORT FULLY_QUALIFIED_CLASSNAME]` the given class (or method) import is automatically added to the file header when the template gets applied: +``` +.printStream : get PrintStream + java.io.File → new PrintStream($expr$) [IMPORT java.io.PrintStream] +``` +Note that you can use the `IMPORT` flag multiple times. -This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details +## Update templates and open plugin settings +Go to *Settings → Editor → Custom Postfix Templates* or *Tools → Custom Postfix Templates → Open Settings / Upgrade Templates*. There you can chose between two different lambda styles and check/uncheck the template files you want to enable/disable. +## Contribute +Any contributions are welcome. Just fork the project, make your changes and create a pull request. +Here are some guides: +* [Create a template file for a utility class/library](https://github.com/xylo/intellij-postfix-templates/wiki/Create-a-template-file-for-a-utility-class-library) +* [Add new language support](https://github.com/xylo/intellij-postfix-templates/wiki/Add-new-language-support) +# See also +* [Feature request for custom postfix completion at jetbrains.com](https://youtrack.jetbrains.com/issue/IDEA-122443) diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 00000000..49ea8ab1 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,125 @@ +plugins { + // Java support + id("java") + // Kotlin support + //id("org.jetbrains.kotlin.jvm") version "1.7.10" + // Gradle Changelog Plugin + //id("org.jetbrains.changelog") version "1.3.1" + // Gradle Qodana Plugin + id("org.jetbrains.qodana") version "0.1.13" + // Gradle IntelliJ Plugin + id("org.jetbrains.intellij") version "1.14.2" + kotlin("jvm") version "1.9.10" +} + +group = "com.intellij" +version = "2.20.2.241" + +tasks.withType { + sourceCompatibility = "17" + targetCompatibility = "17" + options.encoding = "UTF-8" +} + +repositories { + mavenCentral() +} + + +dependencies { + implementation("commons-io:commons-io:2.11.0") + implementation("org.apache.commons:commons-lang3:3.13.0") + implementation("com.fasterxml.jackson.core:jackson-core:2.15.1") + implementation("com.fasterxml.jackson.core:jackson-databind:2.15.1") + implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.15.1") + implementation("io.sentry:sentry:6.9.0") { + exclude("org.slf4j") + } + // https://mvnrepository.com/artifact/org.projectlombok/lombok + + compileOnly("org.projectlombok:lombok:1.18.26") + annotationProcessor("org.projectlombok:lombok:1.18.26") + + testCompileOnly("org.projectlombok:lombok:1.18.26") + testAnnotationProcessor("org.projectlombok:lombok:1.18.26") + + testImplementation("junit:junit:4.13.2") + //implementation(kotlin("stdlib-jdk8")) +} + + + + +sourceSets { + main { + java.srcDirs("src", "gen") + resources.srcDir("resources") + } + + test { + java.srcDir("test/src") + resources.srcDir("test/resources") + } + +} + + +intellij { + // full list of IntelliJ IDEA releases at https://www.jetbrains.com/intellij-repository/releases + // full list of IntelliJ IDEA EAP releases at https://www.jetbrains.com/intellij-repository/snapshots + //version "IU-233.11799.6-EAP-SNAPSHOT" + type.set("IU") + //version.set("241.14024.14-EAP-SNAPSHOT") + version.set("241.14494.240") + + plugins.set( + listOf( + "java", + "Pythonid:241.14494.240", + "Kotlin", + "org.intellij.scala:2024.1.7", + "JavaScript", + //"CSS", + "Dart:241.15845", + "Groovy", + "properties", + "org.jetbrains.plugins.ruby:241.14494.240", + "com.jetbrains.php:241.14494.240", + "java-i18n", + "DatabaseTools", + "org.toml.lang", + "org.jetbrains.plugins.go:241.14494.240", + "nl.rubensten.texifyidea:0.9.4" + ) + ) + updateSinceUntilBuild.set(true) +} + +tasks { + // Avoid ClassNotFoundException: com.maddyhome.idea.copyright.psi.UpdateCopyrightsProvider + buildSearchableOptions { + // jvmArgs = ["-Djava.system.class.loader=com.intellij.util.lang.PathClassLoader"] + enabled = false + } + + runPluginVerifier { + //ideVersions.set(listOf(intellij.type.get() + "-" + intellij.version.get())) + //ideVersions("IU-222.3345.118") + //setFailureLevel(RunPluginVerifierTask.FailureLevel.ALL) + } + + publishPlugin { + token.set(System.getenv("ORG_GRADLE_PROJECT_intellijPublishToken")) + } +} +/* +kotlin { + jvmToolchain(20) +} + */ +tasks.compileKotlin { + kotlinOptions { + jvmTarget = "17" + freeCompilerArgs = listOf("-Xjvm-default=all") + } +} diff --git a/dev/images/cpt-icon.svg b/dev/images/cpt-icon.svg new file mode 100644 index 00000000..43eceb96 --- /dev/null +++ b/dev/images/cpt-icon.svg @@ -0,0 +1,101 @@ + + + + + + + + + + + + image/svg+xml + + + + + + + + + p + + + + diff --git a/dev/images/cpt-icon_2.svg b/dev/images/cpt-icon_2.svg new file mode 100644 index 00000000..7eb19248 --- /dev/null +++ b/dev/images/cpt-icon_2.svg @@ -0,0 +1,87 @@ + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + diff --git a/dev/images/cpt-icon_3.svg b/dev/images/cpt-icon_3.svg new file mode 100644 index 00000000..c416d3d2 --- /dev/null +++ b/dev/images/cpt-icon_3.svg @@ -0,0 +1,106 @@ + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + diff --git a/dev/images/cpt-icon_3_opt.svg b/dev/images/cpt-icon_3_opt.svg new file mode 100644 index 00000000..95619097 --- /dev/null +++ b/dev/images/cpt-icon_3_opt.svg @@ -0,0 +1,19 @@ + + + + + + + image/svg+xml + + + + + + + + + + + + diff --git a/gen/de/endrullis/idea/postfixtemplates/language/parser/CptParser.java b/gen/de/endrullis/idea/postfixtemplates/language/parser/CptParser.java new file mode 100644 index 00000000..2b0a9f73 --- /dev/null +++ b/gen/de/endrullis/idea/postfixtemplates/language/parser/CptParser.java @@ -0,0 +1,340 @@ +// This is a generated file. Not intended for manual editing. +package de.endrullis.idea.postfixtemplates.language.parser; + +import com.intellij.lang.PsiBuilder; +import com.intellij.lang.PsiBuilder.Marker; +import static de.endrullis.idea.postfixtemplates.language.psi.CptTypes.*; +import static com.intellij.lang.parser.GeneratedParserUtilBase.*; +import com.intellij.psi.tree.IElementType; +import com.intellij.lang.ASTNode; +import com.intellij.psi.tree.TokenSet; +import com.intellij.lang.PsiParser; +import com.intellij.lang.LightPsiParser; + +@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"}) +public class CptParser implements PsiParser, LightPsiParser { + + public ASTNode parse(IElementType t, PsiBuilder b) { + parseLight(t, b); + return b.getTreeBuilt(); + } + + public void parseLight(IElementType t, PsiBuilder b) { + boolean r; + b = adapt_builder_(t, b, this, null); + Marker m = enter_section_(b, 0, _COLLAPSE_, null); + if (t == ESCAPE) { + r = escape(b, 0); + } + else if (t == MAPPING) { + r = mapping(b, 0); + } + else if (t == MAPPINGS) { + r = mappings(b, 0); + } + else if (t == REPLACEMENT) { + r = replacement(b, 0); + } + else if (t == TEMPLATE) { + r = template(b, 0); + } + else if (t == TEMPLATE_CODE_G) { + r = templateCodeG(b, 0); + } + else if (t == TEMPLATE_VARIABLE) { + r = templateVariable(b, 0); + } + else if (t == TEMPLATE_VARIABLE_EXPRESSION_G) { + r = templateVariableExpressionG(b, 0); + } + else if (t == TEMPLATE_VARIABLE_NAME_G) { + r = templateVariableNameG(b, 0); + } + else if (t == TEMPLATE_VARIABLE_VALUE_G) { + r = templateVariableValueG(b, 0); + } + else { + r = parse_root_(t, b, 0); + } + exit_section_(b, 0, m, t, r, true, TRUE_CONDITION); + } + + protected boolean parse_root_(IElementType t, PsiBuilder b, int l) { + return CptFile(b, l + 1); + } + + /* ********************************************************** */ + // (template|COMMENT)* + static boolean CptFile(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "CptFile")) return false; + int c = current_position_(b); + while (true) { + if (!CptFile_0(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "CptFile", c)) break; + c = current_position_(b); + } + return true; + } + + // template|COMMENT + private static boolean CptFile_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "CptFile_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = template(b, l + 1); + if (!r) r = consumeToken(b, COMMENT); + exit_section_(b, m, null, r); + return r; + } + + /* ********************************************************** */ + // TEMPLATE_ESCAPE + public static boolean escape(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "escape")) return false; + if (!nextTokenIs(b, TEMPLATE_ESCAPE)) return false; + boolean r; + Marker m = enter_section_(b); + r = consumeToken(b, TEMPLATE_ESCAPE); + exit_section_(b, m, ESCAPE, r); + return r; + } + + /* ********************************************************** */ + // CLASS_NAME (BRACKET_OPEN CLASS_NAME BRACKET_CLOSE)? MAP replacement + public static boolean mapping(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "mapping")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, MAPPING, ""); + r = consumeToken(b, CLASS_NAME); + r = r && mapping_1(b, l + 1); + r = r && consumeToken(b, MAP); + r = r && replacement(b, l + 1); + exit_section_(b, l, m, r, false, recover_parser_parser_); + return r; + } + + // (BRACKET_OPEN CLASS_NAME BRACKET_CLOSE)? + private static boolean mapping_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "mapping_1")) return false; + mapping_1_0(b, l + 1); + return true; + } + + // BRACKET_OPEN CLASS_NAME BRACKET_CLOSE + private static boolean mapping_1_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "mapping_1_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = consumeTokens(b, 0, BRACKET_OPEN, CLASS_NAME, BRACKET_CLOSE); + exit_section_(b, m, null, r); + return r; + } + + /* ********************************************************** */ + // mapping* + public static boolean mappings(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "mappings")) return false; + Marker m = enter_section_(b, l, _NONE_, MAPPINGS, ""); + int c = current_position_(b); + while (true) { + if (!mapping(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "mappings", c)) break; + c = current_position_(b); + } + exit_section_(b, l, m, true, false, null); + return true; + } + + /* ********************************************************** */ + // !(TEMPLATE_NAME|CLASS_NAME|COMMENT) + static boolean recover_parser(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "recover_parser")) return false; + boolean r; + Marker m = enter_section_(b, l, _NOT_); + r = !recover_parser_0(b, l + 1); + exit_section_(b, l, m, r, false, null); + return r; + } + + // TEMPLATE_NAME|CLASS_NAME|COMMENT + private static boolean recover_parser_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "recover_parser_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = consumeToken(b, TEMPLATE_NAME); + if (!r) r = consumeToken(b, CLASS_NAME); + if (!r) r = consumeToken(b, COMMENT); + exit_section_(b, m, null, r); + return r; + } + + /* ********************************************************** */ + // (templateCodeG|escape|templateVariable)+ + public static boolean replacement(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "replacement")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, REPLACEMENT, ""); + r = replacement_0(b, l + 1); + int c = current_position_(b); + while (r) { + if (!replacement_0(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "replacement", c)) break; + c = current_position_(b); + } + exit_section_(b, l, m, r, false, null); + return r; + } + + // templateCodeG|escape|templateVariable + private static boolean replacement_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "replacement_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = templateCodeG(b, l + 1); + if (!r) r = escape(b, l + 1); + if (!r) r = templateVariable(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + /* ********************************************************** */ + // (TEMPLATE_NAME SEPARATOR TEMPLATE_DESCRIPTION) mappings + public static boolean template(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "template")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, TEMPLATE, "