active-list 5.0.1 → 6.0.0

data/lib/active_list/generator.rb

@@ -1,122 +0,0 @@
-# encoding: UTF-8
-module ActiveList
-
-  class Generator
-
-    attr_accessor :table, :controller, :controller_method_name, :view_method_name, :records_variable_name
-
-    def initialize(*args, &block)
-      options = args.extract_options!
-      @controller = options[:controller]
-      name = args.shift || @controller.controller_name.to_sym
-      model = (options[:model]||name).to_s.classify.constantize
-      @collection = !!(model.name == @controller.controller_name.to_s.classify)
-      @controller_method_name = "list#{'_'+name.to_s if name != @controller.controller_name.to_sym}"
-      @view_method_name       = "_#{@controller.controller_name}_list_#{name}_tag"
-      @records_variable_name  = "@#{name}"
-      @table = ActiveList::Definition::Table.new(name, model, options)
-      if block_given?
-        yield @table
-      else
-        @table.load_default_columns
-      end
-      @parameters = {:sort => :to_s, :dir => :to_s}
-      @parameters.merge!(:page => :to_i, :per_page => :to_i) if @table.paginate?
-    end
-
-    def collection?
-      @collection
-    end
-
-    def var_name(name)
-      "_#{name}"
-    end
-
-    def renderer
-      ActiveList::Renderers[@table.options[:renderer]].new(self)
-    end
-
-    def controller_method_code
-      code  = "# encoding: utf-8\n"
-      code << "def #{self.controller_method_name}\n"
-      code << self.session_initialization_code.dig
-      code << "  respond_to do |format|\n"
-      code << "    format.html do\n"
-      code << "      if request.xhr?\n"
-      code << self.renderer.remote_update_code.dig(4)
-      code << "      else\n"
-      code << "        render(inline: '<%=#{self.view_method_name}-%>')\n" # , layout: action_has_layout?
-      code << "      end\n"
-      code << "    end\n"
-      for format, exporter in ActiveList::Exporters.hash
-        code << "    format.#{format} do\n"
-        code << exporter.new(self).send_data_code.dig(3)
-        code << "    end\n"
-      end
-      code << "  end\n"
-      # Save preferences of user
-      if defined? User and User.instance_methods.include? :pref
-        code << "  p = current_user.pref('list.#{self.view_method_name}', YAML::dump({}))\n"
-        code << "  p.set! YAML::dump(#{var_name(:params)}.stringify_keys)\n"
-      end
-      code << "end\n"
-      # code.split("\n").each_with_index{|l, x| puts((x+1).to_s.rjust(4)+": "+l)}
-      unless ::Rails.env.production?
-        file = ::Rails.root.join("tmp", "code", "active_list", "controllers", self.controller.controller_path, self.controller_method_name + ".rb")
-        FileUtils.mkdir_p(file.dirname)
-        File.write(file, code)
-      end
-      return code
-    end
-
-    def view_method_code
-      code  = "# encoding: utf-8\n"
-      code << "def #{self.view_method_name}(options={}, &block)\n"
-      code << self.session_initialization_code.dig
-      code << self.renderer.build_table_code.dig
-      code << "end\n"
-      # code.split("\n").each_with_index{|l, x| puts((x+1).to_s.rjust(4)+": "+l)}
-      unless ::Rails.env.production?
-        file = ::Rails.root.join("tmp", "code", "active_list", "views", self.controller.controller_path, self.view_method_name + ".rb")
-        FileUtils.mkdir_p(file.dirname)
-        File.write(file, code)
-      end
-      return code
-    end
-
-    def session_initialization_code
-      code  = "options = {} unless options.is_a? Hash\n"
-      code << "options.update(params)\n"
-      if defined? User and User.instance_methods.include? :pref
-        code << "#{var_name(:params)} = YAML::load(current_user.pref('list.#{self.view_method_name}', YAML::dump({})).value).symbolize_keys\n"
-        code << "#{var_name(:params)} = {} unless #{var_name(:params)}.is_a?(Hash)\n"
-      else
-        code << "#{var_name(:params)} = {}\n"
-      end
-      code << "#{var_name(:params)}.update(options.symbolize_keys)\n"
-      code << "unless #{var_name(:params)}[:hidden_columns].is_a? Array\n"
-      code << "  #{var_name(:params)}[:hidden_columns] = #{@table.hidden_columns.map(&:name).map(&:to_sym).inspect}\n"
-      code << "end\n"
-      for parameter, convertor in @parameters.sort{|a,b| a[0].to_s <=> b[0].to_s}
-        # expr  = "options.delete('#{@table.name}_#{parameter}') || options.delete('#{parameter}') || #{var_name(:params)}[:#{parameter}]"
-        # expr += " || #{@table.options[parameter]}" unless @table.options[parameter].blank?
-        # code << "#{var_name(:params)}[:#{parameter}] = (#{expr}).#{convertor}\n"
-        expr  = "#{var_name(:params)}[:#{parameter}]"
-        expr = "(#{expr} || #{@table.options[parameter]})" unless @table.options[parameter].blank?
-        code << "#{var_name(:params)}[:#{parameter}] = #{expr}.#{convertor}\n"
-      end
-      # Order
-      code << "#{var_name(:order)} = #{@table.options[:order] ? @table.options[:order].inspect : 'nil'}\n"
-      code << "if #{var_name(:col)} = {" + @table.sortable_columns.collect{|c| "'#{c.sort_id}' => '#{c.sort_expression}'"}.join(', ') + "}[#{var_name(:params)}[:sort]]\n"
-      code << "  #{var_name(:params)}[:dir] = 'asc' unless #{var_name(:params)}[:dir] == 'asc' or #{var_name(:params)}[:dir] == 'desc'\n"
-      code << "  #{var_name(:order)} = #{var_name(:col)} + ' ' + #{var_name(:params)}[:dir]\n"
-      code << "end\n"
-
-      return code
-    end
-
-  end
-
-end
-
-require "active_list/generator/finder"

data/lib/active_list/generator/finder.rb

@@ -1,150 +0,0 @@
-module ActiveList
-
-  # Manage data query
-  class Generator
-
-    # Generate select code for the table taking all parameters in account
-    def select_data_code(options = {})
-      paginate = (options.has_key?(:paginate) ? options[:paginate] : @table.paginate?)
-      # Check order
-      unless @table.options.keys.include?(:order)
-        columns = @table.table_columns
-        @table.options[:order] = (columns.size > 0 ? columns.first.name.to_sym : {id: :desc}) # "#{@table.model.table_name}.id DESC"
-      end
-
-      class_name = @table.model.name
-      class_name = "(controller_name != '#{class_name.tableize}' ? controller_name.to_s.classify.constantize : #{class_name})" if self.collection?
-
-      # Find data
-      query_code = "#{class_name}"
-      query_code << self.scope_code if self.scope_code
-      query_code << ".select(#{self.select_code})" if self.select_code
-      query_code << ".where(#{self.conditions_code})" unless @table.options[:conditions].blank?
-      query_code << ".joins(#{@table.options[:joins].inspect})" unless @table.options[:joins].blank?
-      unless self.includes_reflections.empty?
-        expr = self.includes_reflections.inspect[1..-2]
-        query_code << ".includes(#{expr})"
-        query_code << ".references(#{expr})"
-      end
-
-      code = ""
-      code << "#{var_name(:count)} = #{query_code}.count\n"
-      if paginate
-        code << "#{var_name(:limit)}  = (#{var_name(:params)}[:per_page] || 25).to_i\n"
-        code << "#{var_name(:page)}   = (#{var_name(:params)}[:page] || 1).to_i\n"
-        code << "#{var_name(:page)}   = 1 if #{var_name(:page)} < 1\n"
-        code << "#{var_name(:offset)} = (#{var_name(:page)} - 1) * #{var_name(:limit)}\n"
-        code << "#{var_name(:last)}   = (#{var_name(:count)}.to_f / #{var_name(:limit)}).ceil.to_i\n"
-        code << "#{var_name(:last)}   = 1 if #{var_name(:last)} < 1\n"
-        code << "return #{self.view_method_name}(options.merge(page: 1)) if 1 > #{var_name(:page)}\n"
-        code << "return #{self.view_method_name}(options.merge(page: #{var_name(:last)})) if #{var_name(:page)} > #{var_name(:last)}\n"
-      end
-      code << "#{self.records_variable_name} = #{query_code}"
-      code << ".reorder(#{var_name(:order)})"
-      if paginate
-        code << ".offset(#{var_name(:offset)})"
-        code << ".limit(#{var_name(:limit)})"
-      end
-      code << " || {}\n"
-      return code
-    end
-
-    protected
-
-    # Compute includes Hash
-    def includes_reflections
-      hash = []
-      for column in @table.columns
-        if column.respond_to?(:reflection)
-          hash << column.reflection.name
-        end
-      end
-      return hash
-    end
-
-
-    def scope_code
-      return nil unless scopes = @table.options[:scope]
-      scopes = [scopes].flatten
-      code  = ""
-      for scope in scopes
-        code << ".#{scope}"
-      end
-      return code
-    end
-    
-
-    # Generate the code from a conditions option
-    def conditions_code
-      conditions = @table.options[:conditions]
-      code = ''
-      case conditions
-      when Array
-        case conditions[0]
-        when String  # SQL
-          code << '[' + conditions.first.inspect
-          code << conditions[1..-1].collect{|p| ", " + sanitize_condition(p)}.join if conditions.size > 1
-          code << ']'
-        when Symbol # Method
-          raise "What?"
-          code << conditions.first.to_s + '('
-          code << conditions[1..-1].collect{|p| sanitize_condition(p)}.join(', ') if conditions.size > 1
-          code << ')'
-        else
-          raise ArgumentError.new("First element of an Array can only be String or Symbol.")
-        end
-      when Hash # SQL
-        code << '{' + conditions.collect{|key, value| key.to_s + ': ' + sanitize_condition(value)}.join(',') + '}'
-      when Symbol # Method
-        code << conditions.to_s + "(options)"
-      when Code
-        code << "(" + conditions.gsub(/\s*\n\s*/, ';') + ")"
-      when String
-        code << conditions.inspect
-      else
-        raise ArgumentError.new("Unsupported type for conditions: #{conditions.inspect}")
-      end
-      return code
-    end
-
-    def select_code
-      return nil unless @table.options[:distinct] or @table.options[:select]
-      code  = ""
-      code << "DISTINCT " if @table.options[:distinct]
-      code << "#{@table.model.table_name}.*"
-      if @table.options[:select]
-        code << @table.options[:select].collect{|k, v| ", #{k[0].to_s+'.'+k[1].to_s} AS #{v}" }.join
-      end
-      return ("'" + code + "'").c
-    end
-
-
-    def sanitize_condition(value)
-      # if value.is_a? Array
-      #   # if value.size==1 and value[0].is_a? String
-      #   #   value[0].to_s
-      #   # else
-      #   value.inspect
-      #   # end
-      # elsif value.is_a? Code
-      #   value.inspect
-      # elsif value.is_a? String
-      #   '"' + value.gsub('"', '\"') + '"'
-      # els
-      if [Date, DateTime].include? value.class
-        '"' + value.to_formatted_s(:db) + '"'
-      elsif value.is_a? NilClass
-        'nil'
-      else
-        value.inspect
-      end
-    end
-
-
-  end
-
-
-end
-
-
-

data/lib/active_list/helpers.rb

@@ -1,33 +0,0 @@
-module ActiveList
-  module Helpers
-
-    def recordify!(value, record_name)
-      if value.is_a?(Symbol)
-        return record_name + "." + value.to_s
-      elsif value.is_a?(Code)
-        return "(" + value.gsub(/RECORD/, record_name) + ")"
-      else
-        raise ArgumentError, "Code or Symbol must be given to be recordified)"
-      end
-    end
-
-    def recordify(value, record_name)
-      if value.is_a?(Symbol)
-        return record_name + "." + value.to_s
-      elsif value.is_a?(Code)
-        return "(" + value.gsub(/RECORD/, record_name) + ")"
-      else
-        return value.inspect
-      end
-    end
-
-    def urlify(value, record_name)
-      if value.is_a?(Code)
-        return "(" + value.gsub(/RECORD/, record_name) + ")"
-      else
-        return value.inspect
-      end
-    end
-
-  end
-end

data/lib/active_list/rails/engine.rb

@@ -1,13 +0,0 @@
-module ActiveList
-  module Rails
-    class Engine < ::Rails::Engine
-      engine_name "active_list"
-      initializer "active_list.integrate_methods" do |app|
-        ::ActionController::Base.send(:include, ActiveList::ActionPack::ActionController)
-        ::ActionView::Base.send(:include, ActiveList::ActionPack::ViewsHelper)
-        files = Dir[File.join(File.dirname(__FILE__), "..", "..", "..", "locales", "*.yml")]
-        ::I18n.load_path.concat(files)
-      end
-    end
-  end
-end

data/lib/active_list/renderers.rb

@@ -1,25 +0,0 @@
-# require 'active_support/core_ext/module/attribute_accessors'
-
-module ActiveList
-
-  module Renderers
-
-    def self.[](name)
-      ActiveList.renderers[name]
-    end
-
-    autoload :AbstractRenderer, 'active_list/renderers/abstract_renderer'
-    autoload :SimpleRenderer,   'active_list/renderers/simple_renderer'
-  end
-
-  mattr_reader :renderers
-  @@renderers = {}
-
-  def self.register_renderer(name, renderer)
-    raise ArgumentError.new("A renderer must be ActiveList::Renderers::Renderer") unless renderer < ActiveList::Renderers::AbstractRenderer
-    @@renderers[name] = renderer
-  end
-
-end
-
-ActiveList.register_renderer(:simple_renderer, ActiveList::Renderers::SimpleRenderer)

data/lib/active_list/renderers/abstract_renderer.rb

@@ -1,29 +0,0 @@
-module ActiveList
-
-  module Renderers
-
-    class AbstractRenderer
-      attr_reader :generator, :table
-
-      def initialize(generator)
-        @generator = generator
-        @table = generator.table
-      end
-
-      def var_name(name)
-        @generator.var_name(name)
-      end
-
-      def remote_update_code
-        raise NotImplementedError, "#{self.class.name}#remote_update_code is not implemented."
-      end
-
-      def build_data_code
-        raise NotImplementedError, "#{self.class.name}#build_table_code is not implemented."
-      end
-
-    end
-
-  end
-
-end

data/lib/active_list/renderers/simple_renderer.rb

@@ -1,356 +0,0 @@
-module ActiveList
-
-  module Renderers
-
-    class SimpleRenderer < AbstractRenderer
-      include ActiveList::Helpers
-
-
-      DATATYPE_ABBREVIATION = {
-        :binary => :bin,
-        :boolean => :bln,
-        :date => :dat,
-        :datetime => :dtt,
-        :decimal => :dec,
-        :measure => :dec,
-        :float => :flt,
-        :integer => :int,
-        :string => :str,
-        :text => :txt,
-        :time => :tim,
-        :timestamp => :dtt
-      }
-
-      def remote_update_code
-        code  = "if params[:column] and params[:visibility]\n"
-        code << "  column = params[:column].to_sym\n"
-        # Removes potentially unwanted columns
-        code << "  #{var_name(:params)}[:hidden_columns].delete_if{|c| !#{table.data_columns.map(&:name).inspect}.include?(c)}\n"
-        code << "  #{var_name(:params)}[:hidden_columns].delete(column) if params[:visibility] == 'shown'\n"
-        code << "  #{var_name(:params)}[:hidden_columns] << column if params[:visibility] == 'hidden'\n"
-        code << "  head :ok\n"
-        code << "elsif params[:only]\n"
-        code << "  render(:inline => '<%=#{generator.view_method_name}(:only => params[:only])-%>')\n"
-        code << "else\n"
-        code << "  render(:inline => '<%=#{generator.view_method_name}-%>')\n"
-        code << "end\n"
-        return code
-      end
-
-      def build_table_code
-        record = "r"
-        child  = "c"
-
-        # colgroup = columns_definition_code
-        header = header_code
-        extras = extras_code
-
-        code  = generator.select_data_code
-        code << "#{var_name(:tbody)} = '<tbody data-total=\"'+#{var_name(:count)}.to_s+'\""
-        if table.paginate?
-          code << " data-per-page=\"'+#{var_name(:limit)}.to_s+'\""
-          code << " data-pages-count=\"'+#{var_name(:last)}.to_s+'\""
-        end
-        code << ">'\n"
-        code << "if #{var_name(:count)} > 0\n"
-        code << "  for #{record} in #{generator.records_variable_name}\n"
-        line_class = ""
-        if table.options[:line_class]
-          line_class = ", class: (" + recordify!(table.options[:line_class], record) + ").to_s"
-        end
-        code << "    #{var_name(:tbody)} << content_tag(:tr, id: 'r' + #{record}.id.to_s#{line_class}) do\n"
-        code << columns_to_cells(:body, record: record).dig(3)
-        code << "    end\n"
-        # if table.options[:children].is_a? Symbol
-        #   children = table.options[:children].to_s
-        #   code << "    for #{child} in #{record}.#{children}\n"
-        #   code << "      #{var_name(:tbody)} << content_tag(:tr, :class => #{line_class}+' child') do\n"
-        #   code << columns_to_cells(:children, table.children, record: child).dig(4)
-        #   code << "      end\n"
-        #   code << "    end\n"
-        # end
-        code << "  end\n"
-        code << "else\n"
-        code << "  #{var_name(:tbody)} << '<tr class=\"empty\"><td colspan=\"#{table.columns.size+1}\">' + ::I18n.translate('list.no_records') + '</td></tr>'\n"
-        code << "end\n"
-
-        code << "#{var_name(:tbody)} << '</tbody>'\n"
-        code << "return #{var_name(:tbody)}.html_safe if options[:only] == 'body' or options[:only] == 'tbody'\n"
-
-        code << "html = ''\n"
-        code << "html << '<div id=\"#{table.name}\" data-list-source=\"'+h(url_for(options.merge(:action => '#{generator.controller_method_name}')))+'\" class=\"active-list\""
-        if table.paginate?
-          code << " data-list-current-page=\"' + #{var_name(:page)}.to_s + '\" data-list-page-size=\"' + #{var_name(:limit)}.to_s + '\""
-        end
-        code << " data-list-sort-by=\"' + #{var_name(:params)}[:sort].to_s + '\" data-list-sort-dir=\"' + #{var_name(:params)}[:dir].to_s + '\""
-        code << ">'\n"
-        code << "html << '<table class=\"list\">'\n"
-        code << "html << (#{header})\n"
-        code << "if block_given?\n"
-        code << "  html << '<tfoot>' + capture(" + table.columns.collect{|c| {name: c.name, id: c.id}}.inspect + ", &block).to_s + '</tfoot>'\n"
-        code << "end\n"
-        code << "html << #{var_name(:tbody)}\n"
-        code << "html << '</table>'\n"
-        code << "html << #{extras}\n" if extras
-        code << "html << '</div>'\n"
-        code << "return html.html_safe\n"
-        return code
-      end
-
-
-
-      def columns_to_cells(nature, options={})
-        code = ''
-        unless [:body, :children].include?(nature)
-          raise ArgumentError, "Nature is invalid"
-        end
-        children_mode = !!(nature == :children)
-        for column in table.columns
-          value_code = ""
-          record = options[:record] || 'record_of_the_death'
-          if column.is_a? ActiveList::Definition::EmptyColumn
-            value_code = 'nil'
-          elsif column.is_a? ActiveList::Definition::StatusColumn
-
-            value_code = column.datum_code(record, children_mode)
-            levels = %w(go caution stop)
-            lights = levels.collect do |light|
-              "content_tag(:span, '', :class => #{light.inspect})"
-            end.join(" + ")
-            # Expected value are :valid, :warning, :error
-            value_code = "content_tag(:span, #{lights}, :class => 'lights lights-' + (#{levels.inspect}.include?(#{value_code}.to_s) ? #{value_code}.to_s : 'undefined'))"
-
-          elsif column.is_a? ActiveList::Definition::DataColumn
-            if column.options[:children].is_a? FalseClass and children_mode
-              value_code = 'nil'
-            else
-              value_code = column.datum_code(record, children_mode)
-              if column.datatype == :boolean
-                value_code = "content_tag(:div, '', :class => 'checkbox-'+("+value_code.to_s+" ? 'true' : 'false'))"
-              elsif [:date, :datetime, :timestamp, :measure].include? column.datatype
-                value_code = "(#{value_code}.nil? ? '' : #{value_code}.l)"
-              elsif [:item].include? column.datatype
-                value_code = "(#{value_code}.nil? ? '' : #{value_code}.human_name)"
-              end
-              if !column.options[:currency].is_a?(FalseClass) and currency = column.options[:currency]
-                currency = currency[nature] if currency.is_a?(Hash)
-                currency = :currency if currency.is_a?(TrueClass)
-                # currency = "#{record}.#{currency}".c if currency.is_a?(Symbol)
-                currency = "#{column.record_expr(record)}.#{currency}".c if currency.is_a?(Symbol)
-                value_code = "(#{value_code}.nil? ? '' : #{value_code}.l(currency: #{currency.inspect}))"
-              elsif column.datatype == :decimal
-                value_code = "(#{value_code}.nil? ? '' : #{value_code}.l)"
-              elsif column.enumerize?
-                value_code = "(#{value_code}.nil? ? '' : #{value_code}.text)"
-              end
-              if column.options[:url] and nature == :body
-                column.options[:url] = {} unless column.options[:url].is_a?(Hash)
-                column.options[:url][:id] ||= (column.record_expr(record)+'.id').c
-                column.options[:url][:action] ||= :show
-                column.options[:url][:controller] ||= column.class_name.tableize.to_sym # (self.generator.collection? ? "RECORD.class.name.tableize".c : column.class_name.tableize.to_sym)
-                # column.options[:url][:controller] ||= "#{value_code}.class.name.tableize".c
-                url = column.options[:url].collect{|k, v| "#{k}: " + urlify(v, record)}.join(", ")
-                value_code = "(#{value_code}.blank? ? '' : link_to(#{value_code}.to_s, #{url}))"
-              elsif column.options[:mode]||column.label_method == :email
-                value_code = "(#{value_code}.blank? ? '' : mail_to(#{value_code}))"
-              elsif column.options[:mode]||column.label_method == :website
-                value_code = "(#{value_code}.blank? ? '' : link_to("+value_code+", "+value_code+"))"
-              elsif column.label_method == :color
-                value_code = "content_tag(:div, #{column.datum_code(record)}, style: 'background: #'+"+column.datum_code(record)+")"
-              elsif column.label_method.to_s.match(/(^|\_)currency$/) and column.datatype == :string
-                value_code = "(Nomen::Currencies[#{value_code}] ? Nomen::Currencies[#{value_code}].human_name : #{value_code})"
-              elsif column.label_method.to_s.match(/(^|\_)language$/) and column.datatype == :string
-                value_code = "(Nomen::Languages[#{value_code}]  ? Nomen::Languages[#{value_code}].human_name : #{value_code})"
-              elsif column.label_method.to_s.match(/(^|\_)country$/)  and column.datatype == :string
-                value_code = "(Nomen::Countries[#{value_code}]  ? (image_tag('countries/' + #{value_code}.to_s + '.png') + ' ' + Nomen::Countries[#{value_code}].human_name).html_safe : #{value_code})"
-              else # if column.datatype == :string
-                value_code = "h(" + value_code + ".to_s)"
-              end
-
-              value_code = "if #{record}\n" + value_code.dig + "end" if column.is_a?(ActiveList::Definition::AssociationColumn)
-            end
-          elsif column.is_a?(ActiveList::Definition::CheckBoxColumn)
-            if nature == :body
-              form_name = column.form_name || "'#{table.name}[' + #{record}.id.to_s + '][#{column.name}]'".c
-              value = "nil"
-              if column.form_value
-                value = recordify(column.form_value, record)
-              else
-                value = 1
-                value_code << "hidden_field_tag(#{form_name.inspect}, 0, id: nil) + \n"
-              end
-              value_code << "check_box_tag(#{form_name.inspect}, #{value}, #{recordify!(column.options[:value] || column.name, record)})" # , id: '#{table.name}_'+#{record}.id.to_s+'_#{column.name}'
-            else
-              value_code << "nil"
-            end
-          elsif column.is_a?(ActiveList::Definition::TextFieldColumn)
-            form_name = column.form_name || "'#{table.name}[' + #{record}.id.to_s + '][#{column.name}]'".c
-            value_code = (nature == :body ? "text_field_tag(#{form_name.inspect}, #{recordify!(column.options[:value] || column.name, record)}#{column.options[:size] ? ', size: ' + column.options[:size].to_s : ''})" : "nil") # , id: '#{table.name}_'+#{record}.id.to_s + '_#{column.name}'
-          elsif column.is_a?(ActiveList::Definition::ActionColumn)
-            value_code = (nature == :body ? column.operation(record) : "nil")
-          else
-            value_code = "'&#160;&#8709;&#160;'.html_safe"
-          end
-          code << "content_tag(:td, :class => \"#{column_classes(column)}\") do\n"
-          code << value_code.dig
-          code << "end +\n"
-        end
-        # if nature == :header
-        #   code << "'<th class=\"spe\">#{menu_code}</th>'"
-        # else
-        #   code << "content_tag(:td)"
-        # end
-
-        code << "content_tag(:td)"
-        return code.c
-      end
-
-
-      # Produces main menu code
-      def menu_code
-        menu = "<div class=\"list-menu\">"
-        menu << "<a class=\"list-menu-start\"><span class=\"icon\"></span><span class=\"text\">' + h(::I18n.translate('list.menu').gsub(/\'/,'&#39;')) + '</span></a>"
-        menu << "<ul>"
-        if table.paginate?
-          # Per page
-          list = [5, 10, 20, 50, 100, 200]
-          list << table.options[:per_page].to_i if table.options[:per_page].to_i > 0
-          list = list.uniq.sort
-          menu << "<li class=\"parent\">"
-          menu << "<a class=\"pages\"><span class=\"icon\"></span><span class=\"text\">' + ::I18n.translate('list.items_per_page').gsub(/\'/,'&#39;') + '</span></a><ul>"
-          for n in list
-            menu << "<li data-list-change-page-size=\"#{n}\" '+(#{var_name(:params)}[:per_page] == #{n} ? ' class=\"check\"' : '')+'><a><span class=\"icon\"></span><span class=\"text\">'+h(::I18n.translate('list.x_per_page', :count => #{n}))+'</span></a></li>"
-          end
-          menu << "</ul></li>"
-        end
-
-        # Column selector
-        menu << "<li class=\"parent\">"
-        menu << "<a class=\"columns\"><span class=\"icon\"></span><span class=\"text\">' + ::I18n.translate('list.columns').gsub(/\'/,'&#39;') + '</span></a><ul>"
-        for column in table.data_columns
-          menu << "<li data-list-toggle-column=\"#{column.name}\" class=\"'+(#{var_name(:params)}[:hidden_columns].include?(:#{column.name}) ? 'unchecked' : 'checked')+'\"><a><span class=\"icon\"></span><span class=\"text\">'+h(#{column.header_code})+'</span></a></li>"
-        end
-        menu << "</ul></li>"
-
-        # Separator
-        menu << "<li class=\"separator\"></li>"
-        # Exports
-        for format, exporter in ActiveList.exporters
-          menu << "<li class=\"export #{exporter.name}\">' + link_to(params.merge(:action => :#{generator.controller_method_name}, :sort => #{var_name(:params)}[:sort], :dir => #{var_name(:params)}[:dir], :format => '#{format}')) { '<span class=\"icon\"></span>'.html_safe + content_tag('span', ::I18n.translate('list.export_as', :exported => ::I18n.translate('list.export.formats.#{format}')).gsub(/\'/,'&#39;'), :class => 'text')} + '</li>"
-        end
-        menu << "</ul></div>"
-        return menu
-      end
-
-      # Produces the code to create the header line using  top-end menu for columns
-      # and pagination management
-      def header_code
-        code = "'<thead><tr>"
-        for column in table.columns
-          code << "<th data-list-column=\"#{column.sort_id}\""
-          code << " data-list-column-cells=\"#{column.short_id}\""
-          code << " data-list-column-sort=\"'+(#{var_name(:params)}[:sort] != '#{column.sort_id}' ? 'asc' : #{var_name(:params)}[:dir] == 'asc' ? 'desc' : 'asc')+'\"" if column.sortable?
-          code << " class=\"#{column_classes(column, true, true)}\""
-          code << ">"
-          code << "<span class=\"text\">'+h(#{column.header_code})+'</span>"
-          code << "<span class=\"icon\"></span>"
-          code << "</th>"
-        end
-        code << "<th class=\"spe\">#{menu_code}</th>"
-        code << "</tr></thead>'"
-        return code
-      end
-
-      # Produces the code to create bottom menu and pagination
-      def extras_code
-        code, pagination = nil, ''
-
-        if table.paginate?
-          current_page = "#{var_name(:page)}"
-          last_page = "#{var_name(:last)}"
-
-          pagination << "<div class=\"pagination\">"
-          pagination << "<a href=\"#\" data-list-move-to-page=\"1\" class=\"first-page\"' + (#{current_page} != 1 ? '' : ' disabled=\"true\"') + '><i></i>' + ::I18n.translate('list.pagination.first') + '</a>"
-          pagination << "<a href=\"#\" data-list-move-to-page=\"' + (#{current_page} - 1).to_s + '\" class=\"previous-page\"' + (#{current_page} != 1 ? '' : ' disabled=\"true\"') + '><i></i>' + ::I18n.translate('list.pagination.previous') + '</a>"
-
-          x = '@@PAGE-NUMBER@@'
-          y = '@@PAGE-COUNT@@'
-          pagination << "<span class=\"paginator\">'+::I18n.translate('list.page_x_on_y', :default => '%{x} / %{y}', :x => '#{x}', :y => '#{y}').html_safe.gsub('#{x}', ('<input type=\"number\" size=\"4\" data-list-move-to-page=\"value\" value=\"'+#{var_name(:page)}.to_s+'\">').html_safe).gsub('#{y}', #{var_name(:last)}.to_s) + '</span>"
-
-          pagination << "<a href=\"#\" data-list-move-to-page=\"' + (#{current_page} + 1).to_s + '\" class=\"next-page\"' + (#{current_page} != #{last_page} ? '' : ' disabled=\"true\"') + '><i></i>' + ::I18n.translate('list.pagination.next')+'</a>"
-          pagination << "<a href=\"#\" data-list-move-to-page=\"' + (#{last_page}).to_s + '\" class=\"last-page\"' + (#{current_page} != #{last_page} ? '' : ' disabled=\"true\"') + '><i></i>' + ::I18n.translate('list.pagination.last')+'</a>"
-
-          pagination << "<span class=\"separator\"></span>"
-
-          pagination << "<span class=\"status\">'+::I18n.translate('list.pagination.showing_x_to_y_of_total', :x => (#{var_name(:offset)} + 1), :y => ((#{var_name(:last)} == #{var_name(:page)}) ? #{var_name(:count)} : #{var_name(:offset)}+#{var_name(:limit)}), :total => #{var_name(:count)})+'</span>"
-          pagination << "</div>"
-
-          code = "(#{var_name(:last)} > 1 ? '<div class=\"extras\">#{pagination}</div>' : '').html_safe"
-        end
-
-        return code
-      end
-
-
-      # # Not used
-      # def columns_definition_code
-      #   code = table.columns.collect do |column|
-      #     "<col id=\\\"#{column.unique_id}\\\" class=\\\"#{column_classes(column, true)}\\\" data-cells-class=\\\"#{column.short_id}\\\" href=\\\"\#\{url_for(:action => :#{generator.controller_method_name}, :column => #{column.id.to_s.inspect})\}\\\" />"
-      #   end.join
-      #   return "\"#{code}\""
-      # end
-
-      # Finds all default styles for column
-      def column_classes(column, without_id = false, without_interpolation = false)
-        classes, conds = [], []
-        conds << [:sor, "#{var_name(:params)}[:sort] == '#{column.sort_id}'".c] if column.sortable?
-        conds << [:hidden, "#{var_name(:params)}[:hidden_columns].include?(:#{column.name})".c] if column.is_a? ActiveList::Definition::DataColumn
-        classes << column.options[:class].to_s.strip unless column.options[:class].blank?
-        classes << column.short_id unless without_id
-        if column.is_a? ActiveList::Definition::ActionColumn
-          classes << :act
-        elsif column.is_a? ActiveList::Definition::StatusColumn
-          classes << :status
-        elsif column.is_a? ActiveList::Definition::DataColumn
-          classes << :col
-          classes << DATATYPE_ABBREVIATION[column.datatype]
-          classes << :url if column.options[:url].is_a?(Hash)
-          classes << column.label_method if [:code, :color].include? column.label_method.to_sym
-          if column.options[:mode] == :download
-            classes << :dld
-          elsif column.options[:mode]||column.label_method == :email
-            classes << :eml
-          elsif column.options[:mode]||column.label_method == :website
-            classes << :web
-          end
-        elsif column.is_a? ActiveList::Definition::TextFieldColumn
-          classes << :tfd
-        elsif column.is_a? ActiveList::Definition::CheckBoxColumn
-          classes << :chk
-        else
-          classes << :unk
-        end
-        html = classes.join(' ').strip
-        if conds.size > 0
-          if without_interpolation
-            html << "' + "
-            html << conds.collect do |c|
-              "(#{c[1]} ? ' #{c[0]}' : '')"
-            end.join(' + ')
-            html << " + '"
-          else
-            html << conds.collect do |c|
-              "\#\{' #{c[0]}' if #{c[1]}\}"
-            end.join
-          end
-        end
-        return html
-      end
-
-
-    end
-
-
-  end
-
-end