Regionerate

Continuously Integrated

noreply@blogger.com (Omer Rauchwerger) — Thu, 12 Mar 2009 16:27:00 +0000

Regionerate is now running on CodeBetter.com’s TeamCity server and a new install is created whenever new code is committed.

This means you can get new features and bug fixes as soon as they are committed to the project SVN, without having to compile the project yourself or wait for a new version to be released.

You can get nightly builds from the download page.

I’d like to thank James Kovacs and the wonderful peeps at CodeBetter.com for hosting the project.

Community Forums Are Back Up

noreply@blogger.com (Omer Rauchwerger) — Thu, 12 Mar 2009 09:54:00 +0000

As you might have noticed, the community forums were down this week. This was the result of a vicious spam monster-attack.
I somehow managed to bring it back up (no thanks to 1and1's service - thanks for nothing guys!). It still has some crap in it, but hopefully I will find a way to get rid of it soon.

Free Regionerate Giveaway at DevAcademy III

noreply@blogger.com (Omer Rauchwerger) — Mon, 15 Dec 2008 04:32:00 +0000

I'll be attending DevAcademy III today and will be giving free copies of Regionerate (yes! free!) to random people. Oh yes, and they are on floppy disks!

I find the concept of "giving away" free copies of an open-source software pretty amusing, I wonder how people will react. I'll be tweeting over the event, so make sure you follow me at Twitter.

Anyway, if you are there, give me a shout and get your free shiny copy of Regionerate v0.7 :-)

Announcing Regionerate Beta 2

noreply@blogger.com (Omer Rauchwerger) — Mon, 29 Sep 2008 07:34:00 +0000

I am pleased to announce the release of Regionerate Beta 2 (v0.7) (download now)

The first public beta (v0.6) was released more than a year ago and since then, thanks to great community participation in the forums and submitted patches, many bugs were fixed and many new features were introduced. You can review all the different bug fixes and new features since v0.6 here.

What's New in This Release

New Code Layout Browser

The new Code Layout Browser is even sexier. Browse through different layouts by using the keyboard shortcut or the menu item. Read more.

Advanced Sorting

Use sub-sorting to create code blocks that contain methods which are sorted by name, sub-sorted by parameter count and more.

Structs & Interfaces

Get standard layouts on your structs & interfaces as well.

New Code Layouts

A standard layout is cool, but forcing an entity class to look the same as a unit test fixture is just wrong. You can now apply new Code Layouts on specific class styles such as: Unit Test, Entity, Contract, Utility and more.

Complete Control Over Spacing

You can now control how consecutive items are spaced and how the first and last items are padded. This means you have absolute control over the spacing of your code. Read more.

Support for SharpDevelop 3.0 Beta 2

Use Regionerate on the latest SharpDevelop release. (Thanks to Kai P. Reisert for the patch)

I would like to thank everyone for their great help over the past year, and I hope Regionerate will continue to evolve and grow towards a super-stable and feature-rich v1.0.

Spacing

noreply@blogger.com (Omer Rauchwerger) — Mon, 29 Sep 2008 07:25:00 +0000

You can easily tweak the way Regionerate spaces your code.

Padding the First and Last Child

You can set the amount of new lines that will be added before the first child and after the last child of every region by setting the PadFirstChild and PadLastChild attributes on the CreateRegion element.

For example, this Code Layout snippet will place 2 new lines between the region's declaration and its members:

<CreateRegion Title="Fields" PadFirstChild="2" PadLastChild="2">

     <PutFields/>

</CreateRegion>

Running this Code Layout on this piece of code:

   1:  class MyClass

   2:  {

   3:        private string _myField;

   4:  }

... will result in this:

   1:  public class MyClass

   2:  {

   3:       #region Fields (1)

4:

5:

   6:       private int _myField;

7:

8:

   9:       #endregion Fields

  10:  }

The default value for PadFirstChild and PadLastChild is 1, meaning that if you don't specify any other value, the items will be padded with a single line.

Separating Consecutive Children

You can also control the amount of new lines between two consecutive children. This can be done at the ForEach level and at the Put level by using the SeparatingLines attribute.

For example, this Code Layout snippet will put 2 separating lines between every two consecutive regions inside an interface:

<ForEach Type="Interface" SeparatingLines="2">

     <CreateRegion Title="Properties">...</CreateRegion>

     <CreateRegion Title="Events">...</CreateRegion>

     <CreateRegion Title="Methods">...</CreateRegion>

</ForEach>

Test Drive Regionerate Beta 2 (v0.7)

noreply@blogger.com (Omer Rauchwerger) — Sat, 16 Aug 2008 13:19:00 +0000

I am a couple of days away from releasing Regionerate Beta 2, and I would like to test drive it on some other machines, just to make sure no show stoppers are introduced.

If you wanna help out and test drive it, please e-mail me with your specs (OS, IDE version, service pack, .NET framework version) and I'll send you a link to download Regionerate Beta 2.

Source Code Released

noreply@blogger.com (Omer Rauchwerger) — Tue, 01 Jan 2008 09:43:00 +0000

I'm glad to announce that I've finally set up an Assembla space for Regionerate!

You can visit Regionerate's Assembla space at http://www.assembla.com/spaces/Regionerate.

Opening this space officially makes Regionerate an open-source project, which means that starting now, everyone is welcome to pitch in!

The Assembla space will be used to host the source code (using the Subversion repository) and track bugs & feature requests. (using the Trac service). This web site will continue to be used as the only source for announcements, documentation and downloads.

Please discuss development issues in the Development forum.

I haven't migrated existing bugs, versions & features from the previous bugtracker to the new Trac service. It'll take me a few more days. For now, you can get the source code and compile it.

When I finish migrating, I will post instructions about submitting patches and managing tickets. (bugs & features)

Happy new year!

Source

noreply@blogger.com (Omer Rauchwerger) — Mon, 31 Dec 2007 22:15:00 +0000

Accessing the Source

To access the source code, perform an SVN checkout from https://svn2.assembla.com/svn/Regionerate,

Contributing

Make sure you read Scott Hanselman's post about submitting patches. To add, edit and view tickets (bugs & feature requests) visit the Trac service at http://trac2.assembla.com/Regionerate.

Discuss development issues in the Development forum.

You can visit Regionerate's Assembla space at http://www.assembla.com/spaces/Regionerate.

The Assembla space is used to host the source code (using the Subversion repository) and track bugs & feature requests. (using the Trac service). This web site will continue to be used as the only source for announcements, documentation and downloads.

New Version Available - v0.6.7.8

noreply@blogger.com (Omer Rauchwerger) — Thu, 06 Dec 2007 08:56:00 +0000

What's new:

The first 9 items inside the Code Layout Browser are now numbered and can be accessed by hitting their number. For example, if your keyboard shortcut is set to Ctrl+R and you want to access the 4th Code Layout that appears in your Code Layout Browser, just hit Ctrl+R, release the R (the Code Layout Browser will appear), hit 4 and the 4th Code Layout will be selected. Then release Ctrl and the 4th Code Layout will be applied.
Andreas Dangberg has contributed his Composite Application Block Code Layout which is now available in the Code Layout Browser. Thanks, Andreas!

Bug fixes:

Attributes are no longer mistaken to be Wrappers. (source)
Problem with overloading equal signs is solved. (source)
If your screen resolution is too small to show all items in the Code Layout Browser, it will automatically scroll to the selected item.

You can download this version at the Downloads page.

Speed Coding with Regionerate & GhostDoc

noreply@blogger.com (Omer Rauchwerger) — Thu, 29 Nov 2007 09:51:00 +0000

Here's a short screencast I created that demonstrates how I use free productivity enhancers such as GhostDoc (by Roland Weigelt), Regionerate and Visual Studio's built-in refactoring tools to quickly create and maintain skeleton code. It also demonstrates the usage of Regionerate's new Code Layout Browser.

I know there are some commercial tools that do more, but I'm just presenting a free (partial-)alternative. Make sure your speakers are turned on.

Can you think of other types of Code Layout? Comment here.
To prepare this screencast, I used CamStudio and Roy Osherove's KeyJedi.

New Version Available - v0.6.7.2

noreply@blogger.com (Omer Rauchwerger) — Thu, 22 Nov 2007 13:11:00 +0000

This version comes with a new feature called the Code Layout Browser. Yesterday I went to sleep with it in mind and just had to get it done today. I've been sitting in my favorite coffee place for like 6 hours now :-)

Read about the Code Layout Browser in my devblog post called Code Layout on Steroids!

To make the Code Layout Browser useful, I am also releasing several Code Layouts I use:

Contract First - Puts public stuff first, then all the rest.
Name Clustering - Separates fields, properties and methods by name clusters. (Fields starting with A-F, Fields starting with G-L etc')
NUnit Test Fixture - Separates initialization methods ([SetUp()], [TestFixtureSetUp()]), finalization methods ([TearDown()], [TestFixtureTearDown()]), test methods ([Test()]) and helper methods.
Plain Old CLR Object - Separates data members (fields, properties) from plumbing code (basically all the rest)
Regionless Layout - Unpacks all regions.

The new Code Layouts could use some work, I would appreciate any feedback in the General Discussion forum.

Also, if you have ideas for Code Layouts which will be useful to other users, send'em over!

You can download this version at the Downloads page.

Adding Custom Code Layouts to the Code Layout Browser

noreply@blogger.com (Omer Rauchwerger) — Thu, 22 Nov 2007 04:22:00 +0000

If you have a custom Code Layout and you want to make it accessible through the Code Layout Browser, all you need to do is place it in the "My Code Layouts" folder under your installation folder. (Typically "C:\Program Files\Regionerate\My Code Layouts")

The file must have an .xml extension. The label inside the Code Layout Browser will be the same as the file name just without the extension. ("My Custom Code Layout.xml" will be shown as "My Custom Code Layout")

If you want to have a custom image assigned to it, just place a 128x128 png file in the same directory with the same name. For example, if you want to have a custom image for "My Custom Code Layout.xml", just name your image "My Custom Code Layout.png". If you don't place a custom image, the default image will be used.

Remember: if you have a custom Code Layout and want to use it as your primary Code Layout (the primary Code Layout is the one that will be accessible when hitting the keyboard shortcut without holding it down), use the settings dialog to select it.

New Version Available - v0.6.6.5

noreply@blogger.com (Omer Rauchwerger) — Sat, 10 Nov 2007 10:06:00 +0000

This one took quite a while. Thanks for holding on patiently. The reason for this big delay between v0.6.5.0 and v0.6.6.5 is a big refactoring job I had to do as a preparation for future features. Also, this version comes with quite a few new features and bug fixes.

I've learned a lesson from this version. I tried to squeeze too much into it and it ended up taking over 2 months. This really goes against the "release often" mantra which I believe strongly in. I paid the price and I can only hope I'll be smarter on next releases. My aim is to release every 3 weeks, even if things are not perfect.

New Features:

The symbol mechanism has been completely rewritten and you can now choose from 3 different types of symbols (read more)
You can now configure Regionerate to unpack specific existing regions. (read more. Thanks to Krzysztof Kozmic for the idea!)
Nested classes are recursively Regionerated.

Bug Fixes:

A known issue from v0.2 - Curly brace issue solved.
Another known issue from v0.6 - Supportng #if-#endif blocks.
Generic Constraints stop Regionerate (reported here)
Better spacing for existing regions. (reported here)
Extraneous #endregions after Regionerating (reported here)
Protected internal methods being ignored (reported here)
Breaking at semicolons in string (reported here)

Please note that since this version had a big refactoring job, it is unstable and will probably induce some bugs. v0.6.6.5 can only be downloaded in "Latest" folder. The "Stable" folder still has v0.6.5.0 at the moment.

If no critical bugs pop up in the next two weeks or so, I will move this version to the "Stable" folder.

You can download this version at the Downloads page.

Configuration

noreply@blogger.com (Omer Rauchwerger) — Sat, 10 Nov 2007 08:59:00 +0000

The Configuration element in your Code Layout document can be used to configure certain settings that define Regionerate's behavior. These settings are shared between all layouts inside the Code Layout document.

The Symbol element can be used to determine which symbol is embedded in your regions. (What Are Symbols?)
Use the Unpack element to open certain existing regions. (Read more about unpacking)
Rendering options:
- ShowCount - Determines if Regionerated regions will automatically and recursively count their children.
- Tabs - The amount of tab characters Regionerated regions declarations have.
- UseTabs – Determines if regions should be indented using tabs. (otherwise, they will be indented with spaces)
- Spaces- The amount of space characters Regionerated regions declarations have.

Unpacking

noreply@blogger.com (Omer Rauchwerger) — Sat, 10 Nov 2007 08:58:00 +0000

The term "Unpacking" refers to a pre-processing stage that occurs before your code is analyzed and constructed. When Regionerate unpacks your code, it strips up all members from regions which are managed by it ("Regionerated regions"). After the code is shaped according to the Code Layout, these members are packed back into their regions.

While Regionerate automatically handles Regionerated regions, it allows you to specify which additional regions should be unpacked.

For example, you might have some regions that were generated by the IDE or a 3rd party tool for default interface implementations, such as:

   1:      public class Foo : IList<string>

   2:      {

   3:          #region IList<string> Members

4:

   5:          ...

6:

   7:          #endregion

8:

   9:          #region ICollection<string> Members

10:

  11:          ...

12:

  13:          #endregion

  14:      }

You can use the Unpack element under Configuration inside your Code Layout document to tell Regionerate to unpack any interface that matches a regular expression. For example:

<Configuration>

...

    <Unpack>

        <Regions ThatMatch="I.*\sMembers" />

    </Unpack>

</Configuration>

If you use the unpack command as above, every time you implement an interface, it will be unpacked and merged into the layout.

   1:      public class Foo : IList<string>

   2:      {

3:

   4:          #region Properties (3)

5:

   6:          ...

7:

   8:          #endregion Properties

9:

  10:          #region Methods (10)

11:

  12:          ...

13:

  14:          #endregion Methods

15:

  16:      }

Another possible use for unpacking is when migrating between symbols. If you used the Prefix symbol (the only option in versions prior to v0.6.6.5) long enough you have a code base filled with regions that look like:

#region [rgn] Fields (3)

If you change the symbol (lets say, from a Prefix to a Hidden Dragon), Regionerate will unpack and pack only regions the have the Hidden Dragon embedded in them, meaning that all "[rgn]" regions will stay untouched.

To migrate to the new symbol, you should tell Regionerate to unpack "[rgn]" regions:

   1:  <Configuration>

   2:      <Symbol>

   3:          <HiddenDragon />

   4:      </Symbol>

   5:      <Unpack>

   6:          <Regions ThatMatch="\[rgn\]" />

   7:      </Unpack>

   8:  </Configuration>

This way, the first time a code file is Regionerated with the new settings, Regionerate first unpacks all the old "[rgn]" regions and then it merges all the members into new Hidden Dragon symbolized regions.

What Are Symbols?

noreply@blogger.com (Omer Rauchwerger) — Sat, 10 Nov 2007 08:58:00 +0000

By using symbols Regionerate knows which regions are self-managed ("Regionerated regions") and which regions should be kept untouched ("exisiting regions") .

Up until v0.6.6.5, symbols were visible as prefixes before the name of the region, for example:

#region [rgn] Fields (5)

Now you can choose between 3 different types of symbols:

1. Hidden Dragon - (default) The Hidden Dragon is a special character (#255) which is not considered whitespace, yet not visible. If you use the Hidden Dragon, the symbol will be transparently embedded in your region declarations and will look like this:

#region Fields (5)

I would recommend you keep using the Hidden Dragon unless you stumble upon any trouble with it or if you want to be able to visually identify Regionerated regions.

2. Prefix - Allows you to add a prefix to Regionerated region headers, for example:

#region [rgn] Fields (5)

3. Wrapper - Allows you to add a prefix and a suffix to Regionerated region headers, for example:

#region [Fields (5)]

The symbol can be declared in your Code Layout document under the Configuration element.

<Configuration>

    <Symbol>

        <HiddenDragon />

    </Symbol>

...

</Configuration>

New Version Available - v0.6.5.0

noreply@blogger.com (Omer Rauchwerger) — Sat, 25 Aug 2007 22:15:00 +0000

Quarter way to release candidate! I would like to take this opportunity and thank everyone for helping me find all bugs which have been detected by now and for suggesting great ideas & feature requests. Together we can shape the ideal code layout tool.

I think Regionerate has gone a long way since v0.6.0.0, it is much more stable and offers a lot more features.

This release offers mostly bug fixes. My next goal is to finish implementing all the leaders in the first survey and release another survey with some new requests which have been proposed lately.

New Features:

After providing partial support for operators in v0.6.4.5, you can filter operators in v0.6.5.0 (read more)

Bug Fixes:

Partial fix for comments which are dropped when symbol is empty. (read more and thanks to Retrei & flanakin)
Chained constructors with initialized type forwarding aren't matched properly. (thanks kkozmic)
TypeVisibility not working in PutNestedClasses. (thanks dango2003)
Existing #endregion of format "#endregion .*(.*" breaks code. (thanks rathkopf)
Whitespace sequence freezes construction. This has caused some nested classes to freeze. (thank kkozmic)

You can download this version at the Downloads page.

New Version Available - v0.6.4.7

noreply@blogger.com (Omer Rauchwerger) — Mon, 13 Aug 2007 01:48:00 +0000

Just a couple of bug fixes. No need to update you Code Layout documents, they still work with the v0.6.3.8 namespace.

The main reason that this version was released so early is that v0.6.4.5 introduced a small bug which caused some attributed properties to be recognized as constructors. This is fixed. My bad for not reading the build report thoroughly.
Properties with attributed accessors are now handled (Mike, thanks for both these bug reports)

You can download this version at the Downloads page.

New Version Available - v0.6.4.5

noreply@blogger.com (Omer Rauchwerger) — Sun, 12 Aug 2007 03:22:00 +0000

2 New features for Visual Studio & #develop users:

Keyboard shortcuts are now customizable. (read more)
You can run Regionerate on entire solutions & projects from the Solution Explorer window in Visual Studio or Projects pad in #develop. (read more)

Bug fixes:

Semi-colon after innerclass definition problem solved. (thanks Finger)
Operators are recognized as methods. (read more)
#develop add-in now provides a code window context menu "Regionerate this" button.

No need to update your Code Layout documents, they will still work with the v0.6.3.8 namespace.

You can download this version at the Downloads page.

New Version Available - v0.6.3.8

noreply@blogger.com (Omer Rauchwerger) — Sat, 28 Jul 2007 06:45:00 +0000

New Features:

You can easily order your members by their length.
Place delegates inside regions.

Bug fixes:

Methods with multiple generic types are now recognized. (thanks chuggle)
International characters are supported. (thanks Finger, tercm and nvoigt)
Line breaks in field assignments issue solved. (thanks Finger)

You can download this version at the Downloads page.

Code Layout Tricks: Region Styles

noreply@blogger.com (Omer Rauchwerger) — Mon, 23 Jul 2007 14:39:00 +0000

If you read about Regionerate in blog posts, you are most likely to read that it is "a tool that creates regions automatically".
Most people don't understand that Regionerate is primarily about Code Layout and that #region is just one display style. Currently, Regionerate has 3 types of regions - Visible, Invisible and Comment.

If you take a look at the Code Layout schema, you can see that the CreateRegion statement has an attribute called RegionStyle which accepts any of the values mentioned above.

The Visible region style is the default style which will wrap your selection with #region-#endregion, for example:

#region Private Fields (3)

private string a;
private string b;
private string c;

#endregion

The Comment region style is a simpler style which will display a comment at the beginning of the selection, for example:

// Private Fields (3)

private string a;
private string b;
private string c;

This region style is very useful for regions inside regions which typically have a small amount of elements. For example:

#region Methods (3)

// Public Methods (2)

public abstract void A();
public abstract void B();

// Protected Methods (1)

protected abstract void C();

#endregion

The Invisible region style will display only the selected items without any header or footer, for example:

private string a;
private string b;
private string c;

This region style is ideal if you want to keep your code under a specific layout, but can't stand expanding and collapsing those annoying #regions.

New Version Available - v0.6.3.3

noreply@blogger.com (Omer Rauchwerger) — Sun, 22 Jul 2007 17:59:00 +0000

Just some bug fixes on this one, hoping to release some new features from the queue on the next version.

Constraints appear to break regioning - fixed. (thanks bsorensen)
A hopeful fix for some localization issues. (thanks nvoigt & Brettljausn)
Multiline Enum Value Problem solved.

Since there are no new features on this one, a new Code Layout schema was not published, so no need to update your Code Layouts.

You can download this version at the Downloads page.

Public Beta is One Month Old!

noreply@blogger.com (Omer Rauchwerger) — Sun, 22 Jul 2007 08:50:00 +0000

Regionerate's Public Beta was first published on DotNetKicks on June 22nd, 2007.
Since then, over 15,000 people have visited the website and over 2,000 people downloaded Regionerate.

I just wanted to send a big thanks to everyone for all the kind words, suggestions and bug reports.

I'm hoping to release a stable version as soon as possible and get going with the new features of Regionerate v2.0.

If you like Regionerate, help me spread it by recommending it to your friends & colleagues.

Thank you for your support!
--rauchy.

Code Layout Tricks: Placing Leftovers

noreply@blogger.com (Omer Rauchwerger) — Tue, 17 Jul 2007 10:42:00 +0000

Member leftovers are instances of a specific member type which were not already placed by a previous PutX statement. Member leftovers are placed by a PutX statement with no restricting Where statements.

For instance, A <PutFields/> statement will place all fields that weren't already placed by previous <PutFields> statements.
A <PutMethods><Where><IsConstructor Equals="true"/></Where></PutMethods> will place all constructors which weren't placed by previous <PutMethods> statements. (see example at the bottom)

Take this Code Layout Snippet as an example:

<PutFields>
<Where><Static Equals="true"/></Where>
</PutFields>
<PutFields/>

Run it on this piece of code -

public class WorkItem
{
private string _a;
private static string _b;
private readonly string _c;
}

and you will get -

public class WorkItem
{
private static string _b;
private string _a;
private readonly string _c;
}

The first <PutFields> statement in the Code Layout snippet will place "_b" and the second <PutFields/> statement will place all the leftovers ("_a", and "_c").

How is this useful, you ask? Well, placing leftovers can help you put some order in your regions without having to specify each specific case. For example, you might want to create a region for constructors, having all the public constructors appear first followed by the rest of the constructors.

Without leftovers, the Code Layout should have looked something like:

<CreateRegion Title="Constructors">
<PutMethods>
<Where><IsConstructor Equals="true"/><Access Equals="Public"/></Where>
</PutMethods>
<PutMethods>
<Where><IsConstructor Equals="true"/><Access Equals="Protected"/></Where>
</PutMethods>
<PutMethods>
<Where><IsConstructor Equals="true"/><Access Equals="Private"/></Where>
</PutMethods>
<PutMethods>
<Where><IsConstructor Equals="true"/><Access Equals="Internal"/></Where>
</PutMethods>
<PutMethods>
<Where><IsConstructor Equals="true"/><Access Equals="ProtectedInternal"/></Where>
</PutMethods>
</CreateRegion>

Using leftovers, the Code Layout can be reduced to:

<CreateRegion Title="Constructors">
<PutMethods>
<Where><IsConstructor Equals="true"/><Access Equals="Public"/></Where>
</PutMethods>
<PutMethods>
<Where><IsConstructor Equals="true"/></Where>
</PutMethods>
</CreateRegion>

New Version Available - v0.6.2.4

noreply@blogger.com (Omer Rauchwerger) — Sat, 14 Jul 2007 06:56:00 +0000

Three new features are included:

Multiple Where statements are finally supported.
Create regions for extern methods.
Create regions for your enums.

Bugs fixed:

Supporting nullable generic classes. (thanks gtsiokos)
Enums are not scrambled anymore. (Well, this is a side-effect of adding suport for enums)

You can download this version at the Downloads page.