active-list 4.2.4 → 5.0.0

data/lib/active_list/definition/text_field_column.rb

@@ -0,0 +1,10 @@
+module ActiveList
+
+  module Definition
+
+    class TextFieldColumn < FieldColumn
+    end
+
+  end
+
+end

data/lib/active_list/exporters.rb

@@ -0,0 +1,28 @@
+# require 'active_support/core_ext/module/attribute_accessors'
+module ActiveList
+
+  module Exporters
+
+    def self.hash
+      ActiveList.exporters
+    end
+
+    autoload :AbstractExporter,                'active_list/exporters/abstract_exporter'
+    autoload :OpenDocumentSpreadsheetExporter, 'active_list/exporters/open_document_spreadsheet_exporter'
+    autoload :CsvExporter,                     'active_list/exporters/csv_exporter'
+    autoload :ExcelCsvExporter,                'active_list/exporters/excel_csv_exporter'
+  end
+
+  mattr_reader :exporters
+  @@exporters = {}
+
+  def self.register_exporter(name, exporter)
+    raise ArgumentError.new("ActiveList::Exporters::AbstractExporter expected (got #{exporter.name}/#{exporter.ancestors.inspect})") unless exporter < ActiveList::Exporters::AbstractExporter
+    @@exporters[name] = exporter
+  end
+
+end
+
+ActiveList.register_exporter(:ods,  ActiveList::Exporters::OpenDocumentSpreadsheetExporter)
+ActiveList.register_exporter(:csv,  ActiveList::Exporters::CsvExporter)
+ActiveList.register_exporter(:xcsv, ActiveList::Exporters::ExcelCsvExporter)

data/lib/active_list/exporters/abstract_exporter.rb

@@ -0,0 +1,55 @@
+module ActiveList
+
+  module Exporters
+
+    class AbstractExporter
+
+      attr_reader :table, :generator
+
+      def initialize(generator)
+        @generator = generator
+        @table = generator.table
+      end
+
+      def file_extension
+        "txt"
+      end
+
+      def mime_type
+        Mime::TEXT
+      end
+
+      def send_data_code
+        raise NotImplementedError, "#{self.class.name}#format_data_code is not implemented."
+      end
+
+      def columns_headers(options={})
+        headers, columns = [], table.exportable_columns
+        for column in columns
+          datum = column.header_code
+          headers << (options[:encoding] ? datum+".to_s.encode('#{options[:encoding]}')" : datum)
+        end
+        return headers
+      end
+
+      def columns_to_array(nature, options={})
+        columns = table.exportable_columns
+
+        array = []
+        record = options[:record] || 'record_of_the_death'
+        for column in columns
+          if column.is_a?(ActiveList::Definition::AbstractColumn)
+            if nature == :header
+              datum = column.header_code
+            else
+              datum = column.exporting_datum_code(record)
+            end
+            array << (options[:encoding] ? datum+".to_s.encode('#{options[:encoding]}')" : datum)
+          end
+        end
+        return array
+      end
+
+    end
+  end
+end

data/lib/active_list/exporters/csv_exporter.rb

@@ -0,0 +1,32 @@
+module ActiveList
+
+  module Exporters
+
+    class CsvExporter < AbstractExporter
+
+      def file_extension
+        "csv"
+      end
+
+      def mime_type
+        Mime::CSV
+      end
+
+      def send_data_code
+        record = "r"
+        code  = generator.select_data_code(paginate: false)
+        code << "data = ActiveList::CSV.generate do |csv|\n"
+        code << "  csv << [#{columns_to_array(:header).join(', ')}]\n"
+        code << "  for #{record} in #{generator.records_variable_name}\n"
+        code << "    csv << [#{columns_to_array(:body, record: record).join(', ')}]\n"
+        code << "  end\n"
+        code << "end\n"
+        code << "send_data(data, type: #{self.mime_type.to_s.inspect}, disposition: 'inline', filename: #{table.model.name}.model_name.human.gsub(/[^a-z0-9]/i,'_') + '.#{self.file_extension}')\n"
+        return code.c
+      end
+
+    end
+
+  end
+
+end

data/lib/active_list/exporters/excel_csv_exporter.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+# Register XCSV format unless is already set
+Mime::Type.register("text/csv", :xcsv) unless defined? Mime::XCSV
+
+module ActiveList
+
+  module Exporters
+
+    class ExcelCsvExporter < CsvExporter
+
+      def file_extension
+        "csv"
+      end
+
+      def mime_type
+        Mime::XCSV
+      end
+
+      def send_data_code
+        record = "r"
+        code  = generator.select_data_code(paginate: false)
+        encoding = "CP1252"
+        code << "data = ActiveList::CSV.generate(:col_sep => ';') do |csv|\n"
+        code << "  csv << [#{columns_to_array(:header, encoding: encoding).join(', ')}]\n"
+        code << "  for #{record} in #{generator.records_variable_name}\n"
+        code << "    csv << [#{columns_to_array(:body, record: record, encoding: encoding).join(', ')}]\n"
+        code << "  end\n"
+        code << "end\n"
+        code << "send_data(data, type: #{self.mime_type.to_s.inspect}, disposition: 'inline', filename: #{table.model.name}.model_name.human.gsub(/[^a-z0-9]/i,'_')+'.#{self.file_extension}')\n"
+        return code.c
+      end
+
+    end
+
+  end
+
+end

data/lib/active_list/exporters/open_document_spreadsheet_exporter.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+require 'zip'
+
+# Register ODS format unless is already set
+Mime::Type.register("application/vnd.oasis.opendocument.spreadsheet", :ods) unless defined? Mime::ODS
+
+module ActiveList
+
+  module Exporters
+
+    class OpenDocumentSpreadsheetExporter < AbstractExporter
+
+      DATE_ELEMENTS = {
+        "m" => "<number:month number:style=\"long\"/>",
+        "d" => "<number:day number:style=\"long\"/>",
+        "Y" => "<number:year/>"
+      }
+
+      def file_extension
+        "ods"
+      end
+
+      def mime_type
+        Mime::ODS
+      end
+
+      def send_data_code
+        xml_escape = "to_s.gsub('&', '&amp;').gsub('\\'', '&apos;').gsub('<', '&lt;').gsub('>', '&gt;')"
+        xml_escape << ".force_encoding('US-ASCII')" if xml_escape.respond_to?(:force_encoding)
+        record = "r"
+        code  = generator.select_data_code(paginate: false)
+        code << "name = #{table.model.name}.model_name.human.gsub(/[^a-z0-9]/i, '_')\n"
+        code << "file = ::Rails.root.join('tmp', 'export', 'active_list', name + rand.to_s+'.#{self.file_extension}')\n"
+        code << "FileUtils.mkdir_p(file.dirname)\n"
+        code << "Zip::OutputStream.open(file) do |zile|\n"
+        # MimeType in first place
+        code << "  zile.put_next_entry('mimetype', nil, nil, Zip::Entry::STORED)\n"
+        code << "  zile << '#{self.mime_type}'\n"
+
+        # Manifest
+        code << "  zile.put_next_entry('META-INF/manifest.xml')\n"
+        code << "  zile << ('<?xml version=\"1.0\" encoding=\"UTF-8\"?><manifest:manifest xmlns:manifest=\"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0\"><manifest:file-entry manifest:media-type=\"#{self.mime_type}\" manifest:full-path=\"/\"/><manifest:file-entry manifest:media-type=\"text/xml\" manifest:full-path=\"content.xml\"/></manifest:manifest>')\n"
+        code << "  zile.put_next_entry('content.xml')\n"
+
+        code << "  zile << ('<?xml version=\"1.0\" encoding=\"UTF-8\"?><office:document-content xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\" xmlns:style=\"urn:oasis:names:tc:opendocument:xmlns:style:1.0\" xmlns:text=\"urn:oasis:names:tc:opendocument:xmlns:text:1.0\" xmlns:table=\"urn:oasis:names:tc:opendocument:xmlns:table:1.0\" xmlns:draw=\"urn:oasis:names:tc:opendocument:xmlns:drawing:1.0\" xmlns:fo=\"urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:meta=\"urn:oasis:names:tc:opendocument:xmlns:meta:1.0\" xmlns:number=\"urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0\" xmlns:presentation=\"urn:oasis:names:tc:opendocument:xmlns:presentation:1.0\" xmlns:svg=\"urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0\" xmlns:chart=\"urn:oasis:names:tc:opendocument:xmlns:chart:1.0\" xmlns:dr3d=\"urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0\" xmlns:math=\"http://www.w3.org/1998/Math/MathML\" xmlns:form=\"urn:oasis:names:tc:opendocument:xmlns:form:1.0\" xmlns:script=\"urn:oasis:names:tc:opendocument:xmlns:script:1.0\" xmlns:ooo=\"http://openoffice.org/2004/office\" xmlns:ooow=\"http://openoffice.org/2004/writer\" xmlns:oooc=\"http://openoffice.org/2004/calc\" xmlns:dom=\"http://www.w3.org/2001/xml-events\" xmlns:xforms=\"http://www.w3.org/2002/xforms\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:field=\"urn:openoffice:names:experimental:ooxml-odf-interop:xmlns:field:1.0\" office:version=\"1.1\"><office:scripts/>')\n"
+        # Styles
+        code << "  zile << ('<office:automatic-styles>"+
+          "<style:style style:name=\"co1\" style:family=\"table-column\"><style:table-column-properties fo:break-before=\"auto\" style:use-optimal-column-width=\"true\"/></style:style>"+
+          "<style:style style:name=\"header\" style:family=\"table-cell\"><style:text-properties fo:font-weight=\"bold\" style:font-weight-asian=\"bold\" style:font-weight-complex=\"bold\"/></style:style>"+
+          "<number:date-style style:name=\"K4D\" number:automatic-order=\"true\"><number:text>"+::I18n.translate("date.formats.default").gsub(/\%./){|x| "</number:text>"+DATE_ELEMENTS[x[1..1]]+"<number:text>"} +"</number:text></number:date-style><style:style style:name=\"ce1\" style:family=\"table-cell\" style:data-style-name=\"K4D\"/>"+
+          "</office:automatic-styles>')\n"
+
+        # Tables
+        code << "  zile << ('<office:body><office:spreadsheet><table:table table:name=\"'+#{table.model.name}.model_name.human.#{xml_escape}+'\">')\n"
+        code << "  zile << ('<table:table-column table:number-columns-repeated=\"#{table.exportable_columns.size}\"/>')\n"
+        code << "  zile << ('<table:table-header-rows><table:table-row>"+columns_headers.collect{|h| "<table:table-cell table:style-name=\"header\" office:value-type=\"string\"><text:p>'+(#{h}).#{xml_escape}+'</text:p></table:table-cell>"}.join+"</table:table-row></table:table-header-rows>')\n"
+        code << "  for #{record} in #{generator.records_variable_name}\n"
+        code << "    zile << ('<table:table-row>"+table.exportable_columns.collect do |column|
+          "<table:table-cell"+(if column.numeric? or column.datatype==:decimal
+                                 " office:value-type=\"float\" office:value=\"'+(#{column.datum_code(record)}).#{xml_escape}+'\""
+                               elsif column.datatype==:boolean
+                                 " office:value-type=\"boolean\" office:boolean-value=\"'+(#{column.datum_code(record)}).#{xml_escape}+'\""
+                               elsif column.datatype==:date
+                                 " office:value-type=\"date\" table:style-name=\"ce1\" office:date-value=\"'+(#{column.datum_code(record)}).#{xml_escape}+'\""
+                               else
+                                 " office:value-type=\"string\""
+                               end)+"><text:p>'+("+column.exporting_datum_code(record, true)+").#{xml_escape}+'</text:p></table:table-cell>"
+        end.join+"</table:table-row>')\n"
+        code << "  end\n"
+        code << "  zile << ('</table:table></office:spreadsheet></office:body></office:document-content>')\n"
+        code << "end\n"
+        code << "send_file(file, stream: false, type: #{self.mime_type.to_s.inspect}, disposition: 'inline', filename: name+'.#{self.file_extension}')\n"
+        code << "File.delete(file)\n" # Removes tmp files before they explode the disk
+        # raise code
+        return code
+      end
+
+    end
+
+  end
+
+end

data/lib/active_list/generator.rb

@@ -0,0 +1,122 @@
+# 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

@@ -0,0 +1,150 @@
+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
+
+
+