rails_table_for 0.2.2 → 0.4.0

data/docs/guides/auto-linking-rows.md

@@ -0,0 +1,44 @@
+---
+layout: default
+title: rails_table_for
+---
+
+# Auto-linking Rows
+
+With the last example, we displayed a link for each row by passing a block to the `column` method
+and using `link_to`.  This is a whole lot of extra code for something so simple.  Let's see how we
+can do something similar in a single line:
+
+```
+<%=
+table_for @records do |table|
+  table.column :name, auto_link: true
+end
+%>
+```
+
+This will generate the following HTML:
+
+```html
+<table>
+  <thead>
+    <tr>
+      <th>Name</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><a href="/records/1">Austin Roos</a></td>
+    </tr>
+  </tbody>
+</table>
+```
+
+You can also pass a block to `column` still, whatever value you return will be placed inside
+the anchor tag
+
+If no route can be found for the record, a `NoMethodError`  will be thrown.
+
+Now that we've simplified the linking, we should move on to some more features to make the table
+more user-friendly.  It's likely that some collections are going to be much too large to display
+on a single page, so let's try out [pagination](./pagination)

data/docs/guides/customizing-column-headers.md

@@ -0,0 +1,36 @@
+---
+layout: default
+title: rails_table_for
+---
+
+# Customizing Column Headers
+
+A one-line table is a delight, but we're a bit limited by only getting values and headers directly from our models.
+Let's start by customizing the column header.  The `table_for` method accepts a block with a single `Table` argument.
+This object has a single method (`.column`) that allows you some customization.  You can use it like this:
+
+```
+<%= table_for @records do |table| %>
+  <% table.column :name, title: 'Naam' %>
+<% end %>
+```
+
+The title of the column will now be `Naam` and the rest of the table will be the same as the first example:
+```html
+<table>
+  <thead>
+    <tr>
+      <th>Naam</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Austin Roos</td>
+    </tr>
+    ...
+  </tbody>
+</table>
+```
+
+So... we've got a pretty simple table here with our header in Dutch... there must be more right?  Indeed, next let's see
+how to do more than print out values directly off the model.  Move on to [customizing row values](./customizing-row-values)

data/docs/guides/customizing-row-values.md

@@ -0,0 +1,41 @@
+---
+layout: default
+title: rails_table_for
+---
+
+# Customizing Row Values
+
+It's great that we can change the header on a column displaying a user's name, but we must be able to do more than just show
+simple strings from our models in these rows, right?  Right.  You can pass a block to the `Table#column` method and return
+anything your heart desires.  Let's add a column that gives us a link to 'Show' the user.
+
+```
+<%= 
+table_for @records do |table|
+  table.column :name, title: 'Naam'
+  table.column title: 'Link' { |record| link_to 'Show', record }
+end
+%>
+```
+
+Assuming the route exists to show that record, this will generate HTML like this:
+
+```html
+<table>
+  <thead>
+    <tr>
+      <th>Naam</th>
+      <th>Link</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Austin Roos</td>
+      <td><a href="/records/1">Show</a></td>
+    </tr>
+  </tbody>
+</table>
+```
+
+So... this gets us through most of the basics, but let's see if we can do things a little more simply.  Check out
+[auto-linking rows](./auto-linking-rows)

data/docs/guides/getting-started.md

@@ -0,0 +1,35 @@
+---
+layout: default
+title: rails_table_for
+---
+
+# Getting Started
+
+For a simple table displaying some attributes of your ActiveRecord model, simply
+call `table_for` with an ActiveRecord collection and an array of columns:
+
+```
+<%= table_for @records, columns: [:full_name] %>
+```
+
+The columns must correspond to methods/properties on the model class.  The column header
+will be the method/property name "humanized" (capitalized, split into words).
+
+Example output:
+```html
+<table>
+  <thead>
+    <tr>
+      <th>Full Name</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Austin Roos</td>
+    </tr>
+    ...
+  </tbody>
+</table>
+```
+
+This is a good start, but surely you'd like to customize things a little bit.   Move on to [customizing columns](./customizing-column-headers)

data/docs/guides/pagination.md

@@ -0,0 +1,55 @@
+---
+layout: default
+title: rails_table_for
+---
+
+# Pagination (beta)
+
+If you've made it this far, you know how to create some basic tables to present your data
+in whatever way you see fit.  Now you're so happy with your table that you want to present
+50 million rows.  This... is a little much for a single page.  Enter pagination:
+
+```
+<%= table_for @records, columns: [:id, :name], page_size: 10 %>
+```
+
+and voila!  you have a table showing only 10 rows per page as well as a set of links beneath
+the table to take you to each page
+
+```html
+<div>
+  <table>
+    <thead>
+      <tr>
+        <th>Id</th>
+        <th>Name</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td>Austin Roos</td>
+        <td>1</td>
+      </tr>
+      ...
+    </tbody>
+  </table>
+  <div class="pagination-links">
+    1
+    <a href="/users?page=2">2</a>
+    <a href="/users?page=3">3</a>
+    <a href="/users?page=4">4</a>
+    <a href="/users?page=5">5</a>
+  </div>
+</div>
+```
+
+This feature is still in beta and there are some known limitations.
+
+### Known Issues
+
+If there are multiple tables on a single web page, the pages of the table will always be
+synced because of the query parameter.
+
+If the number of pages is very large, every pagination link is still shown instead of 
+something a bit more elegant like a few pages before and after the current one as well as
+a link to first and last page

data/docs/index.md

@@ -3,6 +3,12 @@ layout: default
 title: rails_table_for
 ---
 
+# Introduciton
+
+No more writing out dozens of <tr>, <th>, <td> elements.  Write a few lines of ruby code (or even a single line) and
+get a lovely little table generated for you.  You can present data from your records directly with almost no work, or 
+do a little customization if you'd like something extra special.  More features are coming soon, but pagination
+already comes included (only if you want it).
 
 # Installation
 
@@ -18,100 +24,14 @@ And then execute:
 $ bundle
 ```
 
-# Simple Table
-
-For the simplest table, just pass an ActiveRecord collection and an array of columns
-```
-<%= table_for @records, columns: [:name] %>
-```
-
-The columns must correspond to methods/properties on the record class.  The column header
-will be the method/property name "humanized".
-
-Example output:
-```html
-<table>
-  <thead>
-    <tr>
-      <th>Name</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>Austin</td>
-    </tr>
-  </tbody>
-</table>
-```
+# Code Examples
 
-# Customize Column Headers
-
-You can can change the default column headers by passing a block to `table_for` and using the `Table#column` method:
-
-```
-<%= table_for @records do |table| %>
-  <% table.column :name, title: 'Naam' %>
-<% end %>
-```
-
-The title of the column will now be `Naam` and the rest of the table will be the same as the first example:
-```html
-<table>
-  <thead>
-    <tr>
-      <th>Naam</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>Austin</td>
-    </tr>
-  </tbody>
-</table>
-```
+- [Getting Started](./guides/getting-started) (a one-liner?!)
+- [Customizing Column Headers](./guides/customizing-column-headers)
+- [Customizing Row Values](./guides/customizing-row-values)
+- [Auto-linking Rows](./guides/auto-linking-rows)
+- [Pagination](./guides/pagination)
 
-# Pass Blocks to `Table#column`
-
-You can pass a block to the `Table#column` method to display values not directly accessible
-from the model's methods/properties:
-
-```
-<%= 
-table_for @records do |table|
-  table.column title: 'Link' do |record|
-    link_to record.name, record
-  end
-end
-%>
-```
-
-Assuming the route exists to show that record, this will generate HTML like this:
-
-```html
-<table>
-  <thead>
-    <tr>
-      <th>Link</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><a href="/records/1">Record 1</a></td>
-    </tr>
-  </tbody>
-</table>
-```
-
-# Auto-linking columns
-
-Automatically get a link to the record represented by each row like this:
-
-```
-<%=
-table_for @records do |table|
-  table.column :id, auto_link: true
-end
-%>
-```
+# Wanna Help?
 
-If no route can be found for the record, a `NoMethodError`  will be thrown.
+Happily accepting bug reports, feature requests, and pull requests.  Visit [https://github.com/acroos/rails_table_for](https://github.com/acroos/rails_table_for)

data/lib/rails_table_for.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails_table_for/railtie'
 require 'rails_table_for/table_helper'
 

data/lib/rails_table_for/elements/block_column.rb

@@ -1,20 +1,29 @@
+# frozen_string_literal: true
+
 require 'rails_table_for/helpers/auto_link'
 require 'rails_table_for/elements/column'
 
-module Elements
-  class BlockColumn < Column
-    include Helpers::AutoLink, ActionView::Helpers::TagHelper
+module RailsTableFor
+  module Elements
+    class BlockColumn
+      include ActionView::Helpers::TagHelper
+      include Helpers::AutoLink
+      include Column
 
-    def initialize(block, **options)
-      @block = block
-      @title = options[:title]
-      @auto_link = options[:auto_link] || false
-    end
+      attr_reader :block, :title, :auto_link_enabled
+      private :block, :title, :auto_link_enabled
+
+      def initialize(block, **options)
+        @block = block
+        @title = options[:title]
+        @auto_link_enabled = options[:auto_link] || false
+      end
 
-    def td(record)
-      text = @block.call(record)
-      content = @auto_link ? auto_link(record, text) : text
-      content_tag :td, content
+      def td(record)
+        text = block.call(record)
+        content = auto_link_enabled ? auto_link(record, text) : text
+        content_tag :td, content
+      end
     end
   end
-end
+end

data/lib/rails_table_for/elements/column.rb

@@ -1,11 +1,15 @@
-module Elements
-  class Column
-    def th
-      content_tag :th, @title
-    end
+# frozen_string_literal: true
+
+module RailsTableFor
+  module Elements
+    module Column
+      def th
+        content_tag :th, title
+      end
 
-    def td(record)
-      raise 'Not implemented'
+      def td(_)
+        raise 'Not implemented'
+      end
     end
   end
-end
+end

data/lib/rails_table_for/elements/field_column.rb

@@ -1,23 +1,31 @@
+# frozen_string_literal: true
+
 require 'rails_table_for/helpers/auto_link'
 require 'rails_table_for/elements/column'
 
-module Elements
-  class FieldColumn < Column
-    include Helpers::AutoLink, ActionView::Helpers::TagHelper
+module RailsTableFor
+  module Elements
+    class FieldColumn
+      include ActionView::Helpers::TagHelper
+      include Helpers::AutoLink
+      include Column
+
+      attr_reader :field, :title, :auto_link_enabled
+      private :field, :title, :auto_link_enabled
+
+      def initialize(field, **options)
+        raise('Field cannot be nil', ArgumentError) if field.nil?
 
-    def initialize(field, **options)
-      if field.nil?
-        raise ArgumentError.new("Field cannot be nil")
+        @field = field
+        @title = options[:title] || field.to_s.humanize
+        @auto_link_enabled = options[:auto_link] || false
       end
-      @field = field
-      @title = options[:title] || field.to_s.humanize
-      @auto_link = options[:auto_link] || false
-    end
 
-    def td(record)
-      text = record.send(@field)
-      content = @auto_link ? auto_link(record, text) : text
-      content_tag :td, content
+      def td(record)
+        text = record.send(field)
+        content = auto_link_enabled ? auto_link(record, text) : text
+        content_tag :td, content
+      end
     end
   end
-end
+end