listalicious 0.1.0 → 0.3.0

data/README.textile

@@ -4,9 +4,7 @@ Semantic listing; a semantic way to build datagrid structures in Rails.
 
 h2. The Story
 
-Ok, so I really liked what came of my navigasmic gem, and it's proved itself useful and flexible.  I'm also working on unifying some aspects of a CMS and decided that datagrids should be unified to some degree so I can simplify the generators, make broad changes if I need to, and have a potentially more efficient way to create them.
-
-So I started this project to do just that.  I quickly learned that datagrids aren't especially easy to make amazing, and there's a lot of things that one might want to do with them... grouping (with a row that creates a separator), sorting, ordering, additional informational rows, footers, ajax pagination, etc. etc. etc.. The list is actually pretty long, and I wrote a lot of those things, but it's nowhere near perfect.  I sort of don't think it's possible with how I've approached it this time around.  Anyhow, I thought I could get something to a point that simplified the datagrid process, and I believe I've succeeded in providing a good start.  I opted out of adding several features for the time being until I need them -- at which point I might have a better understanding of how I could approach it better.  I cover some of my thoughts below in this document.
+I started this project to create a pretty simple and clean way to create datagrids.  I quickly learned that datagrids aren't especially easy to make amazing, and there's a lot of things that one might want to do with them... grouping (with a row that creates a separator), sorting, ordering, additional informational rows, footers, ajax pagination, etc. etc. etc.. The list is actually pretty long, but I've only written a few of those things.  This is a good start, and if it doesn't contain the features you're looking for feel free to fork and add them.
 
 So, as always, I set up some requirements for what the project should do, and here's what I came up with (a lot of these are standard):
 
@@ -22,13 +20,13 @@ So, as always, I set up some requirements for what the project should do, and he
 I wrote a DSL that met those requirements:
 
 <pre>
-  <% semantic_list_for @users do |l| %>
+  <% semantic_list_for @users, :as => :user do |l| %>
     <%= l.head do %>
-      <%= l.column 'Name', :sort => 'last_name' %>
-      <%= l.column 'Email Address' %>
+      <%= l.column 'User Login' %>
+      <%= l.column 'Email' %>
     <% end %>
     <%= l.columns do |user, index| %>
-      <%= l.column "#{user.first_name} #{user.last_name}" %>
+      <%= l.column :login %>
       <%= l.column link_to(user.email, "mailto:#{user.email}") %>
       <%= l.controls link_to('edit', edit_user_path(user)) %>
     <% end %>
@@ -38,22 +36,22 @@ I wrote a DSL that met those requirements:
   <% end %>
 </pre>
 
-I liked this, but could it be reduced further if the use case allowed?  I came up with the following, which simplifies it, but comes with a minor snag.  Note the line that instantiates a new User object.  This is needed if there's no objects in the collection you pass it, because it needs to know about the object while it's building the columns.
+I liked this, but could it be reduced further if the use case allowed?  I came up with the following (which outlines the different ways you can pass args)
 
 <pre>
-  <% semantic_list_for @users do |l| %>
+  <% semantic_list_for @users, :as => :user do |l| %>
     <%= l.columns [:head, :body] do |user, index| %>
-      <% user ||= User.new # this DSL requires a user object to be here %>
-      <%= l.column user.login, :title => 'Login', :sort => 'login' %>
-      <%= l.column user.email, :title => 'Email Address', :sort => 'email' %>
+      <%= l.column :login, :title => 'User Login' %>
+      <%= l.column "#{user.first_name} #{user.last_name}", :title => 'Name' %>
+      <%= l.column :email, { link_to user.email, "mailto:#{user.email}" } %>
       <%= l.controls link_to('edit', edit_user_path(user)) %>
     <% end %>
   <% end %>
 </pre>
 
-Clearly there's some ups and downs here, so I implemented both DSLs and leave it to your discretion to figure out which one is best to use in your case.
+I implemented both DSLs and leave it to your discretion on which one is best to use in your case.
 
-Since using builders on previous projects has worked out fairly well, I ventured down that path again.  There's a single builder provided for now, TableBuilder (which inherits from GenericBuilder).  GenericBuilder provides some basic functionality (ordering links for example), and isn't intended to be used as a builder by itself.  And of course, the builders can always be extended or replaced if you need more custom markup.
+Since using builders on previous projects has worked out fairly well, I tried the same thing here.  There's a single builder provided for now, TableBuilder (which inherits from GenericBuilder).  GenericBuilder provides some basic functionality (ordering links for example), and isn't intended to be used as a builder by itself.  And as always, the builders can be extended or replaced if you need more custom markup.
 
 h2. Installation
 
@@ -69,33 +67,26 @@ Then install the listalicious gem:
   sudo gem install listalicious
 </pre>
 
-If you would like to get the default JS and CSS files you can use the generator after installing:
-
-<pre>
-  [no javascript or css provided yet]
-</pre>
-
 h2. Usage
 
-Listalicious works fine just as a view helper, but it also handles ordering of the lists.  If you plan on using ordering in the lists you'll have to add a bit to the model and controller.  All of the methods are added to the model by using sortable_fields, and the :order option on finders can be generated by using sort_order_from in the controller.
+Listalicious works fine as a simple view helper, but it also handles ordering of the lists as well.  To add ordering to any list just use the order_from named scope with your find method.  You can also specify fields that are allowed to be ordered in your model by using the orderable_fields method.
 
-h3. Models
+h3. Controllers
 
 <pre>
-  class User < ActiveRecord::Base
-    # communicates to Listalicious how a list of this model can be ordered
-    sortable_fields :first_name, :last_name, :login, :email, :default => :login
+  def index
+    @user = User.ordered_from(params).paginate :page => params[:page], :per_page => 20
+    # respond ...
   end
 </pre>
 
-h3. Controllers
+h3. Models
 
 <pre>
-  def index
-    @users = User.paginate :page => params[:page], :per_page => 2, :order => User.sort_order_from(params)
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @users }
+  class User < ActiveRecord::Base
+    orderable_fields do
+      only :first_name, :last_name, :login, :email
+      default :login, :desc, :stable => true
     end
   end
 </pre>
@@ -104,16 +95,13 @@ h3. Views (I prefer HAML, so no ERB examples, but it should work with ERB fine a
   
 It's important to note that all the methods take blocks or content strings.  For instance, look at the extra and controls methods in the simple usage example.
 
-It's also important to notice that the controls cell is not being counted in the columns.  This is because I position these absolutely and do a hover event on them.. I'll likely take this out shortly so it doesn't effect anyone else.
-
 *Simple Usage*
 
 <pre>
-  - semantic_list_for @users, :html => {:class => 'list'} do |l|
+  - semantic_list_for @users, :as => :user, :html => {:class => 'list'} do |l|
     = l.columns [:head, :body] do |user, index|
-      - user ||= User.new # this method requires a user object
-      = l.column user.login, :title => 'Login', :sort => 'login', :width => '20%'
-      = l.column user.email, :title => 'Email Address', :sort => 'email'
+      = l.column :login, :width => '20%'
+      = l.column :email, :title => 'Email Address'
       = l.extra do
         = "You can add more information about #{user.first_name} here."
       = l.controls link_to('edit', edit_user_path(user))
@@ -134,7 +122,7 @@ It's also important to notice that the controls cell is not being counted in the
         <td class="controls"><a href="/users/1/edit">edit</a></td>
       </tr>
       <tr class="even">
-        <td colspan="2">You can add more information about Jeremy here.</td>
+        <td colspan="3">You can add more information about Jeremy here.</td>
       </tr>
       <tr class="odd">
         <td>user1</td>
@@ -142,7 +130,7 @@ It's also important to notice that the controls cell is not being counted in the
         <td class="controls"><a href="/users/2/edit">edit</a></td>
       </tr>
       <tr class="odd">
-        <td colspan="2">You can add more information about User here.</td>
+        <td colspan="3">You can add more information about User here.</td>
       </tr>
     </tbody>
   </table>
@@ -168,7 +156,7 @@ It's also important to notice that the controls cell is not being counted in the
   <table class="semantic-list" id="user_list">
     <thead>
       <tr class="header">
-        <th width="20%"><a class="sort-ascending" href="?user_sort_asc=last_name">Name</a></th>
+        <th width="20%"><a class="sort-ascending" href="?user_sort_desc=last_name">Name</a></th>
         <th>Email Address</th>
       </tr>
     </thead>
@@ -186,7 +174,7 @@ It's also important to notice that the controls cell is not being counted in the
     </tbody>
     <tfoot>
       <tr>
-        <th colspan="2">
+        <th colspan="3">
           <div class="pagination">[removed for your sanity]</div>
         </th>
       </tr>
@@ -197,39 +185,39 @@ It's also important to notice that the controls cell is not being counted in the
 *Grouping* -- You can group lists, and this will add extra header rows as separators.  This will include sort links if those were provided as well.
 
 <pre>
-  - semantic_list_for @users, :group_by => :login do |l|
+  - semantic_list_for @users, :as => :user, :group_by => :login do |l|
 </pre>
 
 *Sorting* -- Sorting requires javascript.  It's part of the javascript code that comes with Listalicious and requires Prototype.js.  If you want to add sorting to the list, just provide a url for a sort action and it will put that into the HTML5 data-sorturl attribute.  You can use your own javascript if you would like.
 
 <pre>
-  - semantic_list_for @users, :sort_url => { :action => 'sort' } do |l|
+  - semantic_list_for @users, :as => :user, :sort_url => { :action => 'sort' } do |l|
 </pre>
 
-*Additional JS Functionality* -- There a few functions that are javascript specific.  You can add any additional functionality this way as well, since we're using unobtrusive JS to get the following features accomplished.
+*Additional JS Functionality* -- There a few functions that are javascript specific.  You can add any additional functionality this way as well since we're using unobtrusive JS to get the following features accomplished.
 
 You can make the list multi-selectable.  There isn't any pre-bundled functionality to do actions on the selected items, but you can fetch the list of selected items by using JS.
 
+TODO: Document usage here
+
 <pre>
-  - semantic_list_for @users, :selectable => true do |l|
+  - semantic_list_for @users, :as => :user, :selectable => true do |l|
 </pre>
 
 You can make the "extra" information rows expandable.  If you add this, the extra rows won't show unless the row they belong to is highlighted.
 
 <pre>
-  - semantic_list_for @users, :expandable => true do |l|
+  - semantic_list_for @users, :as => :user, :expandable => true do |l|
 </pre>
 
 h3. UL / OL Datagrids
 
-The nature of doing a UL / OL based datagrid requires a certain level of CSS, and I haven't had time or reason to provide that level yet.  When I finish up this project and include the JS and CSS needed for it (in a generator) I may add a builder for this, but there isn't one currently.
+The nature of doing a UL / OL based datagrid requires a certain level of CSS, and I haven't had time or reason to provide that level yet.  When I finish up this project and include the JS and CSS needed for it (in a generator) I may add a builder for this, but there isn't plans for one currently.
 
 h3. Other
 
 It's important to note that a lot of the functionality of these lists do not play nicely with one another -- I don't believe this is a shortcoming, and consider it more an effort to avoid overkill.  A good example of this is the sortable features.  For example, if you need the extra information and sorting together, you should consider using the :expandable => true option.  Grouping and sorting don't play together nicely for obvious reasons as well.  The javascript handles moving the extra container, in sorting, but doesn't attempt to do it gracefully.  If I do the ListBuilder (UL/OL) to compliment the TableBuilder, it would likely handle these things somewhat better, but I haven't had a need for it yet.
 
-I'm kicking around plans for how to make it more featureful without the annoying conflicts mentioned above.  If you have any thoughts let me know, but I expect my solution will come by breaking up the builders by features.. So, instead of having a single TableBuilder, there would be a SortableTableBuilder, and an InformationalTableBuilder, and a MultiSelectTableBuilder, etc.. not sure how that would play out, but that's what I'm thinking might resolve some of the annoyances mentioned above.
-
 And, as always, you can create your own builder by extending one of the existing ones, or by creating one from scratch.
 
 Then just specify your builder, or do it as a configuration.
@@ -246,11 +234,7 @@ h2. Documentation
 
 RDoc documentation _should_ be automatically generated after each commit and made available on the "rdoc.info website":http://rdoc.info/projects/jejacks0n/listalicious.
 
-Documentation is pretty sparse right now.
-
-h2. Compatibility
-
-I'm only testing with the latest Rails 2.4.x stable release, and it should work under Rails 2.3.x as well.  Feel free to add backwards compatibility if you need it.
+Documentation is pretty sparse right now, and I'm working to resolve it.
 
 h2. Project Info
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.3.0

data/lib/builders/generic_builder.rb

@@ -5,28 +5,33 @@ module Listalicious
 
     def initialize(template, collection, options = {}, &proc)
       @template, @collection, @options = template, collection, options
-      @object_name = collection.first.class.name.underscore unless collection.empty?
+      @object_name = "#{options[:as] || collection.first ? collection.first.class.name.underscore : ''}"
+      @table_name = (options[:table_name] || @object_name.pluralize).to_s
 
       render(options.delete(:html), &proc)
     end
 
     def render(options, &proc); end
 
-    def sortable_link(contents, field)
-      sort_url, sort_direction = sortable_params(field)
-      template.content_tag(:a, contents, :href => "?#{sort_url}", :class => "sort-#{sort_direction == 'descending' ? 'ascending' : 'descending'}")
-    end
+    # Creates the anchor tag for the orderable links.
+    # It looks in the params for specificly styled query params:
+    #
+    # eg. order[users][]=login:asc&order[users][]=first_name:asc
+    def orderable_link(contents, field)
+      return contents if @object_name.empty?
 
-    def sortable_params(field)
-      object_name = @object_name.nil? ? '' : "#{@object_name}_"
+      order_params = (template.params['order'] || {})[@table_name]
+      fields = Hash[*order_params.to_a.collect { |field_and_dir| field_and_dir.split(':') }.flatten]
 
-      params = template.params.reject { |param, value| ['action', 'controller', "#{object_name}sort_desc"].include?(param) }
-      direction = params.delete("#{object_name}sort_asc") == field.to_s ? 'descending' : 'ascending'
-      method = direction == 'descending' ? "#{object_name}sort_desc" : "#{object_name}sort_asc"
-      params[method] = field
+      order_params = (template.params['order'] || {}).clone.
+          merge({@table_name => ["#{field}:#{"#{fields[field] == 'asc' ? 'desc' : 'asc'}"}"]})
 
-      [params.to_query, direction]
-    end
+      query = template.params.reject{ |param, value| ['action', 'controller'].include?(param) }
+      query.merge!('order' => order_params)
 
+      template.content_tag(:a, contents,
+                :href => "?#{query.to_query}",
+                :class => "#{fields[field] ? fields[field] == 'asc' ? 'ascending' : 'descending' : ''}")
+    end
   end
 end

data/lib/builders/table_builder.rb

@@ -40,7 +40,7 @@ module Listalicious
 
     def column_group_head(options = {}, &proc)
       @column_count = 0
-      
+
       @head_wrapper = template.content_tag(:tr, template.capture(collection.first, 0, &proc),
                          options[:html].merge({:class => template.add_class(options[:html][:class], 'header')}))
       template.content_tag(:thead, @head_wrapper, options.delete(:wrapper_html))
@@ -51,7 +51,8 @@ module Listalicious
       return unless collection.first.present?
       collection.each_with_index do |record, index|
         @column_count = 0
-        
+        @object = record
+
         if @options[:grouped_by]
           buffer << @head_wrapper if record[@options[:grouped_by]] != @last_row_grouping
           @last_row_grouping = record[@options[:grouped_by]]
@@ -61,7 +62,7 @@ module Listalicious
         buffer << template.content_tag(:tr, template.capture(record, index, &proc),
                      options[:html].merge({:class => template.add_class(options[:html][:class], @cycle)}))
         buffer << template.content_tag(:tr, @extra,
-                     options[:html].merge({:class => template.add_class(options[:html][:class], @cycle)})) if @extra.present?
+                     options[:html].merge({:class => template.add_class(options[:html][:class], [@cycle, 'extra'])})) if @extra.present?
         @extra = nil
       end
       template.content_tag(:tbody, buffer, options.delete(:wrapper_html))
@@ -93,9 +94,6 @@ module Listalicious
       options[:html] ||= {}
       options[:html][:colspan] ||= @column_count
 
-      options[:wrapper_html] ||= {}
-      options[:wrapper_html][:class] = template.add_class(options[:wrapper_html][:class], 'full-column')
-
       @extra = self.send("#{@current_scope}_column", contents, options)
     end
 
@@ -118,9 +116,6 @@ module Listalicious
       options[:html] ||= {}
       options[:html][:colspan] ||= @column_count
 
-      options[:wrapper_html] ||= {}
-      options[:wrapper_html][:class] = template.add_class(options[:wrapper_html][:class], 'extra')
-
       @extra = self.send("#{@current_scope}_column", contents, options)
       ''
     end
@@ -128,21 +123,24 @@ module Listalicious
     def head_column(contents, options = {})
       options[:html] ||= {}
       options[:html][:width] ||= options[:width]
-      
-      contents = sortable_link(contents, options[:sort]) if options[:sort]
+
+      contents = contents.to_s.humanize.titleize if contents.is_a? Symbol
+      contents = orderable_link(contents, options[:sort]) if options[:sort]
 
       template.content_tag(:th, contents, options.delete(:html))
     end
 
     def body_column(contents, options = {})
+      contents = @object.send(contents) if @object && contents.is_a?(Symbol)
+
       template.content_tag(:td, contents, options.delete(:html))
     end
 
     def foot_column(contents, options = {})
-      contents = sortable_link(contents, options[:sort]) if options[:sort]
+      contents = orderable_link(contents, options[:sort]) if options[:sort]
 
       template.content_tag(:th, contents, options.delete(:html))
     end
-    
+
   end
 end

data/lib/listalicious.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
-require File.join(File.dirname(__FILE__), *%w[builders generic_builder])
-require File.join(File.dirname(__FILE__), *%w[builders table_builder])
+require 'builders/generic_builder'
+require 'builders/table_builder'
 
 module Listalicious #:nodoc:
 
@@ -13,23 +13,23 @@ module Listalicious #:nodoc:
     @@builder = ::Listalicious::TableBuilder
     mattr_accessor :builder
 
-    def semantic_list_for(collection, *args, &proc)
+    def semantic_list_for(collection, options, &proc)
       raise ArgumentError, "Missing block" unless block_given?
 
-      options = args.extract_options!
+      # TODO: should :as be required?
 
       options[:html] ||= {}
       options[:html][:class] = add_class(options[:html][:class], 'semantic-list')
-      options[:html][:id] ||= collection.first ? "#{collection.first.class.name.underscore}_list" : 'semantic_list'
-
-      options[:html][:class] = add_class(options[:html][:class], 'actionable') if options[:actionable]
-      options[:html][:class] = add_class(options[:html][:class], 'selectable') if options[:selectable]
+      options[:html][:id] ||= "#{options[:as] || collection.first ? collection.first.class.name.underscore : 'semantic'}_list"
 
       if options[:sort_url]
         options[:html][:class] = add_class(options[:html][:class], 'sortable')
         options[:html]['data-sorturl'] = url_for(options[:sort_url])
       end
 
+      options[:html][:class] = add_class(options[:html][:class], 'selectable') if options[:selectable]
+      options[:html][:class] = add_class(options[:html][:class], 'expandable') if options[:expandable]
+
       builder = options[:builder] || TableBuilder
       builder.new(@template, collection, options, &proc)
     end
@@ -43,35 +43,105 @@ module Listalicious #:nodoc:
 
   module ActiveRecordExtensions # :nodoc:
 
-    def self.included(base) # :nodoc:
-      return if base.kind_of?(::Listalicious::ActiveRecordExtensions::ClassMethods)
-      base.class_eval do
-        extend ClassMethods
-      end
+    # Makes a given model orderable for lists
+    #
+    # To specify that a model behaves according to the Listalicious order style call orderable_fields.  The
+    # orderable_fields method takes a configuration block.
+    #
+    # === Example
+    # orderable_fields do
+    #   only :first_name, :last_name
+    #   default :last_name
+    # end
+    #
+    # === Configuration Methods
+    # [only]
+    #   Provide fields that are orderable.
+    # [except]
+    #   Provide fields that are not orderable, with the default list being all fields.
+    # [default]
+    #   Provide the default sort field, optionally a direction, and additional options.
+    #
+    # *Notes*:
+    # * If +only+ or +except+ are not called within the block, all fields on the model will be orderable, this includes
+    #   things like id, and password/password salt columns.
+    # * If +default+ isn't called, the first field will be considered the default, asc being the default direction.
+    #
+    def orderable_fields(&config_block)
+      cattr_accessor :orderable_fields, :default_order
+
+      # make all columns orderable, incase only or except aren't called in the configuration block
+      self.orderable_fields = column_names.map { |column_name| column_name.to_s }
+
+      instance_eval(&config_block)
+      self.orderable_fields.collect!{ |field| field.to_s }
+
+      self.default_order ||= {:field => self.orderable_fields.first, :direction => :desc}
+      
+      attach_orderable_scopes
     end
 
-    module ClassMethods
-
-      attr_accessor :default_sort_field
-
-      def sortable_fields(*args)
-        options = args.extract_options!
-        @acceptable_sort_fields = args
-        @default_sort_field = options[:default]
-      end
+    # Provide fields that are orderable in the configuration block.
+    #
+    # *Note*: If +only+ or +except+ aren't called from within the configuration block, all fields will be orderable.
+    #
+    # === Example
+    # only :last_name, :email_address
+    def only(*args)
+      self.orderable_fields = args
+    end
 
-      def acceptable_sort_field?(column)
-        column.present? ? @acceptable_sort_fields.include?(column.to_sym) : false
-      end
+    # Provide fields that are not to be orderable, with the default list being all fields.
+    #
+    # *Note*: If +only+ or +except+ aren't called from within the configuration block, all fields will be orderable.
+    #
+    # === Example
+    # * except :id, :password
+    def except(*args)
+      self.orderable_fields - args
+    end
 
-      def sort_order_from(params)
-        field = params["#{self.name.underscore}_sort_asc"] || params["#{self.name.underscore}_sort_desc"]
-        field = @default_sort_field.to_s unless acceptable_sort_field?(field)
+    # Provide the default sort field, optionally a direction, and additional options.
+    #
+    # === Supported options
+    # [:stable]
+    #   Will force appending the default sort to the end of all sort requests.  Default is false.
+    #
+    # === Example
+    #   default :first_name (direction defaults to :asc)
+    #   default :first_name, :stable => true
+    #   default :first_name, :desc, :stable => true
+    def default(*args)
+      options = args.extract_options!
+      field = args.shift
+      direction = args.shift || :asc
 
-        method = (params["#{self.name.underscore}_sort_desc".to_sym] == field) ? 'DESC' : 'ASC'
-        "#{field} #{method}" unless field.blank?
-      end
+      self.default_order = {:field => field, :direction => direction, :options => options}
+    end
 
+    # Attaches the ordered_from named scope to the model requesting it.  The named scope can be chained in the
+    # controller by using:
+    #
+    # +Users.ordered_by(params).paginate :page => params[:page], :per_page => 2+
+    #
+    # The params are expected to be in a specific style:
+    #
+    # eg. order[table_name][]=last_name:desc&order[table_name][]=first_name:asc
+    #
+    # Which will generate the order clause +"last_name DESC, first_name ASC"+.
+    def attach_orderable_scopes
+      self.named_scope :ordered_from, lambda { |params|
+        return unless params.include?(:order) and params[:order][self.table_name.to_sym]
+
+        fields = params[:order][self.table_name.to_sym].collect do |field_and_dir|
+          field, dir = field_and_dir.split(':')
+          self.orderable_fields.include?(field) ? [field, dir.to_s.downcase] : nil
+        end.compact
+
+        fields.empty? ?
+          nil :
+          {:order => fields.map{ |field, dir| "#{field} #{dir.downcase == 'desc' ? 'DESC' : 'ASC'}" }.join(', ')}
+      }
     end
 
   end
@@ -79,4 +149,4 @@ module Listalicious #:nodoc:
 end
 
 ActionController::Base.helper Listalicious::SemanticListHelper
-ActiveRecord::Base.class_eval { include ::Listalicious::ActiveRecordExtensions }
+ActiveRecord::Base.extend Listalicious::ActiveRecordExtensions

data/listalicious.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{listalicious}
-  s.version = "0.1.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jeremy Jackson"]
-  s.date = %q{2010-01-24}
+  s.date = %q{2010-03-02}
   s.description = %q{Semantic listing; a semantic way to build datagrid structures in Rails.}
   s.email = %q{jejacks0n@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: listalicious
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jeremy Jackson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-24 00:00:00 -07:00
+date: 2010-03-02 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency