Pete On Rails

VoteFu gets a couple enhancements

The lastest version of VoteFu has a few useful enhancements:

1. Protect against mass assignment forgery. The params hash will only be consulted for :vote => true or false. The rest has to be assigned in the controller.
2. The acts_as_voteable mixin now has support for tallying votes.

The documentation will be updated tonight, but briefly, here is what you can do with the new tally() method:

1
2
3
4
5
6
7
8

@items = Item.tally(
  {  :at_least => 1, 
      :at_most => 10000,  
      :start_at => 2.weeks.ago,
      :end_at => 1.day.ago,
      :limit => 10,
      :order => "items.name desc"
  })

This will select the Items with between 1 and 10,000 votes, the votes having been cast within the last two weeks (not including today), then display the 10 last items in an alphabetical list.

More to come. Enjoy!

Posted in Code, Rails, Ruby |

You are invited to my open alpha of MyQuotable.com

Quotes. I love quoting people. I have a ton of quotes saved in text files, on my blog, in my various mood messages on IM platforms, and who-know-where-else.

I decided to build an application to manage, organize, and syndicate quotes. You can read more about it on my project page for MyQuotable.

If you read this blog, you are invited to participate in my open alpha of MyQuotable.com.

Early Alpha image of myquotable.com

Posted in Business, Code, Rails, Ruby, Software Development, Uncategorized |

acts-as-taggable-on and space delimited tag lists

UPDATE:

I made the classic coder mistake, and didn’t dig into the plugin code before working around it. I am leaving this post up instead of being embarrassed and deleting it because it a good example of why you should read your plugin code. After reading the code, I found that TAGLIST IS JUST AN ARRAY: you can simply do this and avoid all of the filter magic that I put in place below.

1
2

  # in config/initializers/tag_list.rb
  TagList.delimiter = " "

Drat. That’s way better.

As it turns out, this answer is in the README for acts_as_taggable_on_steroids, but not in acts_as_taggable_on. I’m sending Michael a note to ask him to include that detail in the documentation.

Original Post

Michael Bleigh’s acts_as_taggable_on plugin is a useful extension of acts_as_taggable_on_steroids.

When using it in forms, however, many users have noticed that the @model.tag_list field deals with comma separated lists of tags, like so:

1
2

# From the README
@user.tag_list = "awesome, slick, hefty"      # this should be familiar

If, in your edit view template, you provide a text field for your users to type in freeform tags, then you will find that your database tables have multiword tags instead of multiple tags. This is less than ideal. Users do not like to type commas.

Build your form like this, and you will see the issue when a user types in “awesome slick hefty” in the input box.

<% form_for([@model]) do f %>
    <div id="model_tags">
	Tags: <%= f.text_field :tag_list %> 		
    </div>
...
<% end %>

You will see this in your DB:

+----+-----------------------------------+
| id | name                              |
+----+-----------------------------------+
|  1 | awesome slick hefty               | 
+----+-----------------------------------+

What you wanted was this:

+----+-----------------------------------+
| id | name                              |
+----+-----------------------------------+
|  1 | awesome                           | 
|  2 | slick                             | 
|  3 | hefty                             | 
+----+-----------------------------------+

The Answer

My workaround involves using a before_filter to unroll the content of the input box, and a compactor method in the edit action to change the internal storage format of acts_as_taggable_on to the format that the user expects. Here is an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# ... In the taggable_controller
  before_filter :join_tag_list, :only => [:create, :update]
 
  # GET /users/:id/quotes/1/edit
  def edit 
    @model ||= Model.find(params[:id])
    unroll_tag_list
  end
 
  private
  def join_tag_list
    # Split the tags on spaces and join into comma separated format
    params[:model][:tag_list] = params[:model][:tag_list].split(" ").join(",")
  end
 
  def unroll_tag_list
    # Split the tags on commas and join into a single space separated string
    @model.tag_list = @model.tag_list.join(" ")    
  end

That’s it! Now my users see and work with space-separated tags, and acts_as_taggable_on continues to store comma separated lists internally.

Posted in Code, Rails |

Announcing VoteFu

VoteFu is a voting mixin that allows you to extend your models to vote on one another. Largely based on Cosmin Radoi’s acts_as_voteable plugin, VoteFu adds named_scope support, a set of generators to make using the plugin easier, a :polymorphic association to the voting class (so you can have more than one model type perform votes), and some enhancements for Rails 2.1.

I have simplified the code it requires to cast a vote down from three to one. After setting up your models with the proper mixin functionality, you can cast votes like this:

1
2
3
4
5

   voter.vote_for(voteable)
   # OR
   voter.vote_against(voteable)
  # OR
   voter.vote(voteable, [true | false] )

You can also use the old acts_as_voteable sytnax (which will continue to be supported):

1
2
3
4

  vote = Vote.new(:vote => true)
  m    = Model.find(params[:id])
  m.votes    << vote
  user.votes << vote

I hope you find the plugin useful. Comments and feedback welcome. If there is enough demand, I’ll open up a lighthouse project to track issues.

Grab the code from GitHub or visit the VoteFu Page.

Posted in Code, Rails |