[JBoss JIRA] Created: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
8:38 p.m.
When using the new-field command, the getters and setters should be separated from the
field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha2, 1.0.0.Alpha1, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:40 p.m.
New subject: [JBoss JIRA] Updated: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Pablo Martinez updated SEAMFORGE-79:
------------------------------------
Description:
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
was:
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
}
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:42 p.m.
New subject: [JBoss JIRA] Updated: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Pablo Martinez updated SEAMFORGE-79:
------------------------------------
Description:
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
was:
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:41 a.m.
New subject: [JBoss JIRA] Commented: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Paul Bakker commented on SEAMFORGE-79:
--------------------------------------
Although it's a common approach to use some marker syntax it's very breakable. If
someone edits the file by hand there's a good change that the marker syntax is removed
or the file structure is inconsistent. That's the problem with generating code in
user-editable files.
The Spring Roo guys solved this by putting all generated code in AspectJ Inter Type
Declarations. The cool thing about it is that all generated code is outside of files
editable by users. I don't like the heavy dependency on AspectJ however, but isn't
something similar possible for Forge? For more advanced scaffolding etc. an elegant
solution is necessary too.
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:14 a.m.
New subject: [JBoss JIRA] Commented: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Dan Allen commented on SEAMFORGE-79:
------------------------------------
I don't like the idea of having section markers either. I consider that
"developer intrusion" into the file (similar to "author intrusion" in
a novel). It's just excess information.
Having said that, I recognize that forge is a tool for creating code the way you like it.
Thus, I wouldn't be against an option to have such intrusive comments added. Forge is
certainly smart enough to know where to put them, having comprehension of the file.
Btw, a question I see between the lines here is that forge should format the code, or some
portion of it. Code formatting is not always desired, as it can mess up diffs in VCS
systems, though when laying down brand new code, it certainly applies. If it's
possible to have newly inserted sections of the code formatted according the to user's
preferences (like Eclipse does), that would be ideal. (Ignore if it already does this).
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:55 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Max Rydahl Andersen commented on SEAMFORGE-79:
----------------------------------------------
Look at eclipse does its defaulting - it just finds last field and method location and it
just kinda works out fine IMO.
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:32 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Pablo Martinez commented on SEAMFORGE-79:
-----------------------------------------
what about this logic:
when adding a new-field, search for the last field location, and add the field after that
one (private String field), then , search for constructors, if there's any, put the
getter/setter for the recent added field after all constructors, if no constructor found,
put the getter/setter after last field location (in this case the recently added field)
when adding a new-method, just put it at the bottom.
on pseudo pseudo pseudo code:
{code}
if (method == new-field) {
int fieldLine = searchLastFieldLocation();
addField(fieldLine + 1);
constructorLine = searchLastConstructorLocation();
if (constructorLine != -1 ) //when -1 it indicates no constructor found
addGetterSetter(constructorLine + 1);
else{
addGetterSetter(fieldLine + 2); //+2 instead of +1 to indicate AFTER the recently
added field
}
} else if (method == new-method) {
int methodLine = searchLastMethodLocation();
addMethod(methodLine + 1);
}
{code}
This way, we can be sure that fields go top, constructors after fields, getters/setters
after constructors (if any), and other methods always at the bottom.
Of course, if the user mess with the code creating a field at the bottom, or a constructor
at top or something like that, it wouldn't work as one would expect, BUT at least it
won't break the code, and if the user follows this *CONVENTION* (at least I follow
this methodology always), this would help a lot on understanding the code afterwards.
Any idea about this?
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:34 p.m.
New subject: [JBoss JIRA] Issue Comment Edited: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Pablo Martinez edited comment on SEAMFORGE-79 at 3/21/11 9:33 PM:
------------------------------------------------------------------
what about this logic:
when adding a new-field, search for the last field location, and add the field after that
one (private String field), then , search for constructors, if there's any, put the
getter/setter for the recent added field after all constructors, if no constructor found,
put the getter/setter after last field location (in this case the recently added field)
when adding a new-method, just put it at the bottom.
on pseudo pseudo pseudo code:
{code}
if (command.equals("new-field") {
int fieldLine = searchLastFieldLocation();
addField(fieldLine + 1);
constructorLine = searchLastConstructorLocation();
if (constructorLine != -1 ) //when -1 it indicates no constructor found
addGetterSetter(constructorLine + 1);
else{
addGetterSetter(fieldLine + 2); //+2 instead of +1 to indicate AFTER the recently
added field
}
} else if (command.equals("new-method")) {
int methodLine = searchLastMethodLocation();
addMethod(methodLine + 1);
}
{code}
This way, we can be sure that fields go top, constructors after fields, getters/setters
after constructors (if any), and other methods always at the bottom.
Of course, if the user mess with the code creating a field at the bottom, or a constructor
at top or something like that, it wouldn't work as one would expect, BUT at least it
won't break the code, and if the user follows this *CONVENTION* (at least I follow
this methodology always), this would help a lot on understanding the code afterwards.
Any idea about this?
was (Author: pablomartinez):
what about this logic:
when adding a new-field, search for the last field location, and add the field after that
one (private String field), then , search for constructors, if there's any, put the
getter/setter for the recent added field after all constructors, if no constructor found,
put the getter/setter after last field location (in this case the recently added field)
when adding a new-method, just put it at the bottom.
on pseudo pseudo pseudo code:
{code}
if (method == new-field) {
int fieldLine = searchLastFieldLocation();
addField(fieldLine + 1);
constructorLine = searchLastConstructorLocation();
if (constructorLine != -1 ) //when -1 it indicates no constructor found
addGetterSetter(constructorLine + 1);
else{
addGetterSetter(fieldLine + 2); //+2 instead of +1 to indicate AFTER the recently
added field
}
} else if (method == new-method) {
int methodLine = searchLastMethodLocation();
addMethod(methodLine + 1);
}
{code}
This way, we can be sure that fields go top, constructors after fields, getters/setters
after constructors (if any), and other methods always at the bottom.
Of course, if the user mess with the code creating a field at the bottom, or a constructor
at top or something like that, it wouldn't work as one would expect, BUT at least it
won't break the code, and if the user follows this *CONVENTION* (at least I follow
this methodology always), this would help a lot on understanding the code afterwards.
Any idea about this?
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:42 p.m.
New subject: [JBoss JIRA] Commented: (SEAMFORGE-79) When using the new-field command, the getters and setters should be separated from the field to make it more readable.
[
https://issues.jboss.org/browse/SEAMFORGE-79?page=com.atlassian.jira.plug...
]
Lincoln Baxter III commented on SEAMFORGE-79:
---------------------------------------------
I think this is a necessary feature. It needs some integration though. Take a look at the
forge javaparser implementation: https://github.com/seam/forge/tree/master/parser-java
This is where formatting and ordering must occur. The plugins themselves currently have no
control over these features, so we'll need to incorporate some kind of API to handle
this, or just do something intuitive.
When using the new-field command, the getters and setters should be
separated from the field to make it more readable.
----------------------------------------------------------------------------------------------------------------------
Key: SEAMFORGE-79
URL: https://issues.jboss.org/browse/SEAMFORGE-79
Project: Seam Forge
Issue Type: Feature Request
Components: Brainstorming
Affects Versions: 1.0.0.Alpha1, 1.0.0.Alpha2, 1.0.0.Alpha3
Reporter: Pablo Martinez
Priority: Optional
When using the new-field command, the getters and setters should be separated from the
fields, to make the java class more readable after using seamforge.
An idea is to separate every java class in 4 parts: Field block, Constructor block,
Getter/Setter block and Method block, using some arbitrary sintax (for easy parsing
maybe?), for example something like:
{code}
@Entity
public class User {
/* [FIELDS] */
private int id;
private String username;
private String password;
/* [CONSTRUCTORS] */
public User() {
}
public User(String username, String password) {
}
/* [GETTERS/SETTERS] */
public String getUsername() {
return this.username;
}
public void setUsername(final String username) {
this.username = username;
}
//etc...
/* [METHODS] */
public void doSomething() { }
public boolean equals(User other) { return false; }
//etc...
}
{code}
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5029
days inactive
5030
days old
8 comments
5 participants
participants (5)
-
Dan Allen (JIRA) -
Lincoln Baxter III (JIRA)
-
Max Rydahl Andersen (JIRA)
-
Pablo Martinez (JIRA)
-
Paul Bakker (JIRA)