table_me 0.0.1

data/lib/table_me/table_for_presenter.rb

@@ -0,0 +1,229 @@
+require_relative 'table_me_presenter'
+require_relative 'table_pagination'
+require_relative 'builder'
+require_relative 'url_builder'
+
+module TableMe
+
+  # the first parameter of table_for is the name set in table_me. By default the class 
+  # name is used if a name isn't set.
+
+  # table_for :user
+  # Now, this will list all columns from the database in your table, which you 
+  # may not always want to do. You can pass a block of columns to be more specific:
+
+  # table_for :user do |t|
+  #   t.column :id
+  #   t.column :email
+  #   t.column :created_at
+  # end
+
+  # This will give you a user table with the columns id, email, and created_at.
+
+  # What if you want to customize the output of the column? Each column can also 
+  # take a block of content:
+
+  # table_for :user do |t|
+  #   t.column :id
+  #   t.column :email do |c|
+  #     "<h1>c.email</h1>"
+  #   end
+  #   t.column :created_at
+  # end
+
+  # Now, when a block is used to alter the content of a column, the sorting is lost, 
+  # since the table can no longer assume what is in the column. You need to set a sort_on 
+  # param to tell the column what to sort by. For example:
+
+  # table_for :user do |t|
+  #   t.column :id
+  #   t.column :email, sort_on: :email do |c|
+  #     "<h1>c.email</h1>"
+  #   end
+  #   t.column :created_at
+  # end
+
+  # Filters
+  # You can add basic filter fields to the table by using the filter method. Right now, 
+  # only one filter can be applied and the filters are search fields. I would like to 
+  # eventually add different types for different types of data. I would like to eventually 
+  # add in the ability for multiple filter types with a single search button, but the basic 
+  # form is all I need at the moment. Ajax enabled filtering would be freaking great as well.
+
+  # Filter usage:
+
+  # table_for :user do |t|
+  #   t.filter :email
+  #   t.filter :name
+  #   t.column :id
+  #   t.column :email 
+  #   t.column :name
+  # end
+
+  # The build_table method will use the other public methods to build a full table. It's 
+  # possible to construct your own build table method if you want a custom layout.
+
+
+  class TableForPresenter < ActionView::Base
+    include ActionView::Helpers::CaptureHelper
+    include Haml::Helpers if defined?(Haml)
+
+    attr_accessor :name, :options
+    attr_reader :data
+
+    def initialize table_name, options = {}, &block
+      # self.parent = parent
+      self.options = options
+      self.name = table_name
+      @block = block
+
+      # required to get capture to work with haml
+      init_haml_helpers if defined?(Haml)
+
+      process_data_attributes 
+    end
+
+    # build the complete table with pagination and filters if set.
+
+    def build_table 
+      <<-HTML.strip_heredoc.html_safe
+        <div class='table-me'>
+          #{table_filters}
+          <div class="table-me-table #{'with-filters' if table_builder.filters}">
+            #{table_pagination.pagination_info}
+            <table>
+              <thead>
+                <tr>#{create_header}</tr>
+              </thead>
+              <tbody>
+                #{table_rows}
+              </tbody>
+            </table>
+            #{table_pagination.pagination_controls}
+          </div>
+        </div>
+      HTML
+    end
+
+    # get data from the table_me_presenter in the controller. This breaks encapsulation and makes
+    # this class too tightly coupled to the TableMePresenter, I wanted to keep the table data out
+    # of the class variables in the controller and view, but there has to be a better way to do it.
+    # TODO decouple this and options below
+    def data
+      TableMePresenter.data[name.to_s]
+    end
+
+
+    # same as data above, only with table options. Ideally this needs to be a value object instead
+    # of just a hash. TODO use a value object instead of a hash, see table_vo.rb
+    def options
+      TableMePresenter.options[name.to_s]
+    end
+
+
+    private
+
+
+    # create table filters if they exist
+    def table_filters
+      <<-HTML if table_builder.filters
+        <div class='table-filters'>
+          <h3>Filters</h3>
+          #{table_builder.filters.map do |filter|
+            filter.display
+          end.join("\n")}
+          #{table_builder.clear_filter}
+        </div>
+      HTML
+    end
+
+    # create a table pagination object
+    def table_pagination
+      @table_pagination ||= TablePagination.new(options)
+    end
+
+    # find the class of the data passed in 
+    def data_class
+      data.first.class
+    end
+
+    # create the sortable headers from columns given
+    def create_header
+      order = options[:order].split(' ')
+      table_columns.map do |column|
+        if column.sortable
+          if order[0] == column.sortable.to_s
+            url = TableMe::UrlBuilder.url_for(options, order: "#{column.sortable.to_s} #{order[1].downcase == 'asc' ? 'desc' : 'asc'}")
+            klass = order[1]
+          else
+            url = TableMe::UrlBuilder.url_for(options, order: "#{column.sortable.to_s} asc")
+            klass = nil
+          end
+          "<th><a #{"class='#{klass}'" if klass} href='#{url}'>#{column.name.to_s.split('_').join(' ').titleize}</a></th>"
+        else
+          "<th>#{column.name.to_s.split('_').join(' ').titleize}</th>"
+        end
+      end.join.html_safe
+    end
+
+    # create table rows based on data for each row using columns as a template
+    def table_rows
+      data.map do |d|
+        <<-HTML
+          <tr>
+            #{table_column_for(d)}
+          </tr>
+        HTML
+      end.join.html_safe
+    end
+
+    # it would ne nicer to encapsulate this into the column class, but then we have
+    # to set it up like a view so capture works. For now, I'll leave this here, I'm not
+    # sure if the encapsulation is worth the overhead
+    def table_column_for data
+      table_columns.map do |column|
+        if column.content
+          "<td>#{capture(data, &column.content)}</td>"
+        else
+          "<td>#{data[column.name]}</td>"
+        end
+      end.join
+    end
+
+    # create a table builder instance
+    def table_builder
+      @builder ||= TableMe::Builder.new(options)
+    end
+
+    # get column names from the table_builder
+    def col_names
+      table_builder.names
+    end
+
+    # get table columns from the table_builder
+    def table_columns
+      table_builder.columns
+    end
+
+    # pass in the block given to the table_for_presenter if it exists
+    # else just create a column for every column in the data object
+    def process_data_attributes
+      if @block
+        capture(table_builder, &@block)
+        if table_builder.columns.empty?
+          build_all_columns
+        end
+      else
+        build_all_columns
+      end
+    end
+
+    # create a column for every column in the data object
+    def build_all_columns
+      data.first.attribute_names.each do |attribute|
+        table_builder.column(attribute)
+      end 
+    end
+
+  end
+end

data/lib/table_me/table_me_helper/table_me_helper.rb

@@ -0,0 +1,28 @@
+require_relative '../../../table_me/table_me_presenter'
+module TableMe
+
+  # Controller
+  # A table must first be created in your controller using the table_me method.
+
+  # table_me(collection, options)
+  # The collection can be two things, first an ActiveRecord::Relation, which 
+  # is the result of some sort of active record query ex:
+
+  # table_me( User.where(subscribed: true) )
+  # Keep in mind that doing User.all just returns an array of objects, not the a relation.
+
+  # In order to do the equivalent of the .all just pass in the ActiveRecord class:
+
+  # table_me( User )
+  # Possible options available for this method are:
+
+  # name - Label for the the table
+  # per_page - The amount of items per page of the table
+  
+  module TableMeHelper
+    def table_me(model, options = {})
+      table_presenter = TableMePresenter.new(model, options,params)
+      table_presenter.name
+    end
+  end
+end

data/lib/table_me/table_me_presenter.rb

@@ -0,0 +1,105 @@
+require_relative 'url_parser'
+module TableMe
+
+  # table_me(collection, options)
+  # The collection can be two things, first an ActiveRecord::Relation, which 
+  # is the result of some sort of active record query ex:
+
+  # table_me( User.where(subscribed: true) )
+  # Keep in mind that doing User.all just returns an array of objects, not the a relation.
+
+  # In order to do the equivalent of the .all just pass in the ActiveRecord class:
+
+  # table_me( User )
+  # Possible options available for this method are:
+
+  # name - Label for the the table
+  # per_page - The amount of items per page of the table
+  class TableMePresenter
+    attr_accessor :params, :name
+    attr_reader :data, :options
+
+    class << self
+      def data
+        @@data
+      end
+
+      def options
+        @@options
+      end
+    end
+
+    @@data = {}
+    @@options = {}
+    
+    def initialize model, options = {}, params = {}
+      # this was more of a patch for the code. I need to go back through and normalize all
+      # the hash access so a normal has can be used with confidence
+      # TODO normalize hash access to strings or symbols
+      @options = ActiveSupport::HashWithIndifferentAccess.new(options)
+
+      set_defaults_for model
+      parse_params_for params
+      get_data_for model
+      @@options[self.name] = @options
+    end
+
+    # parse the params into an options hash that we can use
+    def parse_params_for params
+      options.merge! URLParser.parse_params_for(params, self.name)
+    end
+
+    # set defaults for options
+    def set_defaults_for model
+      options[:page] = 1
+      options[:per_page] ||= 10
+      options[:name] ||= model.to_s.downcase
+      options[:order] ||= 'created_at ASC'
+      self.name = options[:name]
+    end
+
+    # make the model queries to pull back the data based on pagination and search results if given
+    def get_data_for model
+      model = apply_search_to(model)
+
+      @@data[self.name] = @data = model.limit(options[:per_page])
+                                       .offset(start_item)
+                                       .order(options[:order])
+
+      options[:total_count] = model.count
+      options[:page_total] = (options[:total_count] / options[:per_page].to_f).ceil
+    end
+
+    # Apply the search query to the appropriate table columns. This is sort of ugly at the moment
+    # and not as reliable as it could be. It needs to be refactored to account for different column
+    # types and use appropriate search methods. Ex. LIKE doesn't work for integers
+    # TODO refactor this to be more reliable for all column types
+    def apply_search_to model
+      if options[:search]
+        if options[:new_search]
+          options[:page] = 1
+          options.delete(:new_search)
+        end
+
+        column_hash = model.columns_hash || model.class.columns_hash
+
+        if column_hash[options[:search][:column].to_s].sql_type.include?('char')
+          model.where(model.arel_table[options[:search][:column]].matches("%#{options[:search][:query]}%"))
+        else
+          model.where(options[:search][:column].to_sym => options[:search][:query])
+        end
+      else
+        model
+      end
+    end
+
+    # beginning item for the offset relation call
+    def start_item
+      (options[:page].to_i - 1) * options[:per_page].to_i
+    end
+
+    def name= value
+      self.options[:name] = @name = value
+    end
+  end
+end

data/lib/table_me/table_pagination.rb

@@ -0,0 +1,110 @@
+require 'cgi'
+require_relative 'url_builder'
+module TableMe
+
+  # This handles the pagination elements of the table
+  class TablePagination
+    attr_accessor :options
+
+    def initialize table_options
+      self.options = table_options
+    end
+
+    # Information at the top of the table displaying the table name and 
+    # position page/item wise out of a total.
+    def pagination_info
+      <<-HTML.strip_heredoc
+        <div class='table-me-pagination-info'>
+          <h3>#{options[:name].split('_').join(' ').titleize}</h3> <p><b>#{options[:page]}</b> of <b>#{options[:page_total]}</b> out of a total <b>#{options[:total_count]}</b></p>
+        </div>
+      HTML
+    end
+
+    # Adds controls at the bottom of the table for previous and next and a 5 number range
+    # TODO Refactor so controllers are hidden when pages on unavailable. IE, if your on page 1
+    # you shouldn't be able to see a previous button, or if your on the last page you shouldn't
+    # be able to see the next button
+    def pagination_controls
+      <<-HTML.strip_heredoc
+        <div class='table-me-pagination-controls'>
+          <a href="#{prev_page_url}" class='previous'>&laquo; Prev</a> #{pagination_number_list} <a href="#{next_page_url}" class='next'>Next &raquo;</a>
+        </div>
+      HTML
+    end
+
+    def next_page_url
+      page = if current_page == total_pages
+        total_pages
+      else
+        current_page + 1
+      end
+
+      link_for_page page
+    end
+
+    def prev_page_url
+      page = if current_page == 0
+        0
+      else
+        current_page - 1
+      end
+
+      link_for_page page
+    end
+
+    # List of number links for the number range between next and previous
+    def pagination_number_list 
+      (0...page_button_count).to_a.map do |n|
+        link_number = n + page_number_offset
+        number_span(link_number)
+      end.join(' ')
+    end
+
+    private
+
+    def number_span link_number
+      if current_page.to_s == link_number.to_s
+        <<-HTML.strip_heredoc
+          <span class='page current'>#{link_number}</span>
+        HTML
+      else
+        <<-HTML.strip_heredoc
+          <span class='page'><a href='#{link_for_page(link_number)}'>#{link_number}</a></span>
+        HTML
+      end
+    end
+
+    def link_for_page page
+      TableMe::UrlBuilder.url_for options, page: page
+    end
+
+    def current_page
+      options[:page].to_i
+    end
+
+    def total_pages
+      options[:page_total]
+    end
+
+    def page_number_offset
+      if current_page >= total_pages - 2
+        current_page - 4 + (total_pages - current_page)
+      elsif current_page <= 2
+        1
+      else
+        current_page - 2
+      end
+    end
+
+    def page_button_count
+      if total_pages > 5
+        5
+      elsif total_pages > 1
+        total_pages
+      else
+        0
+      end
+    end
+
+  end
+end

data/lib/table_me/table_vo.rb

@@ -0,0 +1,48 @@
+# I was going to use this instead of a hash which is passed around, but it started getting too complex
+# for a generic value object, so I might do something else later, not worth it at this time.
+module TableMe
+  class TableVO
+    def self.vo_attr_accessor *args
+      @@set_methods = *args
+      attr_accessor *args
+    end
+
+    vo_attr_accessor :page, :page_total, :search, 
+                  :order, :name, :per_page, 
+                  :total_count, :other_tables
+
+    def initialize params = {}
+      self.merge! params
+    end
+
+    def []= key, value
+      self.method("#{key}=").call(value)
+    end
+
+    def [] key
+      self.method(key).call
+    end
+
+    def merge! object
+      object.each do |k,v|
+        self.method("#{k}=").call(v) unless v.nil?
+      end
+      self
+    end
+
+    def each
+      @@set_methods.each do |method|
+        yield(method,self.method(method).call)
+      end
+    end
+
+    def to_hash
+      hash = {}
+      @@set_methods.each do |method|
+        hash[method] = method(method).call
+      end
+      hash
+    end
+
+  end
+end

data/lib/table_me/url_builder.rb

@@ -0,0 +1,33 @@
+require 'cgi'
+module TableMe
+
+  # This class builds the url needed for the tables based on the table options.
+  # Some options are filtered out to make the url as short as possible. 
+  class UrlBuilder
+    class << self
+
+      def url_for options, additional_options = {}
+        table_options = options.merge additional_options
+
+        url = []
+        filter_options(table_options).each do |option|
+          url <<  {"tm_#{option[:name]}".to_sym => option }.to_param
+        end
+          "?#{url.join('&')}"
+      end
+
+      # Filter out all options except name page search and order
+      # We need to dup the objects so we don't alter the options
+      # object through out the table_me module
+      def filter_options options
+        other_tables = options[:other_tables].dup || []
+        temp_options = options.dup
+        temp_options.keep_if do |k,v|
+          ['name','page','search','order'].include? k.to_s
+        end
+        other_tables << temp_options
+      end
+
+    end
+  end
+end

data/lib/table_me/url_parser.rb

@@ -0,0 +1,38 @@
+require 'cgi'
+require_relative 'url_builder'
+module TableMe
+  # Parse the url params into the hash needed for table_me to work. Take the tables
+  # which aren't the current one and save them as other_tables so we can persist
+  # their states in links.
+  class URLParser
+    def self.parse_params_for params, name
+      @@name = name
+      parse_table_me(params)
+    end
+
+
+    private
+
+    
+    def self.parse_table_me params
+      table_options = {}
+      other_tables = []
+      params.each do |k,v|
+        if k.to_s.include? 'tm_'
+          if v[:name] == @@name.to_s
+            table_options = v
+          else
+            other_tables << v
+          end
+        end
+      end
+      table_options[:other_tables] = other_tables
+      table_options
+    end
+
+    def self.name
+      @@name
+    end
+
+  end
+end

data/lib/table_me/version.rb

@@ -0,0 +1,3 @@
+module TableMe
+  VERSION = "0.0.1"
+end

data/lib/table_me.rb

@@ -0,0 +1,15 @@
+require "active_support/dependencies"
+
+module TableMe
+
+  mattr_accessor :app_root
+
+  # Yield self on setup for nice config blocks
+  def self.setup
+    yield self
+  end
+
+end
+
+# Require our engine
+require "table_me/engine"

data/lib/tasks/table_me_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :table_me do
+#   # Task goes here
+# end