In the example below, I created two fake changesets: Foo and Bar

I want to merge them to one changeset. The idea in Mercurial is to :

• 1- update to a specific revision (5384) which will
     a. revert the files' contents to this revision
     b. mark this revision as the parent of next commits

2- revert the changes to the tip revision (5386), which will recreate the content, without changing the parent of commits

3- commit changes

4- delete old changeset

Complete story with screenshots

1- Right click on the revision 5384 and click Update, nothing hard here

2- Select the tip revision,
then in the files list,
right click on a file,
click on Revert to Revision
check 'all files'
ok, ok, ok, .

3- Go to Working Directory, and you'll see the file system is like at the tip, but the parent revision is the one you wanted, so the diff contains all the changes.

4- To delete the old changesets, you can use the 'mq' extensions from settings, then 'strip' them like this :

Path

The first thing we added was to be able to alter the Match clause with the current Path. Thus you can disable the rendering or change the location of a specific shape for a set of pages only.

<Match Path="/About" DisplayType="Summary">
    <Place Parts_RoutableTitle_Summary="-"/>
</Match>

This example would simply hide the summary on the /About page only. You can also use trailing stars to define it for a container, like /myblog/*.

Switching Shape Type

Using the current dev version you can also do crazy stuff, like changing the shape type dynamically. For instance, you are about to render a shape A, but is some cases, it should render B instead. You can do it like this:

<Place Parts_RoutableTitle="Header:5;shape=Foo"/>

This will substitute the Parts_RoutableTitle by the shape Foo. By doing it, you will also clear all alternates and wrappers associated to the current shape. This can be useful when combined with next presented feature.

Adding Alternates and Wrappers

Using the same technique as shown previously, you can add new alternates and wrappers to a shape based on the current Match.

<Place Parts_RoutableTitle="Header:5;alternate=foo;alternate=bar;wrapper=baz"/>

You can repeat alternate and wrapper verbs as you need.

Placement.info is really a simple and powerful way to solve Theming puzzles, and those new features should help even more in this.

Update

Those features are only available as of version 1.1. The official documentation can be found at http://orchardproject.net/docs/Understanding-placement-info.ashx

This post provides details on the Indexing implementation and usage. Next one will focus on querying the index, and customizing the search experience.

Anatomy

In order to have a search box in your website, you need to enable the Indexing module, then the Search module and finally the Lucene module.

Indexing is responsible for adding content to an IIndexProvider implementation as soon as a content item has been modified. There is a background task which is running on a separate thread and consumes IndexingTask records, created by a specific content handler event which creates the indexed document information. This point will be cover in detail later.

Search is providing a Search Form widget, and also a Search Settings to select what indexed fields should be part of the search.

Lucene is providing a default implementation of IIndexProvider and is used as a dependency of the Index module to save the indexed documents information in a physical storage. It's also providing an ISearchBuilder implementation which is called to build a search query.

Customizing Indexed Content

The Indexing module doesn't know anything about the content in Orchard. Though it has to be able to index anything inside a website, even from new modules, like Products, News, or anything else. For that to happen, modules can create implementations of ContentHandler and explicitly define OnIndexing<T>() in order to provide some information of a specific content part. It it defined as this:

This means you have to provide a lambda which takes exactly two parameters: an IndexContentContext instance, and the content part you should extract indexed information from. IndexContentContext inherits from ContentContextBase, and provide common information about the current content item:

It also contains a DocumentIndex property of type IDocumentIndex which looks like this:

This interface is used to directly provide all the information which has to be indexed. The Add() methods are used to add a named field to the index document, Analyze() just tell the concrete index implementation that the text should be tokenized (to differentiate text content like a title from metadata like an Id or an integral value). For instance, when OnIndexing() is called on the BodyPart (which is what is containing the body of a Page for instance) the following handler is executed:

The text of the body and its inner format are indexed. The text calls RemoveTags() which is used to remove all HTML or XML tags of a content. As our BodyPart will mostly contain HTML, and we don't want a search query on "div" to return all documents, then this method is used on this field. Finally Analyze() is called to be able to search on each different word of the content. The format is save in a separate field, and as it should only contain a mime type like text/html or so, we don't need to analyze its content or to remove tags. Though, we mark this field with a call to Store() in order to be able to retrieve the exact value from a search result, as indexing will generally break the original content. This should be done for any metadata added in the index.

NB: You can add several values to the same field name, even from different handlers. An example will be provided later.

This should be enough to understand that any module can provide information about the indexed information of a specific content item. For more examples just take a look at how Tags, Comments or Routable add their own properties in the index.

So far, I have released 12 modules on the gallery, some of them being co-authored with other team members. But the issue is that apart from a link to the source code and a simple name, you don’t have any hint on what it is supposed to do. There is a documentation page though on www.codeplex.com</a> for each of them, but I am lazy, so I figured it could be easier to provide at least a blog post to explain the overall goals and usage for those modules.

Origins

Let’s talk a little bit about the Rewrite Module. As for most of the modules I have created, it started on an existing problem that needed a solution. In this case we were about to launch the Orchard Contest website (www.orchardproject.net/omc</a>), and we had a SSL certificate for the www.orchardproject.net domain. The SSL was working great and it was a breeze to configure IIS in order to use it. But Bradley, a PM on Orchard responsible for this site, discovered that when users were coming using the orchardproject.net domain, without the www subdomain, then the HTTPS security alert was shown in browsers. Normal as the certificate was for a single domain. Too late to order another one, or even better a wildcard one as going through the Verisign process would have been too long for us. So I suggested Bradley we could hack a specific MVC Filter in this application to automatically redirect users to the correct domain, but one idea coming after the other, I ended up creating a more complete module … typically me!

The Orchard Contest website is built on Orchard itself. Thus we could leverage the users management, a theme that Jon, a web/UX designer in our team, had already created, and also have another case study for Orchard. So instead of creating a simple hard coded MVC filter, let’s create a reusable Orchard module. What could have be reused was the simple one rule redirect stuff. And it reminded me how it is done in PHP applications running on Apache with .htaccess files. IIS has simple and yet very powerful tools to handle url rewriting, and it can even parse Apache .htaccess files, but the goal of a CMS is also to have a single configuration point for the whole application, so having a module makes sense as you might not have access to IIS manager when using a shared hosting provider.

And that’s it! The Rewrite Module is a .htaccess file handler, which enables a lot of possibilities in you Orchard hosting story. Once installed and enabled, a new settings section is created and looks like this:

How to use it

You might have noticed the little text under the rule editing zone, linking to the current Apache documentation. Why bother creating some documentation that already exists! Another link that I like a lot is http://corz.org/serv/tricks/htaccess2.php, because it provides a lot of interesting scenarios that can be done with this module, like:

• preventing hot linking
• blocking specific IP ranges
• blocking specific browser agents or crawlers
• forcing SSL
• domain redirections
• …

For instance, in the Orchard Contest website we use this rule to redirect users to the correct domain:

RewriteCond %{HTTP_HOST} ^orchardproject.net$ [NC]
RewriteRule ^(.*)$ http://www.orchardproject.net/$1 [R=301,NC,L]

Implementation details

The implementation is quite simple. First there is a RedirectSettingsPart and the associated record class to store the settings.

public class RedirectSettingsPart : ContentPart<RedirectSettingsPartRecord> {

    public string Rules {

        get { return Record.Rules; }

        set { Record.Rules = value; }

    }

    public bool Enabled {

        get { return Record.Enabled; }

        set { Record.Enabled = value; }

    }

}

Like other settings parts, there is also a driver, handler, migration and template file. But that’s a common and well documented implementation.

The most important part is to handle all requests and trigger specific actions based on the rules in these settings. This is done by implementing IActionFilter which lets us being called whenever a controller’s action is executed. In Orchard we also need to inherit from FilterProvider in order to getting registered.

public class RedirectFilter : FilterProvider, IActionFilter {

    private readonly IOrchardServices _services;

    public RedirectFilter(IOrchardServices services) {

        _services = services;

        Logger = NullLogger.Instance;

    }

    public ILogger Logger { get; set; }

    public void OnActionExecuted(ActionExecutedContext filterContext) { }

    public void OnActionExecuting(ActionExecutingContext filterContext) {

        // implementation

       }

}

This event can then return specific ActionResult objects. So after parsing the rewirte rules, and checked a condition is fulfilled, there are actually three different possible results:

• HttpUnauthorizedResult
• RedirectResult, when a permanent redirect is requested
• TransferResult, for non permanents redirects, preventing for having the user to send another request

TransferResult is a simple custom ActionResult implementation:

/// <summary>

/// Transfers execution to the supplied url.

/// </summary>

private class TransferResult : RedirectResult {

    public TransferResult(string url)

        : base(url) {}

    public override void ExecuteResult(ControllerContext context) {

        var httpContext = HttpContext.Current;

        httpContext.RewritePath(Url, false);

        IHttpHandler httpHandler = new MvcHttpHandler();

        httpHandler.ProcessRequest(HttpContext.Current);
    }
}

I hope this little story will encourage you into creating reusable modules instead of doing one shot code. And if you happen to use this module someday, let me know.

As for most modules you can find on the gallery, there is a codeplex project for it, http://orchardrewriterules.codeplex.com, where you can submit bugs, get the source code, or read some documentation … when there will be some.

You can get it on Codeplex, where the code is hosted and which is our main code source repository, so you can see exactly what is done and when.  

I have been on the team for almost 4 months, and I'm just very excited by the shape of it, and where it is going. There are still a lot of bugs, and you can't do much with this release as a end user. Though the target with that one is the developer, so that we can rely on a great set of community module early, and we get feedback from the .NET community.

There are already some web sites and blogs running on Orchard, and people are very happy with the switch so far. Now we will start another round of development tasks to reach the Beta version around October. The next version is targeting the designers, with a first big task for us to completely rebuild the Theme engine.

The whole team is participating the design of all the modules, though I have been personaly involved in the development of the Azure management, the Search module, and also the Data Migration story, so if you have any remark or question on these modules, feel free to enter the discussion with me. We are also very active on the Forums here and here.

My first day was the 12th of April, so I suppose they had waited for me to launch Visual Studio 2010. First impression is that everything is done so that workers have the best possible environment to work. The facilities are great, people are always here to help, colleagues take time to explain stuff you need to know, you can't feel alone ! From a technical perspective it's also very interesting. People here are really clever and know their stuff. Actually they are even better than the better I had to work before, can you imagine it? :)

For those who don't know yet I'm working for the Orchard Project, which is an Open Source Web Content Management system you can compare to Drupal or Wordpress, but built in ASP.NET MVC. The project itself is really great, and the goal is, wow, amazing ! I'm really confident the final result will be great because of the talents in the team and also because of the way we are open to the community feedback. It's not yet stable enough to be used in productive web sites, unless you want to develop the stuff it's lacking currently.

My adventure at Evaluant started with a song from James Taylor (Gaia) and ends with another one. I think I have done everything I could to make it successful, and now it's time to reach new objectives. In two weeks I will be working for Microsoft, first in Vancouver and later in Redmond, for the ASP.NET team. It's a completely new life as me and the whole family are moving abroad, and also professionaly because the goal is to target maybe millions of potential users.