active-list 4.2.4 → 5.0.0

data/lib/active_list/definition/abstract_column.rb

@@ -0,0 +1,54 @@
+module ActiveList
+
+  module Definition
+
+    class AbstractColumn
+      attr_reader :table, :name, :id, :options
+
+      def initialize(table, name, options = {})
+        @table   = table
+        @name    = name.to_sym
+        @options = options
+        @hidden  = !!@options.delete(:hidden)
+        @id = ActiveList.new_uid
+      end
+
+      def header_code
+        raise NotImplementedError, "#{self.class.name}#header_code is not implemented."
+      end
+
+      def hidden?
+        @hidden
+      end
+
+      def sortable?
+        false
+      end
+
+      def exportable?
+        false
+      end
+
+      # Unique identifier of the column in the application
+      def unique_id
+        "#{@table.name}-#{@name}"
+      end
+
+      # Uncommon but simple identifier for CSS class uses
+      def short_id
+        @id
+      end
+
+      alias :sort_id :name
+
+      def check_options!(options, *keys)
+        for key in options.keys
+          raise ArgumentError, "Key :#{key} is unexpected. (Expecting: #{keys.to_sentence})"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/active_list/definition/action_column.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+module ActiveList
+
+  module Definition
+
+    class ActionColumn < AbstractColumn
+      include ActiveList::Helpers
+
+      def header_code
+        "''".c
+      end
+
+      def operation(record = 'record_of_the_death')
+        @options[:method] = :delete if @name.to_s == "destroy" and !@options.has_key?(:method)
+        @options[:confirm] ||= :are_you_sure_you_want_to_delete if @name.to_s == "destroy" and !@options.has_key?(:confirm)
+        @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)
+        link_options = ""
+        if @options[:confirm]
+          link_options << ", 'data-confirm' => #{(@options[:confirm]).inspect}.t(scope: 'labels')"
+        end
+        if @options['data-method'] or @options[:method]
+          link_options << ", :method => h('#{(@options['data-method']||@options[:method])}')"
+        end
+        action = @name
+        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 += ")"
+        elsif @options[:actions]
+          unless @options[:actions].is_a? Hash
+            raise StandardError, "options[:actions] have to be a Hash."
+          end
+          cases = []
+          for expected, url in @options[:actions]
+            cases << record+"."+@name.to_s+" == " + expected.inspect + "\nlink_to(content_tag(:i) + h(#{url[:action].inspect}.t(scope: 'labels'))"+
+              ", {"+(url[:controller] ? 'controller: :'+url[:controller].to_s+', ' : '')+"action: '"+url[:action].to_s+"', id: "+record+".id"+format+"}"+
+              ", {:class => '#{@name}'"+link_options+"}"+
+              ")\n"
+          end
+
+          code = "if "+cases.join("elsif ")+"end"
+        else
+          url = @options[:url] ||= {}
+          url[:controller] ||= (@options[:controller] || "RECORD.class.name.tableize".c) # self.table.model.name.underscore.pluralize.to_s
+          url[:action] ||= @name.to_s
+          url[:id] ||= "RECORD.id".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: 'labels')), "+url+", "+code+")"
+        end
+        if @options[:if]
+          code = "if " + recordify!(@options[:if], record) + "\n" + code.dig + "end"
+        end
+        if @options[:unless]
+          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

@@ -0,0 +1,80 @@
+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"
+        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
+          elsif @reflection.macro == :has_one
+            # Do some stuff
+          else
+            raise 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}."
+        end
+        columns_def = @reflection.class_name.constantize.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})"
+          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)}
+              @sort_column = :id
+            end
+          end
+        end
+      end
+
+
+      # Code for rows
+      def datum_code(record = 'record_of_the_death', child = false)
+        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
+        else
+          code = "(#{record}.#{@reflection.name} ? #{record}.#{@reflection.name}.#{@label_method} : nil)"
+        end
+        return code.c
+      end
+
+      def class_name
+        return @reflection.class_name
+      end
+
+      def record_expr(record = 'record_of_the_death')
+        return "#{record}.#{@reflection.name}"
+      end
+
+      def sort_expression
+        if table.reflections.select{|r| r.table_name == @reflection.table_name}.size > 1
+          "#{@reflection.name.to_s.pluralize}_#{@reflection.class_name.constantize.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

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

data/lib/active_list/definition/check_box_column.rb

@@ -0,0 +1,17 @@
+module ActiveList
+
+  module Definition
+
+    class CheckBoxColumn < FieldColumn
+      attr_reader :form_value
+
+      def initialize(table, name, options = {})
+        super(table, name, options)
+        @form_value = options.delete(:form_value)
+      end
+
+    end
+
+  end
+
+end

data/lib/active_list/definition/data_column.rb

@@ -0,0 +1,88 @@
+module ActiveList
+
+  module Definition
+
+    class DataColumn < AbstractColumn
+
+      LABELS_COLUMNS = [:full_name, :label, :name, :number, :coordinate]
+
+      def header_code
+        if @options[:label]
+          "#{@options[:label].to_s.strip.inspect}.t(scope: 'labels')".c
+        else
+          "#{@table.model.name}.human_attribute_name(#{@name.inspect})".c
+        end
+      end
+
+      # Code for exportation
+      def exporting_datum_code(record='record_of_the_death', noview=false)
+        datum = self.datum_code(record)
+        if self.datatype == :boolean
+          datum = "(#{datum} ? ::I18n.translate('list.export.true_value') : ::I18n.translate('list.export.false_value'))"
+        elsif self.datatype == :date
+          datum = "(#{datum}.nil? ? '' : #{datum}.l)"
+        elsif self.datatype == :decimal and not noview
+          currency = nil
+          if currency = self.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
+          datum = "(Nomen::Currencies[#{datum}] ? Nomen::Currencies[#{datum}].human_name : '')"
+        elsif @name.to_s.match(/(^|\_)country$/) and  self.datatype == :string
+          datum = "(Nomen::Countries[#{datum}] ? Nomen::Countries[#{datum}].human_name : '')"
+        elsif @name.to_s.match(/(^|\_)language$/) and self.datatype == :string
+          datum = "(Nomen::Languages[#{datum}] ? Nomen::Languages[#{datum}].human_name : '')"
+        elsif self.enumerize?
+          datum = "(#{datum}.nil? ? '' : #{datum}.text)"
+        end
+        return datum
+      end
+
+      # Returns the data type of the column if the column is in the database
+      def datatype
+        @options[:datatype] || (@column ? @column.type : nil)
+      end
+
+
+      def enumerize?
+        return false
+      end
+
+      def numeric?
+        [:decimal, :integer, :float, :numeric].include? self.datatype
+      end
+
+      # Returns the size/length of the column if the column is in the database
+      def limit
+        @column[:limit] if @column
+      end
+
+      # Defines if column is exportable
+      def exportable?
+        true
+      end
+
+      # Check if a column is sortable
+      def sortable?
+        return true
+        # not self.action? and
+        not self.options[:through] and not @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
+      end
+
+      def sort_expression
+        raise NotImplementedError, "sort_expression must be implemented"
+      end
+
+    end
+
+  end
+
+end

data/lib/active_list/definition/empty_column.rb

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

data/lib/active_list/definition/field_column.rb

@@ -0,0 +1,20 @@
+module ActiveList
+
+  module Definition
+
+    class FieldColumn < AbstractColumn
+      attr_reader :form_name
+
+      def initialize(table, name, options = {})
+        super(table, name, options)
+        @form_name = options.delete(:form_name)
+      end
+
+      def header_code
+        "#{@table.model.name}.human_attribute_name('#{@name}')"
+      end
+    end
+
+  end
+
+end

data/lib/active_list/definition/status_column.rb

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

data/lib/active_list/definition/table.rb

@@ -0,0 +1,159 @@
+module ActiveList
+
+  module Definition
+
+    class Table
+      attr_reader :name, :model, :options, :id, :columns, :parameters
+
+      def initialize(name, model = nil, options = {})
+        @name    = name
+        @model   = model || name.to_s.classify.constantize
+        @options = options
+        @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
+        @columns = []
+        @id = ActiveList.new_uid
+      end
+
+      def new_column_id
+        @current_column_id ||= 0
+        id = @current_column_id.to_s(36).to_sym
+        @current_column_id += 1
+        return id
+      end
+
+      def model_columns
+        @model.columns_hash.values
+      end
+
+      def sortable_columns
+        @columns.select{|c| c.sortable?}
+      end
+
+      def exportable_columns
+        @columns.select{|c| c.exportable?}
+      end
+
+      def children
+        @columns.map(&:child)
+      end
+
+      def paginate?
+        @paginate
+      end
+
+      # 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}
+      end
+
+      def data_columns
+        @columns.select{|c| c.is_a? DataColumn}
+      end
+
+      def hidden_columns
+        self.data_columns.select(&:hidden?)
+      end
+
+      # Compute includes Hash
+      def reflections
+        hash = []
+        for column in self.columns
+          if column.respond_to?(:reflection)
+            unless hash.detect{|r| r.name == column.reflection.name }
+              hash << column.reflection
+            end
+          end
+        end
+        return 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
+      end
+
+      # Add a new method in Table which permit to define check_box columns
+      def check_box(name, options = {})
+        add :check_box, name, options
+      end
+
+      # Add a new method in Table which permit to define action columns
+      def action(name, options = {})
+        add :action, name, options
+      end
+
+      # # Add a new method in Table which permit to define data columns
+      # def attribute(name, options = {})
+      #   add :attribute, name, options
+      # end
+
+      # # Add a column referencing an association
+      # def association(name, options = {})
+      #   options[:through] ||= name
+      #   add :association, name, options
+      # end
+
+      # Add a new method in Table which permit to define data columns
+      def column(name, options = {})
+        if @model.reflect_on_association(name)
+          options[:through] ||= name
+          add :association, name, options
+        elsif @model.reflect_on_association(options[:through])
+          options[:label_method] ||= name
+          add :association, name, options
+        else
+          add :attribute, name, options
+        end
+      end
+
+      def status(*args)
+        options = args.extract_options!
+        name = args.shift || :status
+        add :status, name, options
+      end
+
+
+      def load_default_columns
+        for column in self.model_columns
+          reflections = @model.reflections.values.select{|r| r.macro == :belongs_to and 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)
+          else
+            self.column(column.name)
+          end
+        end
+        return 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
+          unless name.is_a?(Symbol)
+            raise 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}"
+          end
+          @columns << klass.new(self, name, options)
+        else
+          raise ArgumentError, "Invalid column type: #{type.inspect}"
+        end
+      end
+
+
+    end
+
+
+  end
+
+end