Macros

I would love to be able to edit macros in IDEABasic...

How about using ECMAscript? There exist an opensource ECMAscript engine
(http://www.mozilla.org/rhino/) which works well. As IDEA already has
customizable syntax highlighting, and as Rhino is not very difficult to
use, it would be a not-so-difficult option.

In my opinion having to recompile a plugin to change a macro (and hence,
restart IDEA to use the new version), is quite cumbersome.

Guillaume


Jonas Kvarnström wrote:

Kirk Woll wrote:

>> The macro functionality in MS Word is by far the best that I've ever
>> seen, and anything that gets Idea closer to that level of
>> functionality would be golden.

Doesn't Word generate Visual Basic code for its macros?

I guess the closest thing for IDEA would be to automatically create Java
source code for a plugin that does what the macro did using calls to the
open API (if the open API is powerful enough), and then let the user
change the macro by changing and recompiling that plugin.

Kirk Woll wrote:

The macro functionality in MS Word is by far the best that I've ever
seen, and anything that gets Idea closer to that level of
functionality would be golden.

Doesn't Word generate Visual Basic code for its macros?

I guess the closest thing for IDEA would be to automatically create Java
source code for a plugin that does what the macro did using calls to the
open API (if the open API is powerful enough), and then let the user
change the macro by changing and recompiling that plugin.

Ick, but that wouldn't be pleasant. The beauty of macros is their interpreted nature and how you get INSTANT feedback on whether it worked. Frankly, tweaking plugins for Idea is a royal pain in the ass. The iterative development is prohibitively time consuming. Although I like the idea of the open API being powerful enough to support whatever the macros can do.

Kirk Woll wrote:

Ick, but that wouldn't be pleasant. The beauty of macros is their
interpreted nature and how you get INSTANT feedback on whether it
worked.

Well, yes, I mostly agree with you. But even with Word you have to
switch to the Visual Basic editor to change a macro and then switch back
to the word processor to execute the macro.

I haven't had the time to take a look at the open API and how you write
plugins for IDEA, but suppose that there was a rather simple API for
executing the most common macro-related tasks, where all of the standard
boilerplate code was moved away into some macro execution system or
something and all that remained was a "IDEAMacro" interface with a
simple "execute()" method. And then suppose that IDEA automatically
created these classes when you recorded a macro and that you would never
even have to see them unless you wanted to change the macro. Would that
be so bad?

Maybe a simple macro such as Guillaume LaForge's "line comment + line
duplication" example would turn into:

I'm just thinking out loud here, and it's getting a bit late so maybe
this is a stupid idea. I just think it would be a waste of resources to
implement another new interpreted macro language with variable
declarations, control structures and so on, when we could just reuse the
language we already have, and spend the time on improving the open API
that can be used for macros and ordinary plugins instead of having two
separate efforts.

Frankly, tweaking plugins for Idea is a royal pain in the
ass. The iterative development is prohibitively time consuming.

Would it be that much better with a specialized interpreted macro
language? (This is a serious question, not a sarcastic comment.)

Guillaume Pothier wrote:

In my opinion having to recompile a plugin to change a macro (and hence,
restart IDEA to use the new version), is quite cumbersome.

Well, this would of course be unacceptable. But IDEA could hide the
compilation process, and use some of the ordinary class loader tricks to
reload plugins automatically. IIRC Word macros (or at least Access /
Powerpoint macros) need to be compiled too if you want to detect errors;
otherwise you might end up with more runtime errors.

But maybe this leads to too much complexity and maybe a pure scripting
language is better, as long as it is easy to integrate it with methods
already available in the OpenAPI. As long as IntelliJ doesn't start
implementing a new macro language from scratch...

I agree with you. If the language were in Java that would be ideal. It's just the compilation/restarting of Idea that I would have a problem with. If that can somehow be avoided/eliminated/sped up drastically, I think using Java would be the best solution. I know jEdit uses BeanShell at least somewhat to this effect.

What if the macro was defined in xml like an ant script? Each element type would define a different command. For example, you might have:

]]>

To move the cursor to the beginning of the current word and select the text in between. This way you wouldn't have to worry about class reloading and compiling. Since most people are familiar with xml and ant this should be fairly intuitive. In conjunction with a nicely defined DTD for all the elements it should be very easy to understand.

And of course, users would be able to create their own elements through the open-api.

>I would love to be able to edit macros in IDEABasic...

Seriously: better use BeanShell.

Tom

The macro recording functionality haven't been intentend as something that
heavy and complete. It is something very lightweight and easy. May I be bold
enough to say there's no need for such advanced macro functionality Word
has. Don't forget we still have live templates, configurable file templates,
code generation features. So prior we continue in discussion what macros
should be please be more concrete and describe what tasks you'd like to
perform with it and what goals to achive and why it is not currently
possible/convinient enough with other IDEA features.

--

Best regards,
Maxim Shafirov
JetBrains, Inc / IntelliJ Software
http://www.intellij.com
"Develop with pleasure!"


"Kirk Woll" <kirk@digimax.com> wrote in message
news:9098843.1058990274864.JavaMail.itn@is.intellij.net...

The current Macro functionality is too limited. First and foremost, it

should be possible to edit a macro (as in an editor). Second, macros should
be more than just a string of Idea actions. If while recording a macro I
open a dialog (i.e. Introduce Variable) and I hit OK on the dialog I would
expect to not have to hit OK when playing back the macro. It should be
possible for macros to manipulate the dialogs' input values and also to
invoke them. We need some basic variable support so that it's possible to
create a macro that will create a test case class for the current class. In
order to do that, your macro would need access to the current class name,
package name, and info like that.
>

The macro functionality in MS Word is by far the best that I've ever seen,

and anything that gets Idea closer to that level of functionality would be
golden. Everything I've mentioned above is stuff that's been old hat in
Word for many years.

Maxim,

>The macro recording functionality haven't been intentend as something that
>heavy and complete. It is something very lightweight and easy.
>Don't forget we still have live templates, configurable file templates,
>code generation features. So prior we continue in discussion what macros
>should be please be more concrete and describe what tasks you'd like to
>perform with it and what goals to achive and why it is not currently
>possible/convinient enough with other IDEA features.


Fine, but Lite Templates' power is limited, and you don't plan to "fix"
that before long :

see :
http://www.intellij.net/tracker/idea/viewSCR?publicId=13868#510206
priority : Low
planned for : none.


Either one or the other has to be extended.

Alain

Argh, no move xml-as-cod stuff. Not another maven in the world.

Seriously, best insight in this thread was by Thomas: BeanShell.

For instance, I have several interns working in my project. Although I
required them to always use private instance variables, they sometimes
forgot. So I would like to run a kind of script that
would make all instance variables private.
It would be really nice (read: wonderful) to access the openAPI, or a subset
of it (PSI, ...) through a scripting language that doesn't compell us to
write a whole plugin for such a conceptually simple task.
As Tomas proposed, Beanshell seems a good starting point.

When I come to think of it, wouldn't it be nice to be able to do all that
plugins can do throuh scripting from within IDEA?

Other examples of macros:

• Remove all useless javadoc comments. I end up with a lot of empty @param

or @return tags, that get automatically generated and that some developpers
don't bother to remove.

• Perform custom formatting. There are always things you cannot do with

IntelliJ's formatting settings.

• Batch generation of classes. I use XDoclet to generate classes, and, well,

I would me more than happy to use something else. I know, maybe this would
in a sense tie the build process to IDEA, but for me that wouldn't be a
problem (generating these classes are not part of my build process).

*etc

Guillaume



Maxim Shafirov wrote:

The macro recording functionality haven't been intentend as something that
heavy and complete. It is something very lightweight and easy. May I be
bold enough to say there's no need for such advanced macro functionality
Word has. Don't forget we still have live templates, configurable file
templates, code generation features. So prior we continue in discussion
what macros should be please be more concrete and describe what tasks
you'd like to perform with it and what goals to achive and why it is not
currently possible/convinient enough with other IDEA features.

Being able to use this kind of script in the file templates would also be
quite cool!

Guillaume Pothier wrote:

For instance, I have several interns working in my project. Although I
required them to always use private instance variables, they sometimes
forgot. So I would like to run a kind of script that
would make all instance variables private.
It would be really nice (read: wonderful) to access the openAPI, or a
subset of it (PSI, ...) through a scripting language that doesn't compell
us to write a whole plugin for such a conceptually simple task.
As Tomas proposed, Beanshell seems a good starting point.

When I come to think of it, wouldn't it be nice to be able to do all that
plugins can do throuh scripting from within IDEA?

Other examples of macros:

• Remove all useless javadoc comments. I end up with a lot of empty @param

or @return tags, that get automatically generated and that some
developpers don't bother to remove.

• Perform custom formatting. There are always things you cannot do with

IntelliJ's formatting settings.

• Batch generation of classes. I use XDoclet to generate classes, and,

well, I would me more than happy to use something else. I know, maybe this
would in a sense tie the build process to IDEA, but for me that wouldn't
be a problem (generating these classes are not part of my build process).

*etc

Guillaume



Maxim Shafirov wrote:

>> The macro recording functionality haven't been intentend as something
>> that heavy and complete. It is something very lightweight and easy. May I
>> be bold enough to say there's no need for such advanced macro
>> functionality Word has. Don't forget we still have live templates,
>> configurable file templates, code generation features. So prior we
>> continue in discussion what macros should be please be more concrete and
>> describe what tasks you'd like to perform with it and what goals to
>> achive and why it is not currently possible/convinient enough with other
>> IDEA features.
>>

Just one more non-concrete idea, I promise...

I agree with keeping the macros simple. Have you played at all with Photoshop's macro recorder? Try it if you can. IIRC, it's a bit like yours, it that the actions recorded show up it an editable list. However, photoshop has a couple nice features you might consider:
1. You can reorder the actions
2. Each action has editable properties, which I believe can either be giving fixed values, or can be set to pop-up a user-input dialog when the macro is run. This mitigates the need to pop-up dialogs for refactoring actions if the macro is supposed to be fully automated.

I'm sure it has a couple other things I'm forgetting. Mostly, I remember that it was similar in style to yours, and I remember thinking that it was pretty cool and useful.

Finally, to accomidate those who want to design slightly more sophisticated macros, perhaps you could expose an organized list (with context help of course) of all available macro actions, and let the user drag-n-drop them into their macro script. No extra language, nothing complicated, easy to build on top of what you've done, and it allows people to "code" a macro from scratch.

Well, I disagree and think there is definitely a need for a more powerful macro feature. Live templates are designed to allow you to insert one chunk of code in one place. Often for me I need to do more, like add a field or create a class.

1) Create singleton
Add static instance field (ordered as in code style)
Add static instance method (ordered as in code style)

2) Create event
Create event interface
Create event context class
Add add/remove listener methods
Add fireXXX methods

3) Create test case class for current class
Class name and location can be computed via the
current class' name and package.
i.e. MyClassTest can be created for MyClass and
placed in the test location.

4) Navigate to test case for current class
Class name and location can be computed like in 3)
for quick access to test cases

Ultimately, do you ever find yourself engaged in repetitive actions while coding in Idea? For me the answer is a definite yes (and often). I think with a powerful macro engine I could begin codifying my repetitive actions into macros and saving myself a lot of time.

Plus the "live templates" are inconvenient to use. Say I have a task that
I'm going to have to perform repeatedly several places in a file or across
files. Rather than jump out to the live-template dialog and create a
"surrounds with" live template or whatever, I'd rather just DO the change
once, have IDEA remember what I did, and then just be able to invoke that
same (anonymouse 'last macro') again in the places I need it. If it's
something I think I'll use frequently, then I should be able to name it and
bind it to a keystroke.

Think "emacs" macros ;)


"Kirk Woll" <kirk@digimax.com> wrote in message
news:17347073.1059067479134.JavaMail.itn@is.intellij.net...

Well, I disagree and think there is definitely a need for a more powerful

macro feature. Live templates are designed to allow you to insert one chunk
of code in one place. Often for me I need to do more, like add a field or
create a class.
>

1) Create singleton
Add static instance field (ordered as in code style)
Add static instance method (ordered as in code style)

>

2) Create event
Create event interface
Create event context class
Add add/remove listener methods
Add fireXXX methods

>

3) Create test case class for current class
Class name and location can be computed via the
current class' name and package.
i.e. MyClassTest can be created for MyClass and
placed in the test location.

>

4) Navigate to test case for current class
Class name and location can be computed like in 3)
for quick access to test cases

>

Ultimately, do you ever find yourself engaged in repetitive actions while

coding in Idea? For me the answer is a definite yes (and often). I think
with a powerful macro engine I could begin codifying my repetitive actions
into macros and saving myself a lot of time.

How would this be any different from ant, the example I cited?

In any case, right above I suggested BeanShell as well. ;)

I'm thinking that much of people want to accomplish with macros can be done using the idea I stated above. For example, changing access of members, creating new classes, creating stub interface impls, creating test classes, manipulating code formatting or javadocs, navigation, etc. could be all be done by dragging and dropping macro actions into a simple list. Each macro action has editible properties to further customize it (or to avoid user-input when running the macro).

The actions available for adding to macros could be expanded by writing plugins which provide new macro actions.

While writing plugins with a scripting language would be nice, I wouldn't tend to use this in the same places I would use a simple macro editor. With the graphical approach intellij is using, I could, in 90 seconds, whip up a quick "script" to do what I want to do. In a scripting language, it will take me longer, and hence I won't use it for many simply tasks.

Or, combine the ideas. Write a macro action that takes beanshell as a argument.

IntelliJ allows you to program using mostly the keyboard, which in my
opinion is much faster than programming with mouse. With proper
autocompletion, creating a macro with a scripting language wouldn't be so
hard.

As a sidenote, I am developping a graphical programming language, which is
basically graphically edited scripts, the intended audience being
non-programmers. Creating a simple script with the mouse, as we do in our
system, is from a java programmer point-of-view a painful and time
consuming task.

Guillaume

Russell Egan wrote:

I'm thinking that much of people want to accomplish with macros can be
done using the idea I stated above. For example, changing access of
members, creating new classes, creating stub interface impls, creating
test classes, manipulating code formatting or javadocs, navigation, etc.
could be all be done by dragging and dropping macro actions into a simple
list. Each macro action has editible properties to further customize it
(or to avoid user-input when running the macro).

The actions available for adding to macros could be expanded by writing
plugins which provide new macro actions.

While writing plugins with a scripting language would be nice, I wouldn't
tend to use this in the same places I would use a simple macro editor.
With the graphical approach intellij is using, I could, in 90 seconds,
whip up a quick "script" to do what I want to do. In a scripting
language, it will take me longer, and hence I won't use it for many simply
tasks.

Or, combine the ideas. Write a macro action that takes beanshell as a
argument.

1) Create singleton
Add static instance field (ordered as in code style)
Add static instance method (ordered as in code style)

Preconfigured file template.

>

2) Create event
Create event interface
Create event context class
Add add/remove listener methods
Add fireXXX methods

Easily can be configured as a file template.

>

3) Create test case class for current class
Class name and location can be computed via the
current class' name and package.
i.e. MyClassTest can be created for MyClass and
placed in the test location.

File templates again. Though will not catch an information of the current
class & its location automatically. You'll have to enter.

4) Navigate to test case for current class
Class name and location can be computed like in 3)
for quick access to test cases

Existing JUnit plugin.

Ultimately, do you ever find yourself engaged in repetitive actions while

coding in Idea? For me the answer is a definite yes (and often). I think
with a powerful macro engine I could begin codifying my repetitive actions
into macros and saving myself a lot of time.

And finally I'm not sure it will be such an easy task if you have macro
engine you're requesting. Just try to post a sample for let say item 3)
I wonder if this will be significantly simpler than writing plugin through
OpenAPI.

Well, and at the end we'll end up with the feature that most of 20-30 IDEA
users will EVER use. This is not IDEA-like. Like someone said IDEA is
powerful yet SIMPLE.


--

Best regards,
Maxim Shafirov
JetBrains, Inc / IntelliJ Software
http://www.intellij.com
"Develop with pleasure!"

On Wed, 23 Jul 2003 19:57:54 +0000, Kirk Woll wrote:

The current Macro functionality is too limited. First and foremost, it
should be possible to edit a macro (as in an editor). Second, macros
should be more than just a string of Idea actions. If while recording a
macro I open a dialog (i.e. Introduce Variable) and I hit OK on the dialog
I would expect to not have to hit OK when playing back the macro. It
should be possible for macros to manipulate the dialogs' input values and
also to invoke them. We need some basic variable support so that it's
possible to create a macro that will create a test case class for the
current class. In order to do that, your macro would need access to the
current class name, package name, and info like that.

I think you're wanting more a full "scripting" system for IDEA, rather
than a simple macro record/playback, having the full OpenTools API exposed
by say Beanshell could be nice, and I think theres a plugin for that (
mind you, if you read the latest Bileblog beanshell is evil ).


--
...turn to the light - don't be frightened by the shadows it creates,
...turn to the light - turning away could be a terrible mistake
...dream theater - the great debate

Yes, I do want more than a "simple record/playback" functionality because a simple record/playback functionality without any room for customization of the script is fairly useless, IMO.

Well, let's just call the things by their names. As far as I can understand
you'd like to have a scripting capability to an OpenAPI that is a completely
different thing. BTW, at its current stange an OpenAPI will not let you to
deal with parsing tree i.e. classes and methods etc. since PSI is not
officially opened yet.

--

Best regards,
Maxim Shafirov
JetBrains, Inc / IntelliJ Software
http://www.intellij.com
"Develop with pleasure!"


"Kirk Woll" <kirk@digimax.com> wrote in message
news:26309140.1059076150904.JavaMail.itn@is.intellij.net...

Yes, I do want more than a "simple record/playback" functionality because

a simple record/playback functionality without any room for customization of
the script is fairly useless, IMO.

>> 1) Create singleton
>> Add static instance field (ordered as in code style)
>> Add static instance method (ordered as in code style)
>
>Preconfigured file template.

I meant as in I want to CONVERT my existing class into a singleton. Personally, I want to do this far more than starting from scratch with a singleton.

>> 2) Create event
>> Create event interface
>> Create event context class
>> Add add/remove listener methods
>> Add fireXXX methods
>
>Easily can be configured as a file template.

How exactly? We're talking about, through one command, creating two classes and adding some fields and methods to the starting class. How does a file template accomodate this?

>> 3) Create test case class for current class
>> Class name and location can be computed via the
>> current class' name and package.
>File templates again. Though will not catch an >information of the current
>class & its location automatically. You'll have to enter.

Yes, but the point of my example was to NOT have to type in that data.

>> 4) Navigate to test case for current class
>> Class name and location can be computed like in 3)
>> for quick access to test cases
>
>Existing JUnit plugin.

Where is this command located? I'm not familiar with it.

And finally I'm not sure it will be such an easy task
if you have macro you're requesting.

Easy to make the macro? I can imagine it being pretty straightforward, depending on what syntax is used. As for the open API, don't get me wrong, I appreciate everything about it. But for me it's been an error-prone, complicated and time-consuming exercise.

Well, and at the end we'll end up with the feature that
most of 20-30 IDEA users will EVER use.

Are you pulling this number out of thin air?

This is not IDEA-like. Like someone said IDEA is
powerful yet SIMPLE.

What exactly about this idea is not simple? I agree it's not trivial. But I think what I want here is not a terribly complicated idea. Regardless, as you quote: "IDEA is powerful yet simple". But in order to brag about being simple it must FIRST be powerful. What I see so far of the macro engine is very weak.

Sure, call it by a different name. It's semantics. As I stated before, I was using Word as my previous experience with macros and that is in fact what they called this functionality. If you want to reserve the word "macro" for what Idea currently does that's fine.

>>I would love to be able to edit macros in IDEABasic...

Seriously: better use BeanShell.

http://www.intellij.org/twiki/bin/view/Main/MacrosPlugin has been there
since December, 2002. and yes, it uses BeanShell.

--
Dmitry Skavish
JetBrains, Inc. / "Develop with pleasure!"
email: skavish@jetbrains.com | cell: 508.789.6590 | office: 508.875.5564

That's a bit harsh. IMO, the current simple implementation of macros is
much needed. Both JBuilder and Delphi had less than the current
functionality from very early on and I often used it (in fact me and an old
colleague used to have a running competition to see who could 'write' the
'coolest' macro... sad I know :P ). Granted, the provision of refactoring
removes a lot of places where I would have originally have used it; one good
example I can think of is changing method signatures, but I can guarantee
that there will be times when you just want to perform a repetitive
structured edit many places in your code, and you will be glad it's here.
Because of this, I would say it is far from "fairly useless".

In fact this implementation was better than I expected as it allows to save
macros by name - JBuilder just allowed you to record a temporary one which
most of the time was sufficient for me. The great way this can be used
(once the keymap issue is sorted) is to allow the user to customise the way
they interact with the ui without building a plugin or waiting for it to be
implemented. One example I remember is
http://www.intellij.net/tracker/idea/viewSCR?publicId=3483, and check Dan
Sandbergs post on the original RFE
http://www.intellij.net/tracker/idea/viewSCR?publicId=847 but I'm sure there
are scores of others posted (and unposted) that were waiting for this
functionality.

Of course people will want to expand macro's capability, and the idea is
fine, but lets not try to run before we can appreciate being able to walk ;)

N.

Kirk Woll wrote:

Yes, I do want more than a "simple record/playback" functionality
because a simple record/playback functionality without any room for
customization of the script is fairly useless, IMO.

Well, here is my 2 kopecks:

Action system in IDEA was not designed up-front with the ability to use
actions in macros. "Introduce Variable" action, say, have never been
designed so that it takes name for the variable anyware except the
dialog. So I think it will be too much work to implement full scripting
capabilities as in M$ Word or other products mentioned.

In fact, it will be a duplication of work, as we are also working on
OpenAPI for IDEA, and I think scripting + OpenAPI is way too much.

IMHO BeanShell + some helper libraries for common tasks is a way to go.

Friendly,
Dmitry



Mark Derricutt wrote:

On Wed, 23 Jul 2003 19:57:54 +0000, Kirk Woll wrote:

>>
>> The current Macro functionality is too limited. First and foremost, it
>> should be possible to edit a macro (as in an editor). Second, macros
>> should be more than just a string of Idea actions. If while recording a
>> macro I open a dialog (i.e. Introduce Variable) and I hit OK on the
>> dialog
>> I would expect to not have to hit OK when playing back the macro. It
>> should be possible for macros to manipulate the dialogs' input values and
>> also to invoke them. We need some basic variable support so that it's
>> possible to create a macro that will create a test case class for the
>> current class. In order to do that, your macro would need access to the
>> current class name, package name, and info like that.

I think you're wanting more a full "scripting" system for IDEA, rather
than a simple macro record/playback, having the full OpenTools API exposed
by say Beanshell could be nice, and I think theres a plugin for that (
mind you, if you read the latest Bileblog beanshell is evil ).

--
Dmitry Lomov
IntelliJ Labs / JetBrains Inc.
http://www.intellij.com
"Develop with pleasure!"

Just my two cents, and I'm probably not saying anything that hasn't been said already...but just in my own special way.

The thing that makes the Word macros so powerful is that you can record your basic keystroke type things, and then edit the code, adding iteration, or whatever, and your own tweaks to come up with something that saves you hours of work.

I had been asked to convert a bunch of tables in a Word document to XML. It was expected that this would take me a week or so. By creating a couple of robust Word macros, I was able to do the job in about 3 hours, and 2+ of that was spent coding the macros.

Something like this in IDEA would be absolutely fantastic.

More than just word... Visual Studio does the same thing. You record a
"macro" and can bind it, but if you want to edit it, it's vbscript just like
in Word.

"Kirk Woll" <kirk@digimax.com> wrote in message
news:18273856.1059077945227.JavaMail.itn@is.intellij.net...

Sure, call it by a different name. It's semantics. As I stated before, I

was using Word as my previous experience with macros and that is in fact
what they called this functionality. If you want to reserve the word
"macro" for what Idea currently does that's fine.