declarative_grid 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*~
+.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in declarative_grid.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 David Lin
+
+MIT License
+
+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.md

@@ -0,0 +1,90 @@
+# DeclarativeGrid
+
+DeclarativeGrid is a simple, flexible and extensible datagrid/table generator.
+
+- Configurable: Described in DSL
+- Extensible Renderers: You can build a custom renderer to generate XLSX, json, and so on
+- Select and sort columns: You can assign array of column names to renderer
+- Any Enumerable or Enumerator can be source data
+- It is independent from ActiveRecord and other ORMs
+
+## Example
+
+in models/member_grid.rb
+
+    class MemberGrid < DeclarativeGrid::Base
+      # Columns
+      #
+      column(:name)
+      column(:birthday) {|r| (r.birthdate) }
+      column(:gender, header: 'Sex')
+      
+      # Renderers
+      #
+      # with builtin render class: DeclarativeGrid::Renderers::Csv
+      renderer :csv
+      #
+      # with builtin render class: DeclarativeGrid::Renderers::HtmlTable
+      renderer :html_table
+      #
+      # with selected columns
+      renderer :csv_selected, class: :csv, columns: [:gender, :name]
+      #
+      # with custom renderer class
+      renderer :xls, class: XlsRenderer
+      #
+    end
+
+in member.rb
+
+    class Member < Struct.new(:name, :gender, :birthdate)
+    end
+
+example code:
+
+    m = Member.new('Adam Jensen', 'Male', Date.new(1993,3,9))
+    @grid = MemberGrid.new { [m] }
+    
+    puts "== sample 1 =="
+    @grid.renderer(:csv).each_data {|s| puts s }
+    
+    puts "== sample 2 =="
+    @grid.renderer(:csv_selected).each_data {|s| puts s }
+
+result:
+
+    == sample 1 ==
+    Name,Birthday,Sex
+    Adam Jensen,1993-03-09,Male
+    == sample 2 ==
+    Sex,Name
+    Male,Adam Jensen
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'declarative_grid'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install declarative_grid
+
+## Usage
+
+## How to Test
+
+    $ rake spec
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new :spec do |t|
+  t.libs << "spec"
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r declarative_grid"
+end

data/declarative_grid.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'declarative_grid/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "declarative_grid"
+  gem.version       = DeclarativeGrid::VERSION
+  gem.authors       = ["David Lin"]
+  gem.email         = ["davll.xc@gmail.com"]
+  gem.description   = %q{DeclarativeGrid is a gem for rendering grids described in simple DSL}
+  gem.summary       = %q{A flexible grid renderer}
+  gem.homepage      = "https://github.com/davll/declarative_grid"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.required_ruby_version = "~> 1.9.0"
+  
+  gem.add_dependency "activesupport", "~> 3.2.8"
+  gem.add_dependency "backports", "~> 2.6.4"
+  
+  gem.add_development_dependency "rake", "~> 0.9.2.2"
+  gem.add_development_dependency "minitest", "~> 4.1.0"
+  gem.add_development_dependency "mocha", "~> 0.12.7"
+  gem.add_development_dependency "factory_girl", "~> 4.1.0"
+  
+end

data/lib/declarative_grid/base.rb

@@ -0,0 +1,46 @@
+module DeclarativeGrid
+  class Base
+    extend Model::GridClass
+    
+    # Renderer Classes
+    def self.renderer_classes
+      @renderer_classes ||= {}
+    end
+    
+    # Define a renderer
+    def self.renderer(name, options = {})
+      klass = Class.new begin
+        case k = options.delete(:class)
+        when Class then k
+        when String then k.camelize.constantize
+        else "declarative_grid/renderers/#{k || name}".camelize.constantize
+        end
+      end
+      klass.grid_class = self
+      klass.options.merge! options
+      self.renderer_classes[name] = klass
+    end
+    
+    # Attributes
+    attr_accessor :records
+    
+    # Constructor
+    #
+    # Usage 1: grid = MyGrid.new { MyRecord.all }
+    #
+    def initialize
+      self.records = yield
+    end
+    
+    # Renderer by name
+    def renderer(name)
+      self.class.renderer_classes[name].new(self.records)
+    end
+    
+    # Prevent from @records dumping
+    def inspect
+      self.class.inspect
+    end
+    
+  end
+end

data/lib/declarative_grid/configuration.rb

@@ -0,0 +1,6 @@
+class DeclarativeGrid::Configuration
+  
+  def initialize
+  end
+  
+end

data/lib/declarative_grid/model/column.rb

@@ -0,0 +1,35 @@
+module DeclarativeGrid
+  module Model
+    class Column
+      # Attributes
+      attr_accessor :options, :block, :name
+      
+      # Constructor
+      def initialize(name, options = {}, &block)
+        self.name, self.options = name, options
+        self.block = block || lambda {|record| record.send self.name }
+      end
+      
+      # Return the header
+      def header
+        header = self.options[:header]
+        case header
+        when String, Symbol, Numeric then header
+        when Proc then header.call()
+        when nil then self.name.to_s.humanize
+        else raise DefinitionError, "#{header} is not valid"
+        end
+      end
+      
+      # Return the corresponding value of the given record
+      def value_for(record)
+        block = self.block
+        case block.arity
+        when 1 then block.call record
+        else raise DefinitionError, "self.#{block} is not valid"
+        end
+      end
+      
+    end
+  end
+end

data/lib/declarative_grid/model/grid_class.rb

@@ -0,0 +1,29 @@
+module DeclarativeGrid
+  module Model
+    module GridClass
+      
+      def row
+        @row ||= Model::Row.new
+      end
+        
+      # Define a column
+      # REFERENCE: Model::Row#define_column
+      def column(name, options = {}, &block)
+        self.row.define_column(name, options, &block)
+      end
+      
+      # Return the columns
+      # REFERENCE: Model::Row#columns
+      def columns(*args)
+        self.row.columns(*args)
+      end
+      
+      # override Class.inherited
+      def inherited(subclass)
+        super(subclass)
+        subclass.instance_variable_set :@row, self.row.dup
+      end
+      
+    end
+  end
+end

data/lib/declarative_grid/model/row.rb

@@ -0,0 +1,54 @@
+module DeclarativeGrid
+  module Model
+    class Row
+      
+      # Attributes
+      attr_reader :columns_hash
+      
+      # Constructor
+      def initialize
+        @columns_hash = {}
+      end
+      
+      # Copy Constructor
+      def initialize_copy(other)
+        super(other)
+        @columns_hash = other.columns_hash.dup
+      end
+      
+      # Define a column
+      def define_column(name, options = {}, &block)
+        name = name.to_sym
+        check_column_name_collision! name
+        @columns_hash[name] = Column.new name, options, &block
+      end
+      
+      # Return a list of the columns
+      #
+      # PARAM: names can be:
+      #   1) a list of Symbols : returns selected columns according to names
+      #   2) an empty list     : returns all the columns
+      #
+      # NOTE: the returned columns is ordered by the given names
+      #
+      def columns(*names)
+        names = names.flatten
+        if names.empty?
+          @columns_hash.values
+        else
+          @columns_hash.values_at *(names.map(&:to_sym))
+        end
+      end
+      
+      private
+      
+      # Check that the given name is used or not
+      def check_column_name_collision!(name)
+        if @columns_hash.has_key? name
+          raise DefinitionError, "#{self} has a column named as #{name}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/declarative_grid/model.rb

@@ -0,0 +1,7 @@
+module DeclarativeGrid::Model
+  extend ActiveSupport::Autoload
+  
+  autoload :Column
+  autoload :Row
+  autoload :GridClass
+end

data/lib/declarative_grid/renderers/abstract_renderer.rb

@@ -0,0 +1,99 @@
+module DeclarativeGrid
+  module Renderers
+    class AbstractRenderer
+      
+      # Attributes of class
+      def self.grid_class; @grid_class; end
+      def self.grid_class=(k); @grid_class = k; end
+      def self.options; @options ||= {}; end
+      def self.options=(opt); @options = opt; end
+      
+      def self.inherited(subclass)
+        super(subclass)
+        subclass.options = self.options.dup
+      end
+      
+      # Attributes
+      attr_accessor :records, :options
+      
+      # Constructor
+      #
+      # PARAM: records is an object representing the records of model
+      #        it can be:
+      #          1) Enumerator
+      #          2) Enumerable
+      #
+      # PARAM: options is a hash object containing optional configuration
+      #        :columns => an array of column names to render
+      #
+      #
+      def initialize(records, options = {})
+        self.records = records
+        self.options = self.class.options.merge options
+      end
+      
+      # Return selected columns to render
+      def columns
+        names = options[:columns] || []
+        self.class.grid_class.columns(*names)
+      end
+      
+      # Return array of localized headers
+      def headers
+        self.columns.map(&:header)
+      end
+      
+      # Return enumerator of rows
+      def each_row
+        if block_given?
+          self.each_record{|r| yield row_for(r) }
+        else
+          Enumerator.new self, :each_row
+        end
+      end
+      
+      # Return enumerator of self.records
+      def each_record
+        if block_given?
+          case records
+          when Enumerator, Enumerable then records.each{|r| yield r }
+          else raise RendererError, "#{records}: invalid type"
+          end
+        else
+          Enumerator.new self, :each_record
+        end
+      end
+      
+      # Prevent from @records dumping
+      def inspect
+        self.class.inspect
+      end
+      
+      # Rendered Object as an Enumerator
+      def each_data(&block)
+        block ? each_data_string(&block) : Enumerator.new(self, :each_data)
+      end
+      
+      protected
+      
+      # Render data to the block
+      def each_data_string
+        #
+        # yield string1
+        # yield string2
+        # yield string3
+        # ...
+        #
+        raise NotImplementedError
+      end
+      
+      private
+      
+      # Return row (array of data) of a given record
+      def row_for(record)
+        self.columns.map{|c| c.value_for(record) }
+      end
+      
+    end
+  end
+end

data/lib/declarative_grid/renderers/csv.rb

@@ -0,0 +1,17 @@
+module DeclarativeGrid
+  module Renderers
+    class Csv < AbstractRenderer
+      require 'csv'
+      
+      protected
+      
+      def each_data_string
+        yield CSV.generate_line(headers)
+        each_row do |row|
+          yield CSV.generate_line(row)
+        end
+      end
+      
+    end
+  end
+end

data/lib/declarative_grid/renderers/html_table.rb

@@ -0,0 +1,38 @@
+module DeclarativeGrid
+  module Renderers
+    class HtmlTable < AbstractRenderer
+      
+      def utils
+        ERB::Util
+      end
+      delegate :html_escape, to: :utils
+      
+      protected
+      
+      def each_data_string
+        yield "<table>"
+        
+        if options[:caption]
+          yield "<caption>#{html_escape(options[:caption])}</caption>"
+        end
+        
+        yield "<thead><tr>"
+        headers.each do |n|
+          yield "<th>#{html_escape(n)}</th>"
+        end
+        yield "</tr></thead>"
+        
+        yield "<tbody>"
+        each_row do |r|
+          yield "<tr>"
+          r.each {|n| yield "<td>#{html_escape(n)}</td>" }
+          yield "</tr>"
+        end
+        yield "</tbody>"
+        
+        yield "</table>"
+      end
+      
+    end
+  end
+end

data/lib/declarative_grid/renderers.rb

@@ -0,0 +1,9 @@
+module DeclarativeGrid::Renderers
+  extend ActiveSupport::Autoload
+  
+  autoload :AbstractRenderer
+  
+  autoload :Csv
+  autoload :HtmlTable
+  
+end

data/lib/declarative_grid/version.rb

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

data/lib/declarative_grid.rb

@@ -0,0 +1,33 @@
+require "active_support/core_ext"
+require "active_support/concern"
+require "active_support/dependencies"
+require "backports"
+
+require "declarative_grid/version"
+
+module DeclarativeGrid
+  extend ActiveSupport::Autoload
+  
+  autoload :Configuration
+  autoload :Base
+  autoload :Model
+  autoload :Renderers
+  
+  def self.config
+    @config ||= Configuration.new
+  end
+  
+  def self.reset_config
+    @config = nil
+  end
+  
+  class DefinitionError < StandardError
+  end
+  
+  class RendererError < StandardError
+  end
+  
+  class ConfigurationError < StandardError
+  end
+  
+end

data/spec/declarative_grid/base_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+module DeclarativeGrid
+  describe Base do
+    before do
+      @klass = Class.new Base do
+        column :one
+        column :two
+        
+        renderer :csv
+        renderer :html_table
+        renderer :html_table_1, class: :html_table
+        renderer :csv_1, class: 'DeclarativeGrid::Renderers::Csv'
+        renderer :csv_2, class: Renderers::Csv
+        renderer :csv_3, class: :csv, columns: [ :two, :two, :two ]
+      end
+      
+      @record_class = Struct.new :one, :two
+      @records = 5.times.collect do |n|
+        @record_class.new n+1, n*2
+      end
+      
+      @base = @klass.new { @records }
+    end
+    
+    it "is a Class of #{Model::GridClass}" do
+      @base.class.must_be_kind_of Model::GridClass
+    end
+    
+    it "has a collection of records" do
+      @base.records.must_equal @records
+    end
+    
+    it "has a renderer named :csv" do
+      renderer = @base.renderer(:csv)
+      renderer.must_be_kind_of Renderers::Csv
+    end
+    
+    it "has a renderer named :html_table" do
+      renderer = @base.renderer(:html_table)
+      renderer.must_be_kind_of Renderers::HtmlTable
+    end
+    
+    it "has a renderer named :html_table_1" do
+      renderer = @base.renderer(:html_table_1)
+      renderer.must_be_kind_of Renderers::HtmlTable
+      renderer.options.wont_include :class
+    end
+    
+    it "has a renderer named :csv_1" do
+      renderer = @base.renderer(:csv_1)
+      renderer.must_be_kind_of Renderers::Csv
+      renderer.options.wont_include :class
+    end
+    
+    it "has a renderer named :csv_2" do
+      renderer = @base.renderer(:csv_2)
+      renderer.must_be_kind_of Renderers::Csv
+      renderer.options.wont_include :class
+    end
+    
+    it "has a renderer named :csv_3" do
+      renderer = @base.renderer(:csv_3)
+      renderer.must_be_kind_of Renderers::Csv
+      renderer.options.wont_include :class
+      renderer.options.must_include :columns
+    end
+    
+  end
+end

data/spec/declarative_grid/model/column_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module DeclarativeGrid
+  describe Model::Column do
+    before do
+      @columns = 5.times.map{ FactoryGirl.build :model_column }
+      @columns_names = @columns.map(&:name)
+      
+      @model_class = Struct.new(*(@columns_names + [:num]))
+      @record = @model_class.new(*(@columns.count.times.to_a + [10]))
+    end
+    
+    it "must be kind of column" do
+      result = @columns.collect{|c| c.is_a? Model::Column }
+      result.must_equal [true] * @columns.count
+    end
+    
+    it "has an attribute named :name (1)" do
+      @columns.map(&:name).must_equal @columns_names
+      @columns_names = @columns.collect do |column|
+        column.name = FactoryGirl.generate :model_column_name
+      end
+      @columns.map(&:name).must_equal @columns_names
+    end
+    
+    it "has a header with default value" do
+      @columns.map(&:header).must_equal @columns_names.map(&:to_s).map(&:humanize)
+    end
+    
+    it "has a header that can be overriden with option (Symbol)" do
+      @columns.each do |column|
+        column.options[:header] = column.name.to_sym
+      end
+      @columns.map(&:header).must_equal @columns.map(&:name).map(&:to_sym)
+      @columns.map(&:header).must_equal @columns_names.map(&:to_sym)
+      
+      @columns.each do |column|
+        column.name = FactoryGirl.generate :model_column_name
+      end
+      
+      @columns.map(&:header).wont_equal @columns.map(&:name).map(&:to_sym)
+      @columns.map(&:header).must_equal @columns_names.map(&:to_sym)
+    end
+    
+    it "has a header that can be overriden with option (String)" do
+      @columns.each do |column|
+        column.options[:header] = column.name.to_s
+      end
+      @columns.map(&:header).must_equal @columns.map(&:name).map(&:to_s)
+      @columns.map(&:header).must_equal @columns_names.map(&:to_s)
+      
+      @columns.each do |column|
+        column.name = FactoryGirl.generate :model_column_name
+      end
+      
+      @columns.map(&:header).wont_equal @columns.map(&:name).map(&:to_s)
+      @columns.map(&:header).must_equal @columns_names.map(&:to_s)
+    end
+    
+    it "has a header that can be overriden with option (Numeric)" do
+      n = 0
+      @columns.each do |column|
+        column.options[:header] = (n += 1)
+      end
+      @columns.map(&:header).must_equal (1..@columns.count).to_a
+    end
+    
+    it "has a header that can be overriden with option (Proc)" do
+      @columns.each do |column|
+        column.options[:header] = lambda{ column.name.to_s * 2 }
+      end
+      @columns.map(&:header).must_equal @columns_names.map{|n| n.to_s * 2 }
+      @columns.map(&:header).must_equal @columns.map{|c| c.name.to_s * 2 }
+      
+      @columns.each do |column|
+        column.name = FactoryGirl.generate :model_column_name
+      end
+      
+      @columns.map(&:header).wont_equal @columns_names.map{|n| n.to_s * 2 }
+      @columns.map(&:header).must_equal @columns.map{|c| c.name.to_s * 2 }
+    end
+    
+    it "can query value from record" do
+      result = @columns.collect do |column|
+        column.value_for(@record) == @record.send(column.name)
+      end
+      result.must_equal [true] * @columns.count
+    end
+    
+    it "can query value from record - with block" do
+      @columns.each do |column|
+        column.block = lambda {|r| r.num }
+      end
+      
+      @record.num = 20
+      result = @columns.map{|c| c.value_for @record }
+      result.must_equal [20] * @columns.count
+      
+      @record.num = 30
+      result = @columns.map{|c| c.value_for @record }
+      result.must_equal [30] * @columns.count
+    end
+    
+    it "must raise error if the arguments of block is not acceptable" do
+      @columns.each{|c| c.block = lambda { 'yoooooo' } }
+      proc{@columns.each{|c|c.value_for @record}}.must_raise DefinitionError
+    end
+    
+  end
+end

data/spec/declarative_grid/model/grid_class_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module DeclarativeGrid
+  describe Model::GridClass do
+    
+    before do
+      @klass = Class.new Object do
+        extend Model::GridClass
+        column :name
+        column :kind
+      end
+    end
+    
+    it "has columns" do
+      @klass.columns.all?{|c| c.must_be_kind_of Model::Column }
+      
+      names = @klass.columns.map(&:name)
+      names.must_include :name
+      names.must_include :kind
+    end
+    
+    it "has subclasses that inherit its definition" do
+      klass2 = Class.new @klass do
+        column :name2
+      end
+      
+      names = @klass.columns.map(&:name)
+      names.must_include :name
+      names.must_include :kind
+      names.wont_include :name2
+      
+      names2 = klass2.columns.map(&:name)
+      names2.must_include :name
+      names2.must_include :kind
+      names2.must_include :name2
+    end
+    
+  end
+end

data/spec/declarative_grid/model/row_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module DeclarativeGrid
+  describe Model::Row do
+    before do
+      @row = FactoryGirl.build :model_row
+    end
+    
+    it "can define many columns" do
+      @row.columns.must_be_empty
+      (1..10).collect do |n|
+        @row.define_column(FactoryGirl.generate :model_column_name)
+        @row.columns.count.must_equal n
+        
+        result = @row.columns.collect {|c| c.is_a? Model::Column }
+        result.must_equal [true]*n
+      end
+    end
+    
+    it "can select columns" do
+      names = 5.times.map{ FactoryGirl.generate :model_column_name }
+      names.each {|x| @row.define_column x }
+      
+      @row.columns.map(&:name).must_equal names
+      
+      names.permutation do |perm|
+        [true, false].repeated_permutation(perm.count) do |flags|
+          if flags.all?{|f| f == false }
+            @row.columns([]).map(&:name).must_equal names
+          else
+            k = [perm, flags].transpose.select{|n,f|f}.transpose[0]
+            @row.columns(k).map(&:name).must_equal k
+          end
+        end
+      end
+    end
+    
+    it "cannot have columns with the same name" do
+      name = FactoryGirl.generate :model_column_name
+      @row.define_column name
+      proc{ @row.define_column name }.must_raise DefinitionError
+    end
+    
+    it "can be cloned" do
+      row2 = @row.dup
+      # NOTE: Model::Column objects are not cloned actually
+      row2.columns_hash.must_equal @row.columns_hash
+      row2.columns_hash.wont_be_same_as @row.columns_hash
+    end
+    
+  end
+end

data/spec/declarative_grid/renderers/abstract_renderer_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+module DeclarativeGrid
+  describe Renderers::AbstractRenderer do
+    before do
+      @klass = Class.new Object do
+        extend Model::GridClass
+        column :one
+        column :two
+      end
+      
+      @record_class = Struct.new :one, :two
+      @records = 5.times.collect do |n|
+        @record_class.new n+1, n*2
+      end
+      
+      @renderer_class = Class.new Renderers::AbstractRenderer
+      @renderer_class.grid_class = @klass
+      
+      @renderer = @renderer_class.new @records
+    end
+    
+    it "is valid class" do
+      @renderer.must_be_kind_of @renderer_class
+      @renderer.class.grid_class.must_equal @klass
+    end
+    
+    it "is vaild after initialization" do
+      @renderer.records.must_equal @records
+      @renderer.options.must_equal ({})
+    end
+    
+    it "has all the columns" do
+      @renderer.columns.each{|c| c.must_be_kind_of Model::Column }
+      @renderer.columns.map(&:name).must_equal [:one, :two]
+    end
+    
+    it "renders the headers" do
+      @renderer.headers.must_equal @renderer.columns.map(&:header)
+    end
+    
+    it "enumerates all the records" do
+      @renderer.each_record.must_be_kind_of Enumerator
+      @renderer.each_record.to_a.must_equal @records
+    end
+    
+    it "enumerates all the rows" do
+      @renderer.each_row.must_be_kind_of Enumerator
+      @renderer.each_row.to_a.must_equal @records.map{|r| [r.one, r.two] }
+    end
+    
+    it "can select columns" do
+      @renderer.options[:columns] = [ :two ]
+      @renderer.columns.must_equal @klass.columns(:two)
+      @renderer.each_row.to_a.must_equal @records.map{|r| [r.two] }
+    end
+    
+    it "can select columns with different orders" do
+      @renderer.options[:columns] = [ :two, :one, :one ]
+      @renderer.columns.must_equal @klass.columns(:two, :one, :one)
+      @renderer.each_row.to_a.must_equal @records.map{|r|[r.two,r.one,r.one]}
+    end
+    
+    it "can accept records as Enumerator" do
+      @renderer.records = @records.each
+      @renderer.each_record.must_be_kind_of Enumerator
+      @renderer.each_record.to_a.must_equal @records
+    end
+    
+    it "can override class-defined options" do
+      @renderer_class.options[:columns] = [ :one, :one, :one ]
+      @renderer_class.options.wont_equal @renderer_class.superclass.options
+      @renderer = @renderer_class.new @records, columns: [:two]
+      @renderer.options[:columns].must_equal [:two]
+    end
+    
+    it "has a not implemented method :each_data_string" do
+      proc {
+        @renderer.send(:each_data_string)
+      }.must_raise NotImplementedError
+    end
+    
+    it "has a method :each_data" do
+      @renderer.expects(:each_data_string)
+      @renderer.each_data.must_be_kind_of Enumerator
+      @renderer.each_data {|s| s }
+    end
+    
+    it "call each_data to return the string" do
+      def @renderer.each_data_string
+        yield "test"
+        yield "test2"
+        yield "test3"
+      end
+      @renderer.each_data.to_a.must_equal ["test", "test2", "test3"]
+    end
+    
+  end
+end

data/spec/declarative_grid_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe DeclarativeGrid do
+  
+  it "has configuration object" do
+    DeclarativeGrid.config.must_be_kind_of DeclarativeGrid::Configuration
+  end
+  
+  it "can reset configuration" do
+    config = DeclarativeGrid.config
+    DeclarativeGrid.reset_config
+    DeclarativeGrid.config.wont_equal config
+  end
+  
+end

data/spec/factories/models.rb

@@ -0,0 +1,24 @@
+FactoryGirl.define do
+  
+  sequence(:model_column_name) {|n| :"model_column_#{n}" }
+  
+  factory :model_row, class: DeclarativeGrid::Model::Row do
+    initialize_with { self.new }
+  end
+  
+  factory :model_column, class: DeclarativeGrid::Model::Column do
+    name { FactoryGirl.generate :model_column_name }
+    options { {} }
+    block nil
+    
+    initialize_with {
+      name = attributes[:name]
+      row = attributes[:row]
+      options = attributes[:options]
+      block = attributes[:block]
+      
+      new(name, options, &block)
+    }
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# Bundler
+require "rubygems"
+require "bundler/setup"
+
+# Test Framework
+require "minitest/autorun"
+require "mocha"
+require "factory_girl"
+
+#
+require 'declarative_grid'
+
+#
+SPEC_ROOT = File.expand_path("..", __FILE__)
+
+# load factories
+Dir[File.join(SPEC_ROOT, "factories/**/*.rb")].each {|f| require f }

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: declarative_grid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Lin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+- !ruby/object:Gem::Dependency
+  name: backports
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.7
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: DeclarativeGrid is a gem for rendering grids described in simple DSL
+email:
+- davll.xc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- declarative_grid.gemspec
+- lib/declarative_grid.rb
+- lib/declarative_grid/base.rb
+- lib/declarative_grid/configuration.rb
+- lib/declarative_grid/model.rb
+- lib/declarative_grid/model/column.rb
+- lib/declarative_grid/model/grid_class.rb
+- lib/declarative_grid/model/row.rb
+- lib/declarative_grid/renderers.rb
+- lib/declarative_grid/renderers/abstract_renderer.rb
+- lib/declarative_grid/renderers/csv.rb
+- lib/declarative_grid/renderers/html_table.rb
+- lib/declarative_grid/version.rb
+- spec/declarative_grid/base_spec.rb
+- spec/declarative_grid/model/column_spec.rb
+- spec/declarative_grid/model/grid_class_spec.rb
+- spec/declarative_grid/model/row_spec.rb
+- spec/declarative_grid/renderers/abstract_renderer_spec.rb
+- spec/declarative_grid_spec.rb
+- spec/factories/models.rb
+- spec/spec_helper.rb
+homepage: https://github.com/davll/declarative_grid
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A flexible grid renderer
+test_files:
+- spec/declarative_grid/base_spec.rb
+- spec/declarative_grid/model/column_spec.rb
+- spec/declarative_grid/model/grid_class_spec.rb
+- spec/declarative_grid/model/row_spec.rb
+- spec/declarative_grid/renderers/abstract_renderer_spec.rb
+- spec/declarative_grid_spec.rb
+- spec/factories/models.rb
+- spec/spec_helper.rb