simple_table 0.0.1

data/lib/simple_table.rb

@@ -0,0 +1,23 @@
+require 'simple_table/tag'
+require 'simple_table/cell'
+require 'simple_table/row'
+require 'simple_table/rows'
+require 'simple_table/body'
+require 'simple_table/head'
+require 'simple_table/foot'
+require 'simple_table/column'
+require 'simple_table/table'
+
+
+module SimpleTable
+  mattr_accessor :options
+  self.options = {
+    :alternate_rows => true,
+    :i18n_scope => nil
+  }
+
+  def table_for(collection = [], options = {}, &block)
+    html = Table.new(self, collection, options, &block).render.html_safe
+    concat html
+  end
+end

data/lib/simple_table/body.rb

@@ -0,0 +1,29 @@
+module SimpleTable
+  class Body < Rows
+    self.tag_name = :tbody
+
+    include ActionController::RecordIdentifier
+    include ActionView::Helpers::RecordIdentificationHelper
+
+    def row(options = {}, &block)
+      table.collection.each_with_index do |record, ix|
+        super(record, options_for_record(record, ix, options))
+      end
+    end
+
+    protected
+
+      def build
+        row do |row, record|
+          row.cell *table.columns.map { |column| record.send(column.attribute_name) }
+        end if @rows.empty?
+      end
+
+      def options_for_record(record, ix, options = {})
+        options = options.dup
+        options[:id] = dom_id(record) if record.respond_to?(:new_record?)
+        add_class!(options, 'alternate') if ix % 2 == 1
+        options
+      end
+  end
+end

data/lib/simple_table/cell.rb

@@ -0,0 +1,21 @@
+module SimpleTable
+  class Cell < Tag
+    self.level = 3
+
+    attr_reader :content
+
+    def initialize(parent, content = nil, options = {})
+      super(parent, options)
+      @content = content
+      options[:colspan] = table.columns.size if options[:colspan] == :all
+    end
+
+    def render
+      super(content, true)
+    end
+
+    def tag_name
+      parent.head? ? :th : :td
+    end
+  end
+end

data/lib/simple_table/column.rb

@@ -0,0 +1,26 @@
+module SimpleTable
+  class Column
+    attr_reader :name, :options
+
+    def initialize(table, name, options = {})
+      @table = table
+      @name = name
+      @value = options.delete(:value)
+      @options = options.dup || {}
+      @options[:class] ||= name
+    end
+
+    def content
+      name.is_a?(Symbol) ? translate(name) : name
+    end
+
+    def translate(content)
+      scope = [SimpleTable.options[:i18n_scope], @table.collection_name, :columns].compact
+      I18n.t(content, :scope => scope)
+    end
+
+    def attribute_name
+      name.to_s.underscore
+    end
+  end
+end

data/lib/simple_table/foot.rb

@@ -0,0 +1,6 @@
+module SimpleTable
+  class Foot < Rows
+    self.level = 1
+    self.tag_name = :tfoot
+  end
+end

data/lib/simple_table/head.rb

@@ -0,0 +1,16 @@
+module SimpleTable
+  class Head < Rows
+    self.level = 1
+    self.tag_name = :thead
+
+    protected
+
+      def build
+        row = Row.new(self, options)
+        table.columns.each do |column|
+          row.cell(column.content, column.options.reverse_merge(:scope => 'col'))
+        end
+        @rows << row
+      end
+  end
+end

data/lib/simple_table/row.rb

@@ -0,0 +1,40 @@
+module SimpleTable
+  class Row < Tag
+    self.level = 2
+    self.tag_name = :tr
+
+    def initialize(parent, record = nil, options = {}, &block)
+      super(parent, options)
+
+      @parent = parent
+      @cells = []
+      @block = block
+
+      yield(*[self, record].compact) if block_given?
+    end
+
+    def cell(*contents)
+      options = contents.last.is_a?(Hash) ? contents.pop : {}
+      add_class!(options, current_column_class) if parent.is_a?(Body)
+      contents.each do |content|
+        @cells << Cell.new(self, content, options)
+      end
+    end
+
+    def render
+      super(@cells.map(&:render))
+    end
+
+    protected
+
+      def alternate(options)
+        options[:class] ||= ''
+        options[:class] = options[:class].split(' ').push('alternate').join(' ')
+      end
+
+      def current_column_class
+        column = table.columns[@cells.size]
+        column && column.options[:class] || ''
+      end
+  end
+end

data/lib/simple_table/rows.rb

@@ -0,0 +1,26 @@
+module SimpleTable
+  class Rows < Tag
+    self.level = 1
+
+    attr_reader :rows
+
+    def initialize(parent, options = {})
+      super
+      @rows = []
+    end
+
+    def empty?
+      @rows.empty?
+    end
+
+    def row(*args, &block)
+      options = args.extract_options!
+      @rows << Row.new(self, args.shift, options, &block)
+    end
+
+    def render
+      build if respond_to?(:build)
+      super(@rows.map(&:render))
+    end
+  end
+end

data/lib/simple_table/table.rb

@@ -0,0 +1,75 @@
+module SimpleTable
+  class Table < Tag
+    self.level = 0
+    self.tag_name = :table
+
+    attr_reader :body, :head, :foot, :collection, :columns
+
+    def initialize(view = nil, collection = [], options = {})
+      @view = view
+      @collection = collection
+      @columns = []
+      @collection_name = options.delete(:collection_name)
+
+      super(nil, options.reverse_merge(:id => collection_name, :class => "#{collection_name} list"))
+
+      yield(self) if block_given?
+    end
+
+    ['head', 'body', 'foot'].each do |name|
+      class_eval <<-code
+        def #{name}                                # def head
+          @#{name} ||= #{name.classify}.new(self)  #   @head ||= Head.new(self)
+        end                                        # end
+      code
+    end
+
+    def column(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      names.each do |name|
+        @columns << Column.new(self, name, options)
+      end
+    end
+
+    def empty(*args, &block)
+      @empty = (args << block).compact
+    end
+
+    def row(*args, &block)
+      body.row(*args, &block)
+    end
+
+    def collection_class
+      # @collection.first.class.base_class
+      @collection.first.class
+    end
+
+    def collection_name
+      @collection_name ||= collection_class.name.tableize.gsub('/', '_').gsub('rails_', '')
+    end
+
+    def render
+      (@collection.empty? && @empty) ? render_empty : begin
+        column(*collection_attribute_names) if @columns.empty?
+        super do |html|
+          html << head.render
+          html << body.render
+          html << foot.render if @foot && !@foot.empty?
+        end.gsub(/\n\s*\n/, "\n")
+      end
+    end
+
+    def render_empty
+      @empty.insert(1, @empty.pop.call) if @empty.last.respond_to?(:call)
+      content_tag(*@empty)
+    end
+
+    protected
+
+      def collection_attribute_names
+        record = @collection.first
+        names = record.respond_to?(:attribute_names) ? record.attribute_names : []
+        names.map(&:titleize)
+      end
+  end
+end

data/lib/simple_table/tag.rb

@@ -0,0 +1,56 @@
+module SimpleTable
+  class Tag
+    class_inheritable_accessor :level, :tag_name
+
+    include ActionView::Helpers::TagHelper
+
+    attr_reader :options, :parent
+
+    def initialize(parent = nil, options = {})
+      @parent = parent
+      @options = options
+    end
+
+    def collection_class
+      table.collection_class
+    end
+
+    def collection_name
+      table.collection_name
+    end
+
+    def table
+      is_a?(Table) ? self : parent.try(:table)
+    end
+
+    def head?
+      is_a?(Head) || !!parent.try(:head?)
+    end
+
+    def render(content = nil, escape = false)
+      yield(content = '') if content.nil? && block_given?
+      content = lf(indent(content.to_s))
+      lf(content_tag(tag_name, content, options, escape))
+    end
+
+    def add_class(klass)
+      add_class!(options, klass)
+    end
+
+    protected
+      def lf(str)
+        "\n#{str}\n"
+      end
+
+      def indent(str)
+        str.gsub(/^/, "  ")
+      end
+
+      def add_class!(options, klass)
+        unless klass.blank?
+          options[:class] ||= ''
+          options[:class] = options[:class].split(' ').push(klass).join(' ')
+        end
+      end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: simple_table
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sven Fuchs
+- Raphaela Wrede
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-31 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "[description]"
+email: raphaela.wrede@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/simple_table/body.rb
+- lib/simple_table/cell.rb
+- lib/simple_table/column.rb
+- lib/simple_table/foot.rb
+- lib/simple_table/head.rb
+- lib/simple_table/row.rb
+- lib/simple_table/rows.rb
+- lib/simple_table/table.rb
+- lib/simple_table/tag.rb
+- lib/simple_table.rb
+has_rdoc: true
+homepage: http://github.com/rwrede/simple_table
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "[summary]"
+test_files: []
+