GitHub Repo

Heroku App

I was originally going to create the episode 40 blocks in view, but there was a comment mentioning that episode 208 was the updated version. I did watch episode 40 nonetheless, and I noticed how much Rails has improved. The way to create a block in view in Rails 2 was by concatenating and using a block.binding. This seems like a hack compared today’s Rails standard.

For comparison the code for episode 40

def admin_area(&block)
  concat content_tag(:div, capture(&block), :class => 'admin'), block.binding if admin?
end

Episode 208

def admin_area(&block)
  content_tag(:div, :class => "admin", &block) if admin?
end

The line for the episode 208 was shorter because it eliminated concat capture() and block.binding. concat was rendered unnecessary after ERB used the <%= %> tag to signify whether or not the output would be rendered to the view. capture() tried to capture the output of a block’s yield. The content_tag now is able to accept a block as an argument without the need for capture(). block.binding binds to the erb templating. I’m not sure why this became unnecessary, but I suspect the revision of erb fixed this.

Assets Precompile

While pushing to Heroku the CSS I wrote for the admin_area was not being rendered. I eventually found the answer on StackOverflow. I did not have the rails_12factor gem. After further reading of the README for rails_12factor, rails_12factor allows static assets to be retrieved despite using a proxy like Nginx. A proxy like Nginx routes the asset path of assets/rails.png to public/assets/rails.png. Rails 4 is sort of encouraging the use of a CDN to host static assets. The Readme also linked to the ’12factor’ methodology which seems to touch on devops.

The GitHub Repo

The Heroku App

What I love about following the Railscasts and actually implementing the small features is that making these apps are quick, I’m exposed to something I wouldn’t have been otherwise, and they are straightforward. This episode was no different.

preview_button

<%= submit_tag 'Preview', name: 'preview_button' %>

The Preview button is similar to the the submit button, but it differs in it function. The name for the button defaults to commit when using the submit_tag helper. This is good when you need to create a normal submit button to create or update a record, but in the case of a preview button, you do not want to save the record just yet. Instead of having the name='commit we override this default by specifying the name should be equal to preview_button. With the name now equalling preview_button the parameters hash has "preview_button" => "Preview".

Controller

def create
...
  respond_to do |format|
    if params[:preview_button] || !@project.save
      format.html { render action: 'new' }
      format.json { render json: @project.errors, status: :unprocessable_entity }
    else
      format.html { redirect_to @project, notice: 'Project was successfully created.' }
      format.json { render action: 'show', status: :created, location: @project }
    end
  end
end

We can then use the params[:preview_button] within our conditional in the create action. If params[:preview_button] is not nil, then the controller will redirect to the new view while still having the preview_button parameter present in the URL. If there is no params[:preview_button] defined, then we know that the form was submitted through the normal submit button and not the preview button.

Textilize

<% if params[:preview_button] %>
  <div id="preview">
    <h2><%= @project.name %></h2>
    <%= textilize @project.description %>
  </div>
<% end %>

When we are redirected to the new view, the params[:preview_button] is still defined. We can use this in another conditional within our view to display a preview. Here we are previewing the project’s description using the textilize text helper. This was deprecated back in Rails 2, but I found a gem that dropped in to Rails 3+ that adds this back. There has to be a reason that the Rails Core Team deprecated this, so I do not plan to use this again. Instead I might reuse the code I used to render markdown to the view from my Markdown Todo List Rails API App

The GitHub Repo

The Heroku App

Form

<%= form_tag projects_path, method: :get do %>
<p>
  <%= text_field_tag :search, params[:search] %>
  <%= submit_tag 'Search', name: nil %>
</p>
<% end %>

The form for the search form has many lessons to learn. The use of form_tag over form_for is preferred we are not updating attributes associated with a specific model. Here the form_tag submits to the projects path. Normally when you submit a form using the form_for or form_tag Rails helper Rails create the html tags with a post method filled in. When you submit a post request to the projects path, Rails thinks you are trying to create a new record because of the RESTful design. To counteract this you have to explicitly specify the method used on this form, in this case get.

Controller

def index
  @projects = Project.search(params[:search])
end

Instead of the usual Project.all, we use a search method that we defined in the project model. The search method accepts a argument that is matched with records in the database.

Model

class Project < ActiveRecord::Base
  def self.search(search)
    if search
      if Rails.env.development?
        where("name LIKE ?", "%#{search}%")
      elsif Rails.env.production?
        where("name ILIKE ?", "%#{search}%")
      end
    else
      all
    end
  end
end

This is where most of the work is being done. Here we are defining a class method called search which accepts one parameter. If this parameter is true, then it will search for a name similar to the search argument. There is a conditional based on the environment because the LIKE function in SQLite3 used in development is case insensitive, while the LIKE function in PostgreSQL used in Production is case sensitive. PostgreSQL LIKE To counteract this, I have included the ILIKE function for only the production environment.

The "%#{search}%" confused me, so I asked on StackOverflow about what the % was. Apparently it is SQL Wildcards used to match characters in a string. It is similar to how Regex pattern matches, but SQL Wildcards are much simpler. It appears there are only four syntaxes that can be used. %, _, [], [^]. The % substitute zero or more characters. _ substitutes a single character. [] matches sets or ranges of characters. Example: [abc]% matches anything that starts with abc. Similar to regex you use ^ to declared not. [abc]% matches anything that does NOT start with abc. Similar to Regex, so this was not too mind blowing. The tricky part was learning the syntax used.