Styled Bits

Using Rails to Redirect Your Users to FeedBurner

2009-06-17T10:02:27Z

Previously, we built an Atom feed generator for our little pet Rails project, TextMill.

However, having signed up for a movable FeedBurner feed, we’d like to redirect all users there so that we might change our underlying engine and feed out on a whim in the future.

Our goals are clear:

if a request for ‘/articles.atom’ or ‘/projects.atom’ comes from FeedBurner, serve up the appropriate Atom feed
if the request originates from anyone else, send a permanent redirect to the appropriate FeedBurner feed

Implementation is even easier. After watching the logs, I discovered that all requests from FeedBurner have the User-Agent header set to “FeedBurner/1.0 (http://www.FeedBurner.com)”. Our Rails controllers have the ability to inspect the ‘User-Agent’ header by examining the ‘request.headers’ hash.

To glue this all together, I just opened up ‘app/controllers/articles_controller.rb’ and modified the index action to read like so (note lines 7-11):


  1
2
3
4
5
6
7
8
9
10
11
12

  def index
   @articles = Article.all(:conditions => ["published = ?",true], :order => "published_at DESC")

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @articles }
      format.atom do
        if !request.headers['User-Agent'].match(/FeedBurner/)
          redirect_to "http://feeds2.feedburner.com/StyledBits", :status=>:moved_permanently
        end
      end
  end

As you can see, we do a simple regexp match against the User-Agent header to see if it contains the phrase ‘FeedBurner’. If so, give them the raw atom feed. Otherwise, give them a permanent redirect over to our FeedBurner url.

Adding Syntax Highlighting to Your Rails App

2009-06-17T10:00:49Z

Wanting to spice things up when rendering code in my articles, I decided to implement syntax highlighting.

Since I already take advantage of RedCloth for rendering textile, augustl’s redcloth-with-coderay gem looked like a great choice.

Installation was nothing more than:


  

  sudo gem install redclothcoderay

Once that completed, I modified ‘config/environment.rb’ in my rails application to load up the appropriate gems:


  1
2
3

  require 'redcloth'
require 'coderay'
require 'redclothcoderay'

I altered my article erb ‘show’ template to read:


  1
2

  <%RedclothCoderay.coderay_options :line_numbers => :table%>
<%=textilize @article.body%>

Finally, I had to add the following to my stylesheet to allow things to look pretty:


  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

  .CodeRay {
  background-color: #f8f8f8;
  border: 1px solid silver;
  font-family: 'Courier New', 'Terminal', monospace;
  color: #100;
}
.CodeRay pre { margin: 0px }

div.CodeRay { }

span.CodeRay { white-space: pre; border: 0px; padding: 2px }

table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px }
table.CodeRay td { padding: 2px 4px; vertical-align: top }

.CodeRay .line_numbers, .CodeRay .no {
  background-color: #def;
  color: gray;
  text-align: right;
}
.CodeRay .line_numbers tt { font-weight: bold }
.CodeRay .no { padding: 0px 4px }
.CodeRay .code { width: 100% }

ol.CodeRay { font-size: 10pt }
ol.CodeRay li { white-space: pre }

.CodeRay .code pre { overflow: auto }

.CodeRay .af { color:#00C }
.CodeRay .an { color:#007 }
.CodeRay .av { color:#700 }
.CodeRay .aw { color:#C00 }
.CodeRay .bi { color:#509; font-weight:bold }
.CodeRay .c  { color:#888 }

.CodeRay .ch { color:#04D }
.CodeRay .ch .k { color:#04D }
.CodeRay .ch .dl { color:#039 }

.CodeRay .cl { color:#B06; font-weight:bold }
.CodeRay .co { color:#036; font-weight:bold }
.CodeRay .cr { color:#0A0 }
.CodeRay .cv { color:#369 }
.CodeRay .df { color:#099; font-weight:bold }
.CodeRay .di { color:#088; font-weight:bold }
.CodeRay .dl { color:black }
.CodeRay .do { color:#970 }
.CodeRay .ds { color:#D42; font-weight:bold }
.CodeRay .e  { color:#666; font-weight:bold }
.CodeRay .en { color:#800; font-weight:bold }
.CodeRay .er { color:#F00; background-color:#FAA }
.CodeRay .ex { color:#F00; font-weight:bold }
.CodeRay .fl { color:#60E; font-weight:bold }
.CodeRay .fu { color:#06B; font-weight:bold }
.CodeRay .gv { color:#d70; font-weight:bold }
.CodeRay .hx { color:#058; font-weight:bold }
.CodeRay .i  { color:#00D; font-weight:bold }
.CodeRay .ic { color:#B44; font-weight:bold }

.CodeRay .il { background: #eee }
.CodeRay .il .il { background: #ddd }
.CodeRay .il .il .il { background: #ccc }
.CodeRay .il .dl { font-weight: bold ! important; color: #888 ! important }

.CodeRay .in { color:#B2B; font-weight:bold }
.CodeRay .iv { color:#33B }
.CodeRay .la { color:#970; font-weight:bold }
.CodeRay .lv { color:#963 }
.CodeRay .oc { color:#40E; font-weight:bold }
.CodeRay .on { color:#000; font-weight:bold }
.CodeRay .op { }
.CodeRay .pc { color:#038; font-weight:bold }
.CodeRay .pd { color:#369; font-weight:bold }
.CodeRay .pp { color:#579 }
.CodeRay .pt { color:#339; font-weight:bold }
.CodeRay .r  { color:#080; font-weight:bold }

.CodeRay .rx { background-color:#fff0ff }
.CodeRay .rx .k { color:#808 }
.CodeRay .rx .dl { color:#404 }
.CodeRay .rx .mod { color:#C2C }
.CodeRay .rx .fu  { color:#404; font-weight: bold }

.CodeRay .s  { background-color:#fff0f0 }
.CodeRay .s  .s { background-color:#ffe0e0 }
.CodeRay .s  .s  .s { background-color:#ffd0d0 }
.CodeRay .s  .k { color:#D20 }
.CodeRay .s  .dl { color:#710 }

.CodeRay .sh { background-color:#f0fff0 }
.CodeRay .sh .k { color:#2B2 }
.CodeRay .sh .dl { color:#161 }

.CodeRay .sy { color:#A60 }
.CodeRay .sy .k { color:#A60 }
.CodeRay .sy .dl { color:#630 }

.CodeRay .ta { color:#070 }
.CodeRay .tf { color:#070; font-weight:bold }
.CodeRay .ts { color:#D70; font-weight:bold }
.CodeRay .ty { color:#339; font-weight:bold }
.CodeRay .v  { color:#036 }
.CodeRay .xt { color:#444 }

All in all, a very, very quick implementation that didn’t even require me to do any regular expression work of my own!

Easy Atom Feeds for Rails

2009-06-17T02:15:42Z

To get these articles out to the public, I needed to make sure that TextMill could spout out Atom so others can syndicate my content. As usual, Ruby on Rails made it too easy.

Accept the Format

Keeping with the RESTful model, I decided that articles would be syndicated by using a URL like ‘/articles.atom’. In order to activate this, I just had to change this:


  1
2
3
4
5
6
7
8

  def index
    @articles = Article.all(:conditions => ["published = ?",true])

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @articles }
    end
  end

to look like this:


  1
2
3
4
5
6
7
8
9

  def index
  @articles = Article.all(:conditions => ["published = ?",true])

  respond_to do |format|
    format.html #index.html.erb
    format.xml { render :xml => @articles }
    format.atom
  end
end

Pretty sweet, eh?

The Template

When ‘/articles.atom’ is called, a Builder template will be loaded to describe the feed’s structure. I just created ‘app/views/articles/index.atom.builder’ like so:


  1
2
3
4
5
6
7
8
9
10
11
12
13
14

  atom_feed do |feed|
  feed.title("Styled Bits")
  feed.updated(@articles.first.published_at)
  
  @articles.each do |article|
    feed.entry(article) do |entry|
      entry.title(article.title)
      entry.content(textilize(article.body), :type => 'html')
      entry.author do |author|
        author.name("Michael Gorsuch")
      end
    end
  end
end

Auto Discovery

In order to enable auto discovery for RSS readers and browsers, the following was added to the default template in the ‘’ section: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }"><%= auto_discovery_link_tag(:atom, {:controller => "articles", :action => "index", :format => "atom"})%></pre></td> </tr></table> </code></pre>Not too hard, eh? </article> <article> <h1>RESTful Authentication Quick Start</h1> 2009-06-16T23:03:21Z Since <a href="/">Styled Bits</a> isn’t much more than a simple <a href="http://en.wikipedia.org/wiki/Create,_read,_update_and_delete">CRUD</a> application, I needed to add basic authentication support to <a href="/projects/1">TextMill</a>. The most popular choice for such things is <a href="http://github.com/technoweenie/restful-authentication/tree/master">technoweenie’s RESTful Authentication plugin</a>, but I was unable to find a straight forward tutorial explaining how one puts it to use. Hence this article. <h3>Starting Out</h3> For starters, you just want to run the following from the command prompt: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">./script/plugin install git://github.com/technoweenie/restful-authentication.git</pre></td> </tr></table> </code></pre>This takes care of pulling down the latest version of the plugin and installing the basic generator. Generators extend the abilities of the ‘generate’ script, in this case adding an ‘authenticate’ command. To generate the code for use within our app, run this: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">./script/generate authenticate user sessions</pre></td> </tr></table> </code></pre>As you can see from the output, a wide array of files and routes are generated and inserted into your project. First things first, let us take care of updating our database with the necessary migrations: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">rake db:migrate</pre></td> </tr></table> </code></pre><h3>Implementation</h3> Now that we’ve got that taken care of, it is time to figure out how to use this puppy. As far as I’m concerned at the time of this writing, I want to protect all methods of the Article and Project controllers except for ‘show’. If we browse to ‘lib/authenticated_system.rb’, we can see a wide variety of methods available for our use. For our stated goal, the ‘login_required’ seems appropriate. To be able to call this from our controllers, we have two choices: AuthenticatedSystem can either be included in each controller, or we can just place the include statement within the Application controller and allow all of the others to inherit it. In our application, there is no apparent reason not to choose the latter. So, let us open up ‘app/controllers/application_controller.rb’ and change it from this: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>1<tt> </tt>2<tt> </tt>3<tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">class ApplicationController < ActionController::Base<tt> </tt> ...<tt> </tt>end</pre></td> </tr></table> </code></pre>to this: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>1<tt> </tt>2<tt> </tt>3<tt> </tt>4<tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">class ApplicationController < ActionController::Base<tt> </tt> include AuthenticatedSystem<tt> </tt> ...<tt> </tt>end</pre></td> </tr></table> </code></pre>Since all of the methods contained with the AuthenticatedSystem module are now available to all of my controllers, we can open up ‘app/controllers/articles_controller.rb’ and change it from: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>1<tt> </tt>2<tt> </tt>3<tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">class ArticlesController < ApplicationController<tt> </tt> ...<tt> </tt>end</pre></td> </tr></table> </code></pre>to: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>1<tt> </tt>2<tt> </tt>3<tt> </tt>4<tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">class ArticlesController < ApplicationController<tt> </tt> before_filter :login_required, :except => :show<tt> </tt> ...<tt> </tt>end</pre></td> </tr></table> </code></pre>The same procedure can be performed on ‘app/controllers/projects_controller.rb’. <h3>Almost There</h3> Once all of this is in place, it seems that the proper thing to do is prohibit anonymous user signups. All we have to do here is comment out or delete the following lines in ‘config/routes.rb’: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>1<tt> </tt>2<tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">map.register '/register', :controller => 'users', :action => 'create'<tt> </tt> map.signup '/signup', :controller => 'users', :action => 'new'</pre></td> </tr></table> </code></pre>Finally, let us add our administrative user that will actually be capable of logging in. Since we’ve purged the ‘/signup’ route, we’ll have to go in via the console. The following code will build your user: <pre><code class="multiline_code"><table class="CodeRay"><tr> <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>1<tt> </tt>2<tt> </tt>3<tt> </tt>4<tt> </tt>5<tt> </tt>6<tt> </tt></pre></td> <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">user = User.new<tt> </tt>user.login = "admin"<tt> </tt>user.email = "admin@mydomain.com"<tt> </tt>user.password = "mypass"<tt> </tt>user.password_confirmation = "mypass"<tt> </tt>user.save</pre></td> </tr></table> </code></pre>Alright! If we now try and hit up ‘/articles/new’, we’ll be presented with a login prompt that will accept ‘admin’ for the username and ‘mypass’ for the password. <h3>One Final Note on Security</h3> Before committing your new changes to your source control, please make sure that you modify ‘config/initializers/site_keys.rb’ and blank out ‘REST_AUTH_SITE_KEY’. This key is used to generate your encrypted passwords, and if it gets out you are more vulnerable to attack. </article> <article> <h1>Refreshed; Source Code Included</h1> 2009-06-16T22:19:04Z After a lot of thought about what the heck I want to be doing with the little spare time I can find, I made the decision to dust the dandruff off of my site and start over. This time around, we’ll focus only on technical related issues. Should I want to discuss politics or religion, separate blogs will be spawned. I was taking a look at my old blog’s archives, and realized that I was writing a whole lot about nothing. Since the blog was originally intended to be personal, you could imagine how it meandered. When I write about personal stuff, the juicy stuff never gets put down. I have a lot of wild ideas, most of which I just don’t think the general culture is ready for ;-) To help maintain the technical focus, I’ll be releasing the source code that powers this site as well as writing articles to discuss the changes as they happen. It won’t be mind blowing, but it’ll help constrain. <a href="/projects/1">Here ya go</a>. </article> </main></body></html>