listalicious 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jeremy Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,260 @@
+h1. Listalicious
+
+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.
+
+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):
+
+* Should be simple
+* Should be easily customizable
+* Should handle sorting
+* Should handle grouping
+* Should handle ordering columns
+* Should handle additional informational rows
+* Should be pleasant to use
+* Should use less code to create than it generates
+
+I wrote a DSL that met those requirements:
+
+<pre>
+  <% semantic_list_for @users do |l| %>
+    <%= l.head do %>
+      <%= l.column 'Name', :sort => 'last_name' %>
+      <%= l.column 'Email Address' %>
+    <% end %>
+    <%= l.columns do |user, index| %>
+      <%= l.column "#{user.first_name} #{user.last_name}" %>
+      <%= l.column link_to(user.email, "mailto:#{user.email}") %>
+      <%= l.controls link_to('edit', edit_user_path(user)) %>
+    <% end %>
+    <%= l.foot do %>
+      <%= l.full_column will_paginate(@users) %>
+    <% end %>
+  <% 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.
+
+<pre>
+  <% semantic_list_for @users 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.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.
+
+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.
+
+h2. Installation
+
+The gem is hosted on gemcutter, so *if you haven't already*, add it as a gem source:
+
+<pre>
+  sudo gem sources -a http://gemcutter.org/
+</pre>
+
+Then install the listalicious gem:
+
+<pre>
+  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.
+
+h3. Models
+
+<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
+  end
+</pre>
+
+h3. Controllers
+
+<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 }
+    end
+  end
+</pre>
+
+h3. Views (I prefer HAML, so no ERB examples, but it should work with ERB fine as well)
+  
+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|
+    = 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.extra do
+        = "You can add more information about #{user.first_name} here."
+      = l.controls link_to('edit', edit_user_path(user))
+</pre>
+  ...produces...
+<pre>
+  <table class="list semantic-list" id="user_list">
+    <thead>
+      <tr class="header">
+        <th width="20%"><a class="sort-ascending" href="?user_sort_desc=login">Login</a></th>
+        <th><a href="?user_sort_asc=email">Email Address</a></th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr class="even">
+        <td>jejacks0n</td>
+        <td>jeremy@email.com</td>
+        <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>
+      </tr>
+      <tr class="odd">
+        <td>user1</td>
+        <td>user1@email.com</td>
+        <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>
+      </tr>
+    </tbody>
+  </table>
+</pre>
+
+*Extended Usage*
+
+<pre>
+  - semantic_list_for @users do |l|
+    = l.head do
+      = l.column 'Name', :sort => 'last_name', :width => '20%'
+      = l.column 'Email Address'
+    = l.columns do |user, index|
+      = l.column "#{user.first_name} #{user.last_name}"
+      = l.column :html => {:class => 'email'} do
+        = link_to(user.email, "mailto:#{user.email}")
+      = l.controls link_to('edit', edit_protosite_user_path(user))
+    = l.foot do
+      = l.full_column will_paginate(l.collection)
+</pre>
+  ...produces...
+<pre>
+  <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>Email Address</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr class="even">
+        <td>Jeremy Jackson</td>
+        <td class="email"><a href="mailto:jeremy@email.com">jeremy@email.com</a></td>
+        <td class="controls"><a href="/users/1/edit">edit</a></td>
+      </tr>
+      <tr class="odd">
+        <td>User 1</td>
+        <td class="email"><a href="mailto:user1@email.com">user1@email.com</a></td>
+        <td class="controls"><a href="/users/2/edit">edit</a></td>
+      </tr>
+    </tbody>
+    <tfoot>
+      <tr>
+        <th colspan="2">
+          <div class="pagination">[removed for your sanity]</div>
+        </th>
+      </tr>
+    </tfoot>
+  </table>
+</pre>
+
+*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|
+</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|
+</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.
+
+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.
+
+<pre>
+  - semantic_list_for @users, :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|
+</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.
+
+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.
+
+<pre>
+  semantic_list_for @users, :builder => MyCustomBuilder do
+</pre>
+
+<pre>
+  Listalicious::SemanticListHelper.builder = MyCustomBuilder
+</pre>
+
+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.
+
+h2. Project Info
+
+Listalicious is hosted on Github: "http://github.com/jejacks0n/listalicious":http://github.com/jejacks0n/listalicious, and the gem is available on Gemcutter: "http://gemcutter.org/gems/listalicious":http://gemcutter.org/gems/listalicious
+
+
+Copyright (c) Jeremy Jackson, released under the MIT license.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "listalicious"
+    gem.summary = %Q{Semantic lists (datagrids) for Rails}
+    gem.description = %Q{Semantic listing; a semantic way to build datagrid structures in Rails.}
+    gem.email = "jejacks0n@gmail.com"
+    gem.homepage = "http://github.com/jejacks0n/listalicious"
+    gem.authors = ["Jeremy Jackson"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "listalicious #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/builders/generic_builder.rb

@@ -0,0 +1,32 @@
+module Listalicious
+  class GenericBuilder
+
+    attr_accessor :template, :collection
+
+    def initialize(template, collection, options = {}, &proc)
+      @template, @collection, @options = template, collection, options
+      @object_name = collection.first.class.name.underscore unless collection.empty?
+
+      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
+
+    def sortable_params(field)
+      object_name = @object_name.nil? ? '' : "#{@object_name}_"
+
+      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
+
+      [params.to_query, direction]
+    end
+
+  end
+end

data/lib/builders/table_builder.rb

@@ -0,0 +1,148 @@
+module Listalicious
+  class TableBuilder < GenericBuilder
+
+    attr_accessor :template, :collection
+
+    def render(options, &proc)
+      buffer = template.capture(self, &proc)
+      template.concat(template.content_tag(:table, buffer, options))
+    end
+
+    def head(options = {}, &proc)
+      column_group(:head, options, &proc)
+    end
+
+    def body(options = {}, &proc)
+      column_group(:body, options, &proc)
+    end
+
+    def foot(options = {}, &proc)
+      column_group(:foot, options, &proc)
+    end
+
+    def columns(scope = :body, options = {}, &proc)
+      raise ArgumentError, "Missing block" unless block_given?
+
+      if scope.kind_of? Array
+        scope.collect { |scope| column_group(scope, options, &proc) }
+      else
+        column_group(scope, options, &proc)
+      end
+    end
+
+    def column_group(scope, options = {}, &proc)
+      @current_scope = scope
+
+      options[:html] ||= {}
+
+      self.send("column_group_#{scope}", options, &proc)
+    end
+
+    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))
+    end
+
+    def column_group_body(options = {}, &proc)
+      buffer = ''
+      return unless collection.first.present?
+      collection.each_with_index do |record, index|
+        @column_count = 0
+        
+        if @options[:grouped_by]
+          buffer << @head_wrapper if record[@options[:grouped_by]] != @last_row_grouping
+          @last_row_grouping = record[@options[:grouped_by]]
+        end
+
+        @cycle = template.cycle('even', 'odd');
+        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?
+        @extra = nil
+      end
+      template.content_tag(:tbody, buffer, options.delete(:wrapper_html))
+    end
+
+    def column_group_foot(options = {}, &proc)
+      buffer = template.content_tag(:tr, template.capture(collection.first, 0, &proc), options[:html])
+      template.content_tag(:tfoot, buffer, options.delete(:wrapper_html))
+    end
+
+    def column(*args, &proc)
+      options = args.extract_options!
+      contents = options == args.first ? nil : args.first
+
+      if @current_scope == :body
+        contents = template.capture(self, &proc) if block_given? && collection.first.present?
+      else
+        contents = options[:title] || contents
+      end
+
+      @column_count = @column_count + 1
+      self.send("#{@current_scope}_column", contents, options)
+    end
+
+    def full_column(contents = nil, options = {}, &proc)
+      raise ArgumentError, "Must provide a string or a block" if !block_given? && contents.nil?
+      contents ||= template.capture(self, &proc)
+
+      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
+
+    def controls(contents = nil, options = {}, &proc)
+      return unless @current_scope == :body
+      raise ArgumentError, "Must provide a string or a block" if !block_given? && contents.nil?
+      contents ||= template.capture(self, &proc)
+
+      options[:html] ||= {}
+      options[:html][:class] = template.add_class(options[:html][:class], 'controls')
+
+      self.send("#{@current_scope}_column", contents, options)
+    end
+
+    def extra(contents = nil, options = {}, &proc)
+      return unless @current_scope == :body
+      raise ArgumentError, "Must provide a string or a block" if !block_given? && contents.nil?
+      contents ||= template.capture(self, &proc)
+
+      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
+
+    def head_column(contents, options = {})
+      options[:html] ||= {}
+      options[:html][:width] ||= options[:width]
+      
+      contents = sortable_link(contents, options[:sort]) if options[:sort]
+
+      template.content_tag(:th, contents, options.delete(:html))
+    end
+
+    def body_column(contents, options = {})
+      template.content_tag(:td, contents, options.delete(:html))
+    end
+
+    def foot_column(contents, options = {})
+      contents = sortable_link(contents, options[:sort]) if options[:sort]
+
+      template.content_tag(:th, contents, options.delete(:html))
+    end
+    
+  end
+end

data/lib/listalicious.rb

@@ -0,0 +1,82 @@
+# coding: utf-8
+require File.join(File.dirname(__FILE__), *%w[builders generic_builder])
+require File.join(File.dirname(__FILE__), *%w[builders table_builder])
+
+module Listalicious #:nodoc:
+
+  # Semantic list helper methods
+  #
+  # Example Usage:
+  #
+  module SemanticListHelper
+
+    @@builder = ::Listalicious::TableBuilder
+    mattr_accessor :builder
+
+    def semantic_list_for(collection, *args, &proc)
+      raise ArgumentError, "Missing block" unless block_given?
+
+      options = args.extract_options!
+
+      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]
+
+      if options[:sort_url]
+        options[:html][:class] = add_class(options[:html][:class], 'sortable')
+        options[:html]['data-sorturl'] = url_for(options[:sort_url])
+      end
+
+      builder = options[:builder] || TableBuilder
+      builder.new(@template, collection, options, &proc)
+    end
+
+    def add_class(classnames, classname)
+      out = (classnames.is_a?(String) ? classnames.split(' ') : []) << classname
+      out.join(' ')
+    end
+
+  end
+
+  module ActiveRecordExtensions # :nodoc:
+
+    def self.included(base) # :nodoc:
+      return if base.kind_of?(::Listalicious::ActiveRecordExtensions::ClassMethods)
+      base.class_eval do
+        extend ClassMethods
+      end
+    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
+
+      def acceptable_sort_field?(column)
+        column.present? ? @acceptable_sort_fields.include?(column.to_sym) : false
+      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)
+
+        method = (params["#{self.name.underscore}_sort_desc".to_sym] == field) ? 'DESC' : 'ASC'
+        "#{field} #{method}" unless field.blank?
+      end
+
+    end
+
+  end
+
+end
+
+ActionController::Base.helper Listalicious::SemanticListHelper
+ActiveRecord::Base.class_eval { include ::Listalicious::ActiveRecordExtensions }

data/listalicious.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{listalicious}
+  s.version = "0.1.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.description = %q{Semantic listing; a semantic way to build datagrid structures in Rails.}
+  s.email = %q{jejacks0n@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION",
+     "lib/builders/generic_builder.rb",
+     "lib/builders/table_builder.rb",
+     "lib/listalicious.rb",
+     "listalicious.gemspec",
+     "test/helper.rb",
+     "test/test_listalicious.rb"
+  ]
+  s.homepage = %q{http://github.com/jejacks0n/listalicious}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Semantic lists (datagrids) for Rails}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_listalicious.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'listalicious'
+
+class Test::Unit::TestCase
+end

data/test/test_listalicious.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestListalicious < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: listalicious
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jeremy Jackson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Semantic listing; a semantic way to build datagrid structures in Rails.
+email: jejacks0n@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION
+- lib/builders/generic_builder.rb
+- lib/builders/table_builder.rb
+- lib/listalicious.rb
+- listalicious.gemspec
+- test/helper.rb
+- test/test_listalicious.rb
+has_rdoc: true
+homepage: http://github.com/jejacks0n/listalicious
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Semantic lists (datagrids) for Rails
+test_files: 
+- test/helper.rb
+- test/test_listalicious.rb