active-list 5.0.1 → 6.0.0

data/lib/active-list.rb

@@ -1 +0,0 @@
-require 'active_list'

data/lib/active_list.rb

@@ -1,43 +0,0 @@
-require 'csv'
-require 'action_dispatch'
-require 'rails'
-require 'compass-rails'
-
-module ActiveList
-
-  CSV = ::CSV
-
-  # 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
-  end
-
-  def self.version 
-    v = nil
-    File.open(File.join(File.dirname(__FILE__), "..", "VERSION")) {|f| v = f.read.strip}
-    return v
-  end
-
-  VERSION = self.version.freeze
-
-  autoload :Helpers,    'active_list/helpers'
-  autoload :Definition, 'active_list/definition'
-  autoload :Renderers,  'active_list/renderers'
-  autoload :Exporters,  'active_list/exporters'
-  autoload :Generator,  'active_list/generator'
-  autoload :ActionPack, 'active_list/action_pack'
-end
-
-unless "".respond_to? :dig
-  class ::String
-    def dig(depth = 1)
-      return self.strip.gsub(/^/, '  ' * depth) + "\n"
-    end
-  end
-end
-
-
-require 'active_list/rails/engine'

data/lib/active_list/action_pack.rb

@@ -1,46 +0,0 @@
-module ActiveList
-
-  module ActionPack
-
-    module ActionController
-
-      def self.included(base) #:nodoc:
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-
-        # Permits to define and generate methods to manage dynamic
-        # table ActiveList
-        def list(*args, &block)
-          options = args.extract_options!
-          options[:controller] = self
-          args << options
-          generator = ActiveList::Generator.new(*args, &block)
-          class_eval(generator.controller_method_code, __FILE__, __LINE__)
-          ActionView::Base.send(:class_eval, generator.view_method_code, __FILE__, __LINE__)
-        end
-
-      end
-
-    end
-
-    module ViewsHelper
-
-      # Calls the generated view helper
-      def list(*args, &block)
-        options = args.extract_options!
-        name = args.shift
-        kontroller = self.controller.class
-        begin
-          helper_method = "_#{kontroller.controller_name}_#{__method__}_#{name || kontroller.controller_name}_tag".to_sym
-          kontroller = kontroller.superclass
-        end until self.respond_to?(helper_method)
-        return self.send(helper_method, &block)
-      end
-
-    end
-
-  end
-
-end

data/lib/active_list/definition.rb

@@ -1,17 +0,0 @@
-module ActiveList
-
-  module Definition
-    autoload :AbstractColumn,    'active_list/definition/abstract_column'
-    autoload :ActionColumn,      'active_list/definition/action_column'
-    autoload :AssociationColumn, 'active_list/definition/association_column'
-    autoload :AttributeColumn,   'active_list/definition/attribute_column'
-    autoload :CheckBoxColumn,    'active_list/definition/check_box_column'
-    autoload :DataColumn,        'active_list/definition/data_column'
-    autoload :EmptyColumn,       'active_list/definition/empty_column'
-    autoload :FieldColumn,       'active_list/definition/field_column'
-    autoload :StatusColumn,      'active_list/definition/status_column'
-    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,54 +0,0 @@
-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

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

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

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

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

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