active_list 6.5.1 → 6.6.0

data/lib/active_list/definition/check_box_column.rb

@@ -1,7 +1,5 @@
 module ActiveList
-
   module Definition
-
     class CheckBoxColumn < FieldColumn
       attr_reader :form_value
 
@@ -9,9 +7,6 @@ module ActiveList
         super(table, name, options)
         @form_value = options.delete(:form_value)
       end
-
     end
-
   end
-
 end

data/lib/active_list/definition/data_column.rb

@@ -1,9 +1,6 @@
 module ActiveList
-
   module Definition
-
     class DataColumn < AbstractColumn
-
       LABELS_COLUMNS = [:full_name, :label, :name, :number, :coordinate]
 
       def header_code
@@ -15,30 +12,30 @@ module ActiveList
       end
 
       # Code for exportation
-      def exporting_datum_code(record='record_of_the_death', noview=false)
-        datum = self.datum_code(record)
-        if self.datatype == :boolean
+      def exporting_datum_code(record = 'record_of_the_death', noview = false)
+        datum = datum_code(record)
+        if datatype == :boolean
           datum = "(#{datum} ? ::I18n.translate('list.export.true_value') : ::I18n.translate('list.export.false_value'))"
-        elsif self.datatype == :date
+        elsif datatype == :date
           datum = "(#{datum}.nil? ? '' : #{datum}.l)"
-        elsif self.datatype == :decimal and not noview
+        elsif datatype == :decimal && !noview
           currency = nil
-          if currency = self.options[:currency]
+          if currency = options[:currency]
             currency = currency[:body] if currency.is_a?(Hash)
             currency = :currency if currency.is_a?(TrueClass)
             currency = "#{record}.#{currency}".c if currency.is_a?(Symbol)
           end
           datum = "(#{datum}.nil? ? '' : #{datum}.l(#{'currency: ' + currency.inspect if currency}))"
-        elsif @name.to_s.match(/(^|\_)currency$/) and self.datatype == :string
+        elsif @name.to_s.match(/(^|\_)currency$/) && datatype == :string
           datum = "(Nomen::Currencies[#{datum}] ? Nomen::Currencies[#{datum}].human_name : '')"
-        elsif @name.to_s.match(/(^|\_)country$/) and  self.datatype == :string
+        elsif @name.to_s.match(/(^|\_)country$/) && datatype == :string
           datum = "(Nomen::Countries[#{datum}] ? Nomen::Countries[#{datum}].human_name : '')"
-        elsif @name.to_s.match(/(^|\_)language$/) and self.datatype == :string
+        elsif @name.to_s.match(/(^|\_)language$/) && datatype == :string
           datum = "(Nomen::Languages[#{datum}] ? Nomen::Languages[#{datum}].human_name : '')"
         elsif self.enumerize?
           datum = "(#{datum}.nil? ? '' : #{datum}.text)"
         end
-        return datum
+        datum
       end
 
       # Returns the data type of the column if the column is in the database
@@ -46,17 +43,16 @@ module ActiveList
         @options[:datatype] || (@column ? @column.type : nil)
       end
 
-
       def enumerize?
-        return false
+        false
       end
 
       def state_machine?
-        return false
+        false
       end
-      
+
       def numeric?
-        [:decimal, :integer, :float, :numeric].include? self.datatype
+        [:decimal, :integer, :float, :numeric].include? datatype
       end
 
       # Returns the size/length of the column if the column is in the database
@@ -73,20 +69,17 @@ module ActiveList
       def sortable?
         return true
         # not self.action? and
-        not self.options[:through] and not @column.nil?
+        !options[:through] && !@column.nil?
       end
 
       # Generate code in order to get the (foreign) record of the column
       def record_expr(record = 'record_of_the_death')
-        return record
+        record
       end
 
       def sort_expression
-        raise NotImplementedError, "sort_expression must be implemented"
+        fail NotImplementedError, 'sort_expression must be implemented'
       end
-
     end
-
   end
-
 end

data/lib/active_list/definition/empty_column.rb

@@ -1,10 +1,6 @@
 module ActiveList
-
   module Definition
-
     class EmptyColumn < AbstractColumn
     end
-
   end
-
 end

data/lib/active_list/definition/field_column.rb

@@ -1,7 +1,5 @@
 module ActiveList
-
   module Definition
-
     class FieldColumn < AbstractColumn
       attr_reader :form_name
 
@@ -14,7 +12,5 @@ module ActiveList
         "#{@table.model.name}.human_attribute_name('#{@name}')"
       end
     end
-
   end
-
 end

data/lib/active_list/definition/status_column.rb

@@ -1,10 +1,6 @@
 module ActiveList
-
   module Definition
-
     class StatusColumn < AttributeColumn
     end
-
   end
-
 end

data/lib/active_list/definition/table.rb

@@ -1,7 +1,5 @@
 module ActiveList
-
   module Definition
-
     class Table
       attr_reader :name, :model, :options, :id, :columns, :parameters
 
@@ -9,7 +7,7 @@ module ActiveList
         @name    = name
         @model   = model || name.to_s.classify.constantize
         @options = options
-        @paginate = !(@options[:pagination]==:none || @options[:paginate].is_a?(FalseClass))
+        @paginate = !(@options[:pagination] == :none || @options[:paginate].is_a?(FalseClass))
         @options[:renderer] ||= :simple_renderer
         @options[:per_page] = 20 if @options[:per_page].to_i <= 0
         @options[:page] = 1 if @options[:page].to_i <= 0
@@ -19,9 +17,9 @@ module ActiveList
 
       def new_column_id
         @current_column_id ||= 0
-        id = @current_column_id.to_s(36).to_sym
+        id = @current_column_id.to_s # (36).to_sym
         @current_column_id += 1
-        return id
+        id
       end
 
       def model_columns
@@ -29,11 +27,11 @@ module ActiveList
       end
 
       def sortable_columns
-        @columns.select{|c| c.sortable?}
+        @columns.select(&:sortable?)
       end
 
       def exportable_columns
-        @columns.select{|c| c.exportable?}
+        @columns.select(&:exportable?)
       end
 
       def children
@@ -62,36 +60,34 @@ module ActiveList
 
       # Retrieves all columns in database
       def table_columns
-        cols = self.model_columns.map(&:name)
-        @columns.select{|c| c.is_a? DataColumn and cols.include? c.name.to_s}
+        cols = model_columns.map(&:name)
+        @columns.select { |c| c.is_a?(DataColumn) && cols.include?(c.name.to_s) }
       end
 
       def data_columns
-        @columns.select{|c| c.is_a? DataColumn}
+        @columns.select { |c| c.is_a? DataColumn }
       end
 
       def action_columns
-        @columns.select{|c| c.is_a? ActionColumn}
+        @columns.select { |c| c.is_a? ActionColumn }
       end
 
       def hidden_columns
-        self.data_columns.select(&:hidden?)
+        data_columns.select(&:hidden?)
       end
 
       # Compute includes Hash
       def reflections
         hash = []
-        self.columns.each do |column|
-          if column.respond_to?(:reflection)
-            unless hash.detect{|r| r.name == column.reflection.name }
-              hash << column.reflection
-            end
+        columns.each do |column|
+          next unless column.respond_to?(:reflection)
+          unless hash.detect { |r| r.name == column.reflection.name }
+            hash << column.reflection
           end
         end
-        return hash
+        hash
       end
 
-
       # Add a new method in Table which permit to define text_field columns
       def text_field(name, options = {})
         add :text_field, name, options
@@ -123,7 +119,7 @@ module ActiveList
         if @model.reflect_on_association(name)
           options[:through] ||= name
           add :association, name, options
-        elsif options[:through] and @model.reflect_on_association(options[:through])
+        elsif options[:through] && @model.reflect_on_association(options[:through])
           options[:label_method] ||= name
           add :association, name, options
         else
@@ -137,43 +133,41 @@ module ActiveList
         add :status, name, options
       end
 
-
       def load_default_columns
-        for column in self.model_columns
-          reflections = @model.reflect_on_all_associations(:belongs_to).select{|r| r.foreign_key.to_s == column.name.to_s}
+        for column in model_columns
+          reflections = @model.reflect_on_all_associations(:belongs_to).select { |r| r.foreign_key.to_s == column.name.to_s }
           if reflections.size == 1
             reflection = reflections.first
-            columns = reflection.class_name.constantize.columns.collect{ |c| c.name.to_s }
-            self.column([:label, :name, :code, :number].detect{ |l| columns.include?(l.to_s) }, :through => reflection.name, :url => true)
+            columns = reflection.class_name.constantize.columns.collect { |c| c.name.to_s }
+            self.column([:label, :name, :code, :number].detect { |l| columns.include?(l.to_s) }, through: reflection.name, url: true)
           else
             self.column(column.name.to_sym)
           end
         end
-        return true
+        true
       end
 
       private
 
       # Checks and add column
       def add(type, name, options = {})
-        klass = "ActiveList::Definition::#{type.to_s.camelcase}Column".constantize rescue nil
-        if klass and klass < AbstractColumn
+        klass = begin
+                  "ActiveList::Definition::#{type.to_s.camelcase}Column".constantize
+                rescue
+                  nil
+                end
+        if klass && klass < AbstractColumn
           unless name.is_a?(Symbol)
-            raise ArgumentError, "Name of a column must be a Symbol (got #{name.inspect})."
+            fail ArgumentError, "Name of a column must be a Symbol (got #{name.inspect})."
           end
-          if @columns.detect{|c| c.name == name}
-            raise ArgumentError, "Column name must be unique. #{name.inspect} is already used in #{self.name}"
+          if @columns.detect { |c| c.name == name }
+            fail ArgumentError, "Column name must be unique. #{name.inspect} is already used in #{self.name}"
           end
           @columns << klass.new(self, name, options)
         else
-          raise ArgumentError, "Invalid column type: #{type.inspect}"
+          fail ArgumentError, "Invalid column type: #{type.inspect}"
         end
       end
-
-
     end
-
-
   end
-
 end

data/lib/active_list/definition/text_field_column.rb

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

data/lib/active_list/exporters.rb

@@ -1,8 +1,6 @@
 # require 'active_support/core_ext/module/attribute_accessors'
 module ActiveList
-
   module Exporters
-
     def self.hash
       ActiveList.exporters
     end
@@ -12,6 +10,4 @@ module ActiveList
     autoload :CsvExporter,                     'active_list/exporters/csv_exporter'
     autoload :ExcelCsvExporter,                'active_list/exporters/excel_csv_exporter'
   end
-
 end
-

data/lib/active_list/exporters/abstract_exporter.rb

@@ -1,9 +1,6 @@
 module ActiveList
-
   module Exporters
-
     class AbstractExporter
-
       attr_reader :table, :generator
 
       def initialize(generator)
@@ -12,7 +9,7 @@ module ActiveList
       end
 
       def file_extension
-        "txt"
+        'txt'
       end
 
       def mime_type
@@ -20,36 +17,35 @@ module ActiveList
       end
 
       def send_data_code
-        raise NotImplementedError, "#{self.class.name}#format_data_code is not implemented."
+        fail NotImplementedError, "#{self.class.name}#format_data_code is not implemented."
       end
 
-      def columns_headers(options={})
-        headers, columns = [], table.exportable_columns
+      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]}', invalid: :replace, undef: :replace)" : datum)
+          headers << (options[:encoding] ? datum + ".to_s.encode('#{options[:encoding]}', invalid: :replace, undef: :replace)" : datum)
         end
-        return headers
+        headers
       end
 
-      def columns_to_array(nature, options={})
+      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]}', invalid: :replace, undef: :replace)" : datum)
+          next unless 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]}', invalid: :replace, undef: :replace)" : datum)
         end
-        return array
+        array
       end
-
     end
   end
 end

data/lib/active_list/exporters/csv_exporter.rb

@@ -1,11 +1,8 @@
 module ActiveList
-
   module Exporters
-
     class CsvExporter < AbstractExporter
-
       def file_extension
-        "csv"
+        'csv'
       end
 
       def mime_type
@@ -13,20 +10,17 @@ module ActiveList
       end
 
       def send_data_code
-        record = "r"
-        code  = generator.select_data_code(paginate: false)
+        record = 'r'
+        code = generator.select_data_code(paginate: false)
         code << "data = ::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
+        code << "send_data(data, type: #{mime_type.to_s.inspect}, disposition: 'inline', filename: #{table.model.name}.model_name.human.gsub(/[^a-z0-9]/i, '_') + '.#{file_extension}')\n"
+        code.c
       end
-
     end
-
   end
-
 end

data/lib/active_list/exporters/excel_csv_exporter.rb

@@ -1,14 +1,11 @@
 # Register XCSV format unless is already set
-Mime::Type.register("text/csv", :xcsv) unless defined? Mime::XCSV
+Mime::Type.register('text/csv', :xcsv) unless defined? Mime::XCSV
 
 module ActiveList
-
   module Exporters
-
     class ExcelCsvExporter < CsvExporter
-
       def file_extension
-        "csv"
+        'csv'
       end
 
       def mime_type
@@ -16,21 +13,18 @@ module ActiveList
       end
 
       def send_data_code
-        record = "r"
-        code  = generator.select_data_code(paginate: false)
-        encoding = "CP1252"
+        record = 'r'
+        code = generator.select_data_code(paginate: false)
+        encoding = 'CP1252'
         code << "data = ::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
+        code << "send_data(data, type: #{mime_type.to_s.inspect}, disposition: 'inline', filename: #{table.model.name}.model_name.human.gsub(/[^a-z0-9]/i,'_')+'.#{file_extension}')\n"
+        code.c
       end
-
     end
-
   end
-
 end