data_grid 0.0.1 → 0.0.2

data/lib/data_grid/data_grid_logic.rb

@@ -0,0 +1,175 @@
+module DataGrid
+  class DataGridLogic
+
+    attr_accessor :per_page, :page, :name, :columns, :in_data, :out_data, :data_class, :params, :sort, :sort_direction, :view_context, :pages, :total, :export_enabled, :summaries, :row_styles, :state_saver, :show_footer, :hidden_row, :out_hidden_rows, :initial_sort, :global_summaries, :count_statement, :extra_orm_options, :export_filename
+    
+
+    # Initialize
+    def initialize(attrs = {})
+      # Internal copy od request params
+      self.params = attrs[:params].except(:action).except(:controller).except(:utf8)
+
+      # Display rows per page
+      self.per_page = (attrs[:per_page] || DataGrid.per_page).to_i
+
+      # Current page
+      self.page = (attrs[:page] || 1).to_i 
+      self.page = 1 if self.page <= 0
+      self.page = 1 if self.page >= 10000000
+
+      # DataGrid name. Has to be set if two or more grids on page.
+      self.name = attrs[:name] || ''
+
+      # Sort by this field
+      self.sort = attrs[:sort]
+
+      # Sort direction - (asc, desc)
+      self.sort_direction = attrs[:sort] || DataGrid.sort_direction
+
+      # Internal array of columns
+      self.columns = attrs[:columns] || []
+
+      # Internal representation of prepared data to display
+      self.out_data = []
+
+      # Name of state saver method - (cookies)
+      self.state_saver = attrs[:state_saver]
+
+      # Show grid footer?
+      self.show_footer = attrs[:show_footer] || DataGrid.show_footer
+
+      # Internal representation of hidden rows - row below each row
+      self.hidden_row = attrs[:hidden_row]
+
+      # Internal representation of prepared hidden rows
+      self.out_hidden_rows = []
+
+      # Initial data grid sorting (ie. 'age ASC')
+      self.initial_sort = attrs[:initial_sort]
+
+      # SQL which counts rows 
+      self.count_statement = attrs[:count_statement] || nil
+
+      # Extra where statement
+      self.extra_orm_options = attrs[:extra_orm_options] || nil
+
+      # Name of exported filename
+      self.export_filename = attrs[:export_filename] || DataGrid.export_filename
+
+      # Name of export method - (csv)
+      self.export_enabled = attrs[:export_enabled]
+    end
+
+    # Add new column
+    def add_column(column_field, column_attrs = {})
+      self.columns << Column.new(column_field, column_attrs)
+    end
+
+    # Assign data
+    def data(_data)
+      self.in_data = _data
+      self.data_class = _data
+      self.data_class = _data.class
+      self.data_class = _data if _data.class != Array
+    end
+
+    # Sorting comes from URL?
+    def sorting?
+      !self.sort.nil?
+    end
+
+    # Any column has filters?
+    def filters?
+      !self.columns.select{|c| !c.filter.nil?}.empty?
+    end
+
+    # Any column has summary?
+    def summary?
+      !self.columns.select{|c| !c.summary.nil?}.empty?
+    end
+
+    # Any column has global summary?
+    def global_summary?
+      !self.columns.select{|c| !c.global_summary.nil?}.empty?
+    end
+
+    # Display footer?
+    def footer?
+      self.show_footer
+    end
+
+    # Get params from request
+    def get_params_from_request
+      self.per_page = (params["per_page_#{self.name}"] || self.per_page).to_i
+      self.page = (params["page_#{self.name}"] || self.page).to_i
+      self.sort = params["sort_#{self.name}"] ? params["sort_#{self.name}"].split('_').pop.to_i : self.sort
+      self.sort_direction = params["sort_direction_#{self.name}"] || self.sort_direction
+
+      self.columns.each_with_index do |col, col_index|
+        col.filter_value = params["filter_#{self.name}_#{col_index}"]
+        if params["filter_#{self.name}_#{col_index}_from"] or params["filter_#{self.name}_#{col_index}_to"]
+          col.filter_value = params["filter_#{self.name}_#{col_index}_from"].to_s + DataGrid.range_separator +
+            params["filter_#{self.name}_#{col_index}_to"].to_s
+        end
+      end
+    end
+
+    # Used in view to show entries from
+    def entries_from
+      ef = (self.page-1)*self.per_page
+      ef.zero? ? 1 : ef
+    end
+
+    # Used in view to show entries to
+    def entries_to
+      if (self.page)*self.per_page > total
+        total
+      else
+        (self.page)*self.per_page
+      end
+    end
+
+    # Assign data
+    def data(_data)
+      self.in_data = _data
+      self.data_class = _data
+      self.data_class = _data.class
+      self.data_class = _data if _data.class != Array
+    end
+
+    alias :data= :data
+
+
+    # Prepare data, do sorting, filtering, paging
+    def prepare_data
+      data_source = nil
+      if self.data_class == Array
+        require 'data_grid/data_source_array'
+        data_source = DataGrid::DataSourceArray.new
+      else
+        require 'data_grid/data_source_orm'
+        data_source = DataGrid::DataSourceORM.new
+      end
+
+      data_source.data_grid = self
+      data_source.prepare_data
+    end
+
+
+    # Row styler is a column, which is hidden and describes style of the row
+    def row_styler
+      styler_column = self.columns.select{|col| col.title == :row_styler}
+
+      if styler_column and !styler_column.empty?
+        styler_column_index = self.columns.index(styler_column.first)
+
+        self.row_styles = []
+        self.out_data.each do |row|
+          self.row_styles << row[styler_column_index]
+        end
+
+        self.columns.delete_at(styler_column_index)
+      end
+    end
+  end
+end

data/lib/data_grid/data_source_array.rb

@@ -0,0 +1,267 @@
+# Source od grid data comes from Array
+
+module DataGrid
+  class DataSourceArray
+
+    attr_accessor :data_grid
+
+    # Main function which prepares data
+    def prepare_data
+      initial_data_eval 
+      initial_sorting if self.data_grid.sorting?
+      filter
+      global_summary_array
+      pagination
+      summary_array
+      self.data_grid.row_styler
+      prepare_data_for_filters
+    end
+ 
+    
+  private
+
+    def direction_as_int
+      if self.data_grid.sort_direction == 'ASC'
+        return 1
+      else
+        return -1
+      end
+    end
+
+    # Eval lambdas
+    def initial_data_eval
+      self.data_grid.in_data.each_with_index do |row, row_index|
+        entry = []
+
+        self.data_grid.columns.each_with_index do |col, index|
+          # Eval if sorting or filtering by or summary column
+          if (self.data_grid.sort == index) or (col.filter and !col.filter_value.blank?) or col.global_summary or col.summary
+            if col.sort_by.class == Symbol
+              if col.sort_by != col.field
+                if col.field.class == Symbol
+                  to_entry = [row.send(col.field), row.send(col.sort_by)]
+                else
+                  to_entry = [col.field.call(row, self.data_grid.view_context), row.send(col.sort_by)]
+                end
+              else
+                to_entry = row.send(col.sort_by)
+              end
+            else
+              # Call lambda
+              to_entry = col.field.call(row, self.data_grid.view_context)
+            end
+          else
+            # Other column are not evaluated, for now has only row index
+            to_entry = row_index
+          end
+
+          to_entry = 0 if to_entry.nil?
+          entry << to_entry
+        end
+
+        self.data_grid.out_data << entry
+      end
+    end
+
+    # Initial sorting
+    def initial_sorting
+      self.data_grid.out_data.sort! do |a, b|
+        a_v = a[self.data_grid.sort]
+        b_v = b[self.data_grid.sort]
+
+        a_v = a_v[1] if a_v.class == Array
+        b_v = b_v[1] if b_v.class == Array
+
+        a_v = a_v.upcase if a_v.class == String
+        b_v = b_v.upcase if b_v.class == String
+        if (a_v > b_v)
+          direction_as_int
+        else
+          if a_v == b_v
+            0
+          else
+            direction_as_int * -1
+          end
+        end
+      end
+    end
+
+    # Filter
+    def filter
+      if self.data_grid.filters?
+        date_format = I18n.t(:"date.formats.default", {:locale => I18n.locale })
+        filtered_data = []
+        self.data_grid.out_data.each do |row|
+          add_row = true
+          self.data_grid.columns.each_with_index do |col, col_index|
+            if col.filter and !col.filter_value.blank?
+              case col.filter
+              when :auto
+                add_row = false if row[col_index] != col.filter_value
+              when :text
+                add_row = false if row[col_index] !~ Regexp.new(col.filter_value, true) and row[col_index].first !~ Regexp.new(col.filter_value, true) 
+              when :number
+                add_row = false if row[col_index].to_f != col.filter_value.to_f
+              when :range
+                range = col.filter_value.split(DataGrid.range_separator)
+
+                if !range[0].blank? and !range[1].blank?
+                  begin
+                    range[0] < 2
+                  rescue
+                    range[0] = range[0].to_f
+                    range[1] = range[1].to_f
+                  end
+                  add_row = false if row[col_index] < range[0] or row[col_index] > range[1]
+                elsif range[0].blank? and !range[1].blank?
+                  begin
+                    range[1] < 2
+                  rescue
+                    range[1] = range[1].to_f
+                  end
+                  add_row = false if row[col_index] > range[1]
+                elsif range[1].blank? and !range[0].blank?
+                  begin
+                    range[0] < 2
+                  rescue
+                    range[0] = range[0].to_f
+                  end
+                  add_row = false if row[col_index] < range[0]
+                end
+
+              when :date
+                range = col.filter_value.split(DataGrid.range_separator)
+
+                if !range[0].blank? and !range[1].blank?
+                  begin
+                    range[0] < 2
+                  rescue
+                    range[0] = DateTime.strptime(range[0], date_format)
+                    range[1] = DateTime.strptime(range[1], date_format)
+                  end
+                  add_row = false if row[col_index].class == Fixnum or row[col_index] < range[0] or row[col_index] > range[1]
+                elsif range[0].blank? and !range[1].blank?
+                  begin
+                    range[1] < 2
+                  rescue
+                    range[1] = DateTime.strptime(range[1], date_format)
+                  end
+                  add_row = false if row[col_index].class == Fixnum or row[col_index] > range[1]
+                elsif range[1].blank? and !range[0].blank?
+                  begin
+                    range[0] < 2
+                  rescue
+                    range[0] = DateTime.strptime(range[0], date_format)
+                  end
+                  add_row = false if row[col_index].class == Fixnum or row[col_index] < range[0]
+                end
+
+              end
+            end
+          end
+          filtered_data << row if add_row
+        end
+
+        self.data_grid.out_data = filtered_data
+      end
+    end
+    
+    
+    # Pagination
+    def pagination
+      self.data_grid.total = self.data_grid.out_data.size
+      self.data_grid.pages = self.data_grid.out_data.size/self.data_grid.per_page
+      self.data_grid.pages = (self.data_grid.pages != self.data_grid.pages.ceil) ? self.data_grid.pages.ceil + 1 : self.data_grid.pages.ceil
+
+      page = self.data_grid.page
+      per_page = self.data_grid.per_page
+
+      offset = (page - 1) * per_page
+      if !paged_out_data = self.data_grid.out_data[offset..(offset + per_page - 1)]
+        paged_out_data = self.data_grid.out_data[0..(per_page - 1)]
+      end
+
+      self.data_grid.out_data = []
+      paged_out_data.each_with_index do |row, row_index|
+        entry = []
+
+        self.data_grid.columns.each_with_index { |col, index|
+          # If colum is sorted/filtered/summary
+          if (self.data_grid.sort != index) and (!col.filter or col.filter_value.blank?) and !col.summary and !col.global_summary
+            field = row[index]
+            if col.field.class == Symbol
+              if col.field == :auto
+                entry << row_index + 1 + (page-1)*per_page
+              else
+                entry << self.data_grid.in_data[field].send(col.field)
+              end
+            else
+              entry << col.field.call(self.data_grid.in_data[field], self.data_grid.view_context)
+            end
+          else
+            entry << row[index]
+          end
+        }
+
+        self.data_grid.out_data << entry
+      end
+    end
+    
+    # Prepare data for filters
+    def prepare_data_for_filters
+      self.data_grid.columns.each do |col|
+        next if col.filter.nil? # if no filter
+
+        # Prepare auto filters
+        if col.filter == :auto
+          self.data_grid.in_data.each do |d|
+            if col.sort_by.class == Symbol
+              col.filter_data << d.send(col.sort_by)
+            else
+              # Call lambda
+              col.filter_data << col.field.call(d, self.data_grid)
+            end
+          end
+
+          col.filter_data.uniq!
+          col.filter_data.sort!
+        end
+      end
+    end
+    
+    # Summary
+    def summary_array
+      if self.data_grid.summary?
+        self.data_grid.summaries = []
+        self.data_grid.columns.each_with_index do |col, col_index|
+          if col.summary
+            column_data = []
+            self.data_grid.out_data.each do |row|
+              column_data << row[col_index]
+            end
+
+            self.data_grid.summaries[col_index] = DataGrid::Summaries.send(col.summary, column_data)
+          end
+        end
+      end
+    end
+
+    # Global Summary
+    def global_summary_array
+      if self.data_grid.summary?
+        self.data_grid.global_summaries = []
+        self.data_grid.columns.each_with_index do |col, col_index|
+          if col.global_summary
+            column_data = []
+            self.data_grid.out_data.each do |row|
+              column_data << row[col_index]
+            end
+
+            self.data_grid.global_summaries[col_index] = DataGrid::Summaries.send(col.global_summary, column_data)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/data_grid/data_source_orm.rb

@@ -0,0 +1,207 @@
+# Source od grid data comes from ORM
+
+module DataGrid
+  class DataSourceORM
+    
+    attr_accessor :data_grid
+
+    def prepare_data
+      global_summary_orm
+      get_data_from_orm
+      summary_orm
+      self.data_grid.row_styler
+      prepare_orm_data_for_filters
+    end
+ 
+    
+  private
+
+    def direction_as_int
+      if self.sort_direction == 'ASC'
+        return 1
+      else
+        return -1
+      end
+    end
+    
+    # Filter data using ORM 
+    def prepare_orm_filters
+      filters = [[]]
+      date_format = I18n.t(:"date.formats.default", {:locale => I18n.locale })
+      self.data_grid.columns.each_with_index do |col, col_index|
+        if col.filter and !col.filter_value.blank?
+          case col.filter
+          when :boolean
+            filters[0] << "#{col.filter_by} = ?"
+            filters << (col.filter_value == '1') ? true : false
+          when :auto
+            filters[0] << "#{col.filter_by} = ?"
+            filters << col.filter_value
+          when :text
+            filters[0] << "#{col.filter_by} #{ActiveRecord::Base.connection.adapter_name.downcase.to_sym == :postgresql ? 'ILIKE' : 'LIKE'} ?"
+            filters << "%#{col.filter_value}%"
+          when :number
+            filters[0] << "#{col.filter_by} = ?"
+            filters << col.filter_value.to_i
+          when :range
+            range = col.filter_value.split(DataGrid.range_separator)
+
+            if !range[0].blank? and !range[1].blank?
+              begin
+                range[0] < 2
+              rescue
+                range[0] = range[0].to_f
+                range[1] = range[1].to_f
+              end
+              filters[0] << "#{col.filter_by} >= ? AND #{col.filter_by} <= ?"
+              filters << range[0]
+              filters << range[1]
+            elsif range[0].blank? and !range[1].blank?
+              begin
+                range[1] < 2
+              rescue
+                range[1] = range[1].to_f
+              end
+              filters[0] << "#{col.filter_by} <= ?"
+              filters << range[1]
+            elsif range[1].blank? and !range[0].blank?
+              begin
+                range[0] < 2
+              rescue
+                range[0] = range[0].to_f
+              end
+              filters[0] << "#{col.filter_by} >= ?"
+              filters << range[0]
+            end
+
+          when :date
+            range = col.filter_value.split(DataGrid.range_separator)
+
+            if !range[0].blank? and !range[1].blank?
+              begin
+                range[0] < 2
+              rescue
+                range[0] = DateTime.strptime(range[0], date_format)
+                range[1] = DateTime.strptime(range[1], date_format)
+              end
+              filters[0] << "#{col.filter_by} >= ? AND #{col.filter_by} <= ?"
+              filters << range[0]
+              filters << range[1]
+            elsif range[0].blank? and !range[1].blank?
+              begin
+                range[1] < 2
+              rescue
+                range[1] = DateTime.strptime(range[1], date_format)
+              end
+              filters[0] << "#{col.filter_by} <= ?"
+              filters << range[1]
+            elsif range[1].blank? and !range[0].blank?
+              begin
+                range[0] < 2
+              rescue
+                range[0] = DateTime.strptime(range[0], date_format)
+              end
+              filters[0] << "#{col.filter_by} >= ?"
+              filters << range[0]
+            end
+          end
+        end
+      end
+      
+      filters[0] = filters[0].join(' AND ')
+      filters
+    end
+    
+    # Get data
+    def get_data_from_orm
+      self.data_grid.out_data = []
+      
+      # prepare filters as ActiveRecord conditions 
+      filters = prepare_orm_filters
+      self.data_grid.total = self.data_grid.in_data.where(filters).where(self.data_grid.extra_orm_options).count(self.data_grid.count_statement)
+      self.data_grid.page = 1 if ((self.data_grid.per_page * (self.data_grid.page - 1)) > self.data_grid.total)
+      offset = (self.data_grid.page - 1) * self.data_grid.per_page
+
+      
+      # get data sorted
+      if self.data_grid.sorting?
+        self.data_grid.in_data = self.data_grid.in_data.limit(self.data_grid.per_page.to_i).offset(offset.to_i).order("#{self.data_grid.columns[self.data_grid.sort].sort_field} #{self.data_grid.sort_direction}" + (self.data_grid.initial_sort.blank? ? '' : ", #{self.data_grid.initial_sort}")).where(filters).where(self.data_grid.extra_orm_options)
+      else
+        self.data_grid.in_data = self.data_grid.in_data.limit(self.data_grid.per_page.to_i).offset(offset.to_i).where(filters).order(self.data_grid.initial_sort.blank? ? '' : "#{self.data_grid.initial_sort}").where(self.data_grid.extra_orm_options)
+      end
+
+      # prepare out data array, eval lambdas
+      self.data_grid.in_data.each_with_index do |obj, row_index|
+        row = []
+        self.data_grid.columns.each do |col|
+          if col.field.class == Symbol
+            if col.field == :auto
+              row << row_index + 1 + (self.data_grid.page-1)*self.data_grid.per_page
+            else
+              row << obj.send(col.field)
+            end
+          else
+            row << col.field.call(obj, self.data_grid.view_context)
+          end 
+        end
+
+        # Hidden rows
+        unless self.data_grid.hidden_row.nil?
+          self.data_grid.out_hidden_rows << obj.send(self.data_grid.hidden_row) 
+        end
+        
+        self.data_grid.out_data << row
+      end
+      
+      self.data_grid.pages = (self.data_grid.total/self.data_grid.per_page.to_f).ceil
+    end
+    
+    # Prepare data for filters
+    def prepare_orm_data_for_filters
+      self.data_grid.columns.each do |col|
+        next if col.filter.nil? # if no filter
+
+        # Prepare auto filters
+        if col.filter == :auto
+          col.filter_data = self.data_grid.data_class.select("DISTINCT (#{col.filter_by}) as fc").to_a.to_a.map(&:fc)
+        end
+
+        col.filter_data.uniq!
+        col.filter_data.sort!
+      end
+    end
+  
+    # Summary
+    def summary_orm
+      if self.data_grid.summary?
+        self.data_grid.summaries = []
+        self.data_grid.columns.each_with_index do |col, col_index|
+          if col.summary
+            column_data = []
+            self.data_grid.out_data.each do |row|
+              column_data << row[col_index]
+            end
+
+            self.data_grid.summaries[col_index] = DataGrid::Summaries.send(col.summary, column_data)
+          end
+        end
+      end
+    end
+
+    # Global Summary
+    def global_summary_orm
+      if self.data_grid.global_summary?
+        # prepare filters as ActiveRecord conditions 
+        filters = prepare_orm_filters
+
+        self.data_grid.global_summaries = []
+        self.data_grid.columns.each_with_index do |col, col_index|
+          if col.global_summary
+            self.data_grid.global_summaries[col_index] = self.data_grid.in_data.scoped(:conditions => filters).where(self.data_grid.extra_orm_options).send(*col.global_summary)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/data_grid/engine.rb

@@ -0,0 +1,19 @@
+module DataGrid
+  class Engine < Rails::Engine
+
+    initializer "data_grid.action_controller" do
+      ActiveSupport.on_load(:action_controller) do
+        include DataGrid::Controller
+      end
+    end
+
+    initializer "data_grid.view_helpers" do
+      ActionView::Base.send :include, DataGrid::ViewHelpers
+    end
+
+    initializer "static assets" do |app|
+      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+    end
+
+  end
+end

data/lib/data_grid/summaries.rb

@@ -0,0 +1,34 @@
+# Methods defined in this module are available as summary in DataGrid
+
+module DataGrid
+  # Grid summaries
+  class Summaries
+    
+    def self.average(a)
+      result = 0 
+      unless a.blank?
+        a.each{|p| result += p.to_f} 
+        result /= a.size
+      end
+      result.to_s
+    end
+
+    def self.sum(a)
+      result = 0
+      a.each{|p| result += p.to_f} unless a.blank?
+      result.to_s
+    end
+    
+    def self.sum_price(a)
+      result = 0
+      unless a.blank?
+        a.each do |p|
+          result += p.match(/\-*\d+\,\d+/)[0].gsub(',', '.').to_f if p.match(/\d+\,\d+/) and p.match(/\d+\,\d+/)[0] 
+        end
+      end
+      result = sprintf("%.2f", result.to_f.round(2)).to_s 
+      result
+    end
+  end
+end
+

data/lib/data_grid/version.rb

@@ -0,0 +1,3 @@
+module DataGrid
+  VERSION = "0.0.2"
+end