active_list 6.5.1 → 6.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd1c6d6bc71de1ff739a1aee1f4a0d40148aeafa
-  data.tar.gz: 9f558415274955c8b5cc4f09bdd250bc8c071369
+  metadata.gz: 972efe1084c46b43af24147f815d2b63a0df506e
+  data.tar.gz: 6f0597c282d17598f0a71641ac127cc0b7174ebd
 SHA512:
-  metadata.gz: 9fbd4af4697a60e0bd4d3c422bcb9933e20754f6309fdbb08d1a1f2535fb38131fd7716b84ece7379ffa2ab3d1fe8e8e9e63935b36e87c7b637feb27e61a3baf
-  data.tar.gz: c214f63958f4829ad092cfe7f6a71fc92ddfad2506ce69025478afdfcad1afdb8e85ce66bbac4e8beaac00c9036562c86fae578ce1219b78f92de25096ac7550
+  metadata.gz: 15c0e1d3f882e0a7a4695f583e1b40db285370e09fdc7b62b89a3fe1d13cf9d9f603599b01e1ccd48be7349511d72181e00e59678b0335fe7fe2bea3f246ff42
+  data.tar.gz: 7b94b8274545d712ce4e3aef8b1ba8ab8eb8b2002c2d8fb195524aa468088cb7c60a6d54a6acc58106676e348883227de63aff1ddadca640a850031e11ffc51a

data/lib/active_list.rb

@@ -1,3 +1,4 @@
+
 require 'csv'
 require 'action_dispatch'
 require 'rails'
@@ -5,13 +6,12 @@ require 'code_string'
 require 'i18n-complements'
 
 module ActiveList
-
   # Build and returns a short UID
   def self.new_uid
     @@last_uid ||= 0
     uid = @@last_uid.to_s(36).to_sym
     @@last_uid += 1
-    return uid
+    uid
   end
 
   autoload :VERSION,    'active_list/version'
@@ -24,7 +24,7 @@ module ActiveList
   # Set the temporary directory
   # Pathname or callable are acceptable
   def self.temporary_directory=(dir)
-    if dir.respond_to?(:call) or dir.is_a?(Pathname)
+    if dir.respond_to?(:call) || dir.is_a?(Pathname)
       @@temporary_directory = dir
     else
       @@temporary_directory = Pathname(dir)
@@ -40,12 +40,13 @@ module ActiveList
     end
   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
+    unless renderer < ActiveList::Renderers::AbstractRenderer
+      fail ArgumentError, 'A renderer must be ActiveList::Renderers::Renderer'
+    end
     @@renderers[name] = renderer
   end
 
@@ -53,10 +54,11 @@ module ActiveList
   @@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
+    unless exporter < ActiveList::Exporters::AbstractExporter
+      fail ArgumentError, "ActiveList::Exporters::AbstractExporter expected (got #{exporter.name}/#{exporter.ancestors.inspect})"
+    end
     @@exporters[name] = exporter
   end
-
 end
 
 ActiveList.temporary_directory = Pathname(Dir.tmpdir)
@@ -67,14 +69,12 @@ ActiveList.register_exporter(:ods,  ActiveList::Exporters::OpenDocumentSpreadshe
 ActiveList.register_exporter(:csv,  ActiveList::Exporters::CsvExporter)
 ActiveList.register_exporter(:xcsv, ActiveList::Exporters::ExcelCsvExporter)
 
-
-unless "string".respond_to? :dig
+unless 'string'.respond_to? :dig
   class ::String
     def dig(depth = 1)
-      return self.strip.gsub(/^/, '  ' * depth) + "\n"
+      strip.gsub(/^/, '  ' * depth) + "\n"
     end
   end
 end
 
-
 require 'active_list/rails'

data/lib/active_list/definition.rb

@@ -1,5 +1,4 @@
 module ActiveList
-
   module Definition
     autoload :AbstractColumn,    'active_list/definition/abstract_column'
     autoload :ActionColumn,      'active_list/definition/action_column'
@@ -13,5 +12,4 @@ module ActiveList
     autoload :Table,             'active_list/definition/table'
     autoload :TextFieldColumn,   'active_list/definition/text_field_column'
   end
-
 end

data/lib/active_list/definition/abstract_column.rb

@@ -1,7 +1,5 @@
 module ActiveList
-
   module Definition
-
     class AbstractColumn
       attr_reader :table, :name, :id, :options
 
@@ -10,11 +8,11 @@ module ActiveList
         @name    = name.to_sym
         @options = options
         @hidden  = !!@options.delete(:hidden)
-        @id = ActiveList.new_uid
+        @id = 'c' + @table.new_column_id # ActiveList.new_uid
       end
 
       def header_code
-        raise NotImplementedError, "#{self.class.name}#header_code is not implemented."
+        fail NotImplementedError, "#{self.class.name}#header_code is not implemented."
       end
 
       def hidden?
@@ -39,16 +37,13 @@ module ActiveList
         @id
       end
 
-      alias :sort_id :name
+      alias_method :sort_id, :name
 
       def check_options!(options, *keys)
         for key in options.keys
-          raise ArgumentError, "Key :#{key} is unexpected. (Expecting: #{keys.to_sentence})"
+          fail ArgumentError, "Key :#{key} is unexpected. (Expecting: #{keys.to_sentence})"
         end
       end
-
     end
-
   end
-
 end

data/lib/active_list/definition/action_column.rb

@@ -1,12 +1,10 @@
 # coding: utf-8
 module ActiveList
-
   module Definition
-
     class ActionColumn < AbstractColumn
       include ActiveList::Helpers
 
-      ID_PLACEHOLDER = "##IDS##"
+      ID_PLACEHOLDER = '##IDS##'
 
       USE_MODES = [:none, :single, :many, :both]
 
@@ -16,25 +14,25 @@ module ActiveList
         super(table, name, options)
         @use_mode = (@options.delete(:on) || :single).to_sym
         unless USE_MODES.include?(@use_mode)
-          raise "Invalid use mode: #{@use_mode.inspect}"
+          fail "Invalid use mode: #{@use_mode.inspect}"
         end
-        if @name.to_s == "destroy" and !@options.has_key?(:method)
-          @options[:method] = :delete 
+        if @name.to_s == 'destroy' && !@options.key?(:method)
+          @options[:method] = :delete
         end
-        if @name.to_s == "destroy" and !@options.has_key?(:confirm)
-          @options[:confirm] ||= :are_you_sure_you_want_to_delete 
+        if @name.to_s == 'destroy' && !@options.key?(:confirm)
+          @options[:confirm] ||= :are_you_sure_you_want_to_delete
         end
-        @options[:if] ||= :destroyable? if @name.to_s == "destroy"
-        @options[:if] ||= :editable?    if @name.to_s == "edit"
+        @options[:if] ||= :destroyable? if @name.to_s == 'destroy'
+        @options[:if] ||= :editable?    if @name.to_s == 'edit'
         @options[:confirm] = :are_you_sure if @options[:confirm].is_a?(TrueClass)
       end
 
       def use_single?
-        @use_mode == :single or @use_mode == :both
+        @use_mode == :single || @use_mode == :both
       end
 
       def use_many?
-        @use_mode == :many or @use_mode == :both
+        @use_mode == :many || @use_mode == :both
       end
 
       def use_none?
@@ -42,7 +40,7 @@ module ActiveList
       end
 
       def global?
-        self.use_none? or self.use_many?
+        self.use_none? || self.use_many?
       end
 
       def header_code
@@ -53,17 +51,13 @@ module ActiveList
         url = @options[:url] ||= {}
         url[:controller] ||= (@options[:controller] || table.model.name.tableize)
         url[:action] ||= @name.to_s
-        if @options.has_key? :format
-          url[:format] = @options[:format]
-        end
-        if use_many? and use_mode == :many
-          url[:id] ||= ID_PLACEHOLDER
-        end
-        return url
+        url[:format] = @options[:format] if @options.key? :format
+        url[:id] ||= ID_PLACEHOLDER if use_many? && use_mode == :many
+        url
       end
 
       def operation(record = 'record_of_the_death')
-        link_options = ""
+        link_options = ''
         if @options[:confirm]
           link_options << ", 'data-confirm' => #{(@options[:confirm]).inspect}.t(scope: 'labels')"
         end
@@ -71,62 +65,60 @@ module ActiveList
           link_options << ", method: :#{@options[:method].to_s.underscore}"
         end
         action = @name
-        format = @options[:format] ? ", format: '#{@options[:format]}'" : ""
+        format = @options[:format] ? ", format: '#{@options[:format]}'" : ''
         if @options[:remote]
-          raise StandardError, "Sure to use :remote ?"
-          # remote_options = @options.dup
-          # remote_options['data-confirm'] = "#{@options[:confirm].inspect}.tl".c unless @options[:confirm].nil?
-          # remote_options.delete :remote
-          # remote_options.delete :image
-          # remote_options = remote_options.inspect.to_s
-          # remote_options = remote_options[1..-2]
-          # code  = "link_to_remote(#{image}"
-          # code += ", {url: {action: "+@name.to_s+", id: "+record+".id"+format+"}"
-          # code += ", "+remote_options+"}"
-          # code += ", {title: #{action.inspect}.tl}"
-          # code += ")"
+          fail StandardError, 'Sure to use :remote ?'
+        # remote_options = @options.dup
+        # remote_options['data-confirm'] = "#{@options[:confirm].inspect}.tl".c unless @options[:confirm].nil?
+        # remote_options.delete :remote
+        # remote_options.delete :image
+        # remote_options = remote_options.inspect.to_s
+        # remote_options = remote_options[1..-2]
+        # code  = "link_to_remote(#{image}"
+        # code += ", {url: {action: "+@name.to_s+", id: "+record+".id"+format+"}"
+        # code += ", "+remote_options+"}"
+        # code += ", {title: #{action.inspect}.tl}"
+        # code += ")"
         elsif @options[:actions]
           unless use_single?
-            raise StandardError, "Only compatible with single actions"
+            fail StandardError, 'Only compatible with single actions'
           end
           unless @options[:actions].is_a? Hash
-            raise StandardError, ":actions parameter have to be a Hash."
+            fail StandardError, ':actions parameter have to be a Hash.'
           end
           cases = []
           for expected, url in @options[:actions]
-            url[:id] ||= "RECORD.id".c
-            url[:id] = "RECORD.id".c if url[:id] == ID_PLACEHOLDER
-            url[:redirect] ||= "params[:redirect]".c
-            url.delete_if{|k, v| v.nil?}
-            cases << "#{record}.#{@name} == #{expected.inspect}\nlink_to(content_tag(:i) + h(#{url[:action].inspect}.t(scope: 'rest.actions'))"+
-              ", {" + url.collect{|k, v| "#{k}: " + urlify(v, record)}.join(", ") + format + "}" +
-              ", {class: '#{@name}'" + link_options + "}"+
-              ")\n"
+            url[:id] ||= 'RECORD.id'.c
+            url[:id] = 'RECORD.id'.c if url[:id] == ID_PLACEHOLDER
+            url[:redirect] ||= 'params[:redirect]'.c
+            url.delete_if { |_k, v| v.nil? }
+            cases << "#{record}.#{@name} == #{expected.inspect}\nlink_to(content_tag(:i) + h(#{url[:action].inspect}.t(scope: 'rest.actions'))"\
+                     ', {' + url.collect { |k, v| "#{k}: " + urlify(v, record) }.join(', ') + format + '}' \
+                                                                                                       ", {class: '#{@name}'" + link_options + '}'\
+                                                                                                                                               ")\n"
           end
 
-          code = "if " + cases.join("elsif ") + "end"
+          code = 'if ' + cases.join('elsif ') + 'end'
         else
           url = @options[:url] ||= {}
-          url[:controller] ||= (@options[:controller] || "RECORD.class.name.tableize".c)
+          url[:controller] ||= (@options[:controller] || 'RECORD.class.name.tableize'.c)
           url[:action] ||= @name.to_s
-          url[:id] ||= "RECORD.id".c
-          url[:id] = "RECORD.id".c if url[:id] == ID_PLACEHOLDER
-          url[:redirect] ||= "params[:redirect]".c
-          url.delete_if{|k, v| v.nil?}
-          url = "{" + url.collect{|k, v| "#{k}: " + urlify(v, record)}.join(", ") + format + "}"
-          code = "{class: '#{@name}'" + link_options + "}"
-          code = "link_to(content_tag(:i) + h(' ' + :#{action}.t(scope: 'rest.actions')), " + url + ", " + code + ")"
+          url[:id] ||= 'RECORD.id'.c
+          url[:id] = 'RECORD.id'.c if url[:id] == ID_PLACEHOLDER
+          url[:redirect] ||= 'params[:redirect]'.c
+          url.delete_if { |_k, v| v.nil? }
+          url = '{' + url.collect { |k, v| "#{k}: " + urlify(v, record) }.join(', ') + format + '}'
+          code = "{class: '#{@name}'" + link_options + '}'
+          code = "link_to(content_tag(:i) + h(' ' + :#{action}.t(scope: 'rest.actions')), " + url + ', ' + code + ')'
         end
         if @options[:if]
-          code = "if " + recordify!(@options[:if], record) + "\n" + code.dig + "end"
+          code = 'if ' + recordify!(@options[:if], record) + "\n" + code.dig + 'end'
         end
         if @options[:unless]
-          code = "unless " + recordify!(@options[:unless], record) + "\n" + code.dig + "end"
+          code = 'unless ' + recordify!(@options[:unless], record) + "\n" + code.dig + 'end'
         end
         code.c
       end
     end
-
   end
-
 end

data/lib/active_list/definition/association_column.rb

@@ -1,85 +1,83 @@
 module ActiveList
-
   module Definition
-
     class AssociationColumn < DataColumn
-
       attr_reader :label_method, :reflection
 
       def initialize(table, name, options = {})
         super(table, name, options)
         unless @options[:through]
-          raise ArgumentError, "Option :through must be given"
+          fail ArgumentError, 'Option :through must be given'
         end
         reflection_name = @options.delete(:through).to_sym
         if @reflection = @table.model.reflect_on_association(reflection_name)
           if @reflection.macro == :belongs_to
-            # Do some stuff
+          # Do some stuff
           elsif @reflection.macro == :has_one
-            # Do some stuff
+          # Do some stuff
           else
-            raise ArgumentError, "Only belongs_to are usable. Can't handle: #{reflection.macro} :#{reflection.name}."
+            fail ArgumentError, "Only belongs_to are usable. Can't handle: #{reflection.macro} :#{reflection.name}."
           end
         else
-          raise UnknownReflection, "Reflection #{reflection_name} cannot be found for #{table.model.name}."
+          fail UnknownReflection, "Reflection #{reflection_name} cannot be found for #{table.model.name}."
         end
-        unless klass = @reflection.class_name.constantize rescue nil
-          raise StandardError, "Given reflection #{reflection_name} seems to be invalid"
+        unless klass = begin
+                         @reflection.class_name.constantize
+                       rescue
+                         nil
+                       end
+          fail StandardError, "Given reflection #{reflection_name} seems to be invalid"
         end
         columns_def = klass.columns_hash.keys.map(&:to_sym)
         unless @label_method = @options.delete(:label_method)
           columns = columns_def + @reflection.class_name.constantize.instance_methods.map(&:to_sym)
-          unless @label_method = LABELS_COLUMNS.detect{|m| columns.include?(m)}
-            raise ArgumentError, ":label_method option must be given for association #{name}. (#{columns.inspect})"
+          unless @label_method = LABELS_COLUMNS.detect { |m| columns.include?(m) }
+            fail ArgumentError, ":label_method option must be given for association #{name}. (#{columns.inspect})"
           end
         end
         unless @sort_column = @options.delete(:sort)
           if columns_def.include?(@label_method)
             @sort_column = @label_method
           else
-            unless @sort_column = LABELS_COLUMNS.detect{|m| columns_def.include?(m)}
+            unless @sort_column = LABELS_COLUMNS.detect { |m| columns_def.include?(m) }
               @sort_column = :id
             end
           end
         end
       end
 
-
       # Code for rows
       def datum_code(record = 'record_of_the_death', child = false)
-        code = ""
+        code = ''
         if child
-          code = "nil"
-          # if @options[:children].is_a?(FalseClass)
-          #   code = "nil"
-          # else
-          #   code = "#{record}.#{table.options[:children]}.#{@reflection.name}.#{@options[:children] || @label_method}"
-          # end
+          code = 'nil'
+        # if @options[:children].is_a?(FalseClass)
+        #   code = "nil"
+        # else
+        #   code = "#{record}.#{table.options[:children]}.#{@reflection.name}.#{@options[:children] || @label_method}"
+        # end
         else
           code = "(#{record}.#{@reflection.name} ? #{record}.#{@reflection.name}.#{@label_method} : nil)"
         end
-        return code.c
+        code.c
       end
 
       def class_name
-        return @reflection.class_name
+        @reflection.class_name
       end
 
       def record_expr(record = 'record_of_the_death')
-        return "#{record}.#{@reflection.name}"
+        "#{record}.#{@reflection.name}"
       end
 
       def sort_expression
-        same_table_reflections = table.reflections.select{|r| r.table_name == @reflection.table_name}
-        if same_table_reflections.size > 1 and same_table_reflections.index{|r| r.name == @reflection.name } > 0
+        same_table_reflections = table.reflections.select { |r| r.table_name == @reflection.table_name }
+        if same_table_reflections.size > 1 && same_table_reflections.index { |r| r.name == @reflection.name } > 0
           # "#{@reflection.name.to_s.pluralize}_#{@reflection.class_name.constantize.table_name}.#{@sort_column}"
           "#{@reflection.name.to_s.pluralize}_#{table.model.table_name}.#{@sort_column}"
         else
           "#{@reflection.class_name.constantize.table_name}.#{@sort_column}"
         end
       end
-
     end
-
   end
 end

data/lib/active_list/definition/attribute_column.rb

@@ -1,9 +1,6 @@
 module ActiveList
-
   module Definition
-
     class AttributeColumn < DataColumn
-
       attr_reader :column, :label_method, :sort_column
 
       def initialize(table, name, options = {})
@@ -18,31 +15,31 @@ module ActiveList
             @sort_column = :id
           end
         end
-        @column  = @table.model.columns_hash[@label_method.to_s]
+        @column = @table.model.columns_hash[@label_method.to_s]
       end
 
       # Code for rows
       def datum_code(record = 'record_of_the_death', child = false)
-        code = ""
+        code = ''
         if child
           if @options[:children].is_a?(FalseClass)
-            code = "nil"
+            code = 'nil'
           else
             code = "#{record}.#{table.options[:children]}.#{@options[:children] || @label_method}"
           end
         else
           code = "#{record}.#{@label_method}"
         end
-        return code.c
+        code.c
       end
 
       # Returns the class name of the used model
       def class_name
-        return self.table.model.name
+        table.model.name
       end
 
       def enumerize?
-        self.table.model.send(@label_method).send(:values)
+        table.model.send(@label_method).send(:values)
         return true
       rescue
         return false
@@ -51,8 +48,6 @@ module ActiveList
       def sort_expression
         "#{@table.model.table_name}.#{@sort_column}"
       end
-
     end
-
   end
 end