module Sanitization::ActiveRecordExtension::ClassMethods

Attributes

sanitization__store[RW]

Private Instance Methods

sanitization(options = {})
Alias for: sanitizes
sanitizes(options = {}) click to toggle source
# File lib/sanitization/active_record_extension.rb, line 12
      def sanitizes(options = {})
        # Skip initialization if table is not yet created. For example, during migrations.
        begin
          return unless ActiveRecord::Base.connection.data_source_exists?(self.table_name)
        rescue ActiveRecord::NoDatabaseError
          return
        end

        self.sanitization__store ||= {}

        options[:only]   = Array.wrap(options[:only])
        options[:except] = Array.wrap(options[:except])

        unless options[:case].nil?
          raise ArgumentError.new("Invalid type for `case`: #{options[:case].class}") \
            unless [String, Symbol].include?(options[:case].class)
          options[:case] = options[:case].downcase.to_s
          options[:case] = options[:case] + "case" unless options[:case] =~ /case$/
        end

        columns_to_format  = self.columns.select { |c| c.type == :string }
        columns_to_format  = columns_to_format.concat(self.columns.select { |c| c.type == :text }) \
          if options[:include_text_type]

        columns_to_format = options[:only].map do |col|
          columns_to_format.detect { |c| c.name == col.to_s }
        end.compact if options[:only].present?

        options[:except].each do |col|
          columns_to_format.delete_if { |c| c.name == col.to_s }
        end

        if options[:case]
          @valid_case_methods ||= String.new.methods.map { |m|
            m.to_s if m.to_s =~ /case$/
          }.compact

          raise ArgumentError.new("Method not found: `:#{options[:case]}`. " +
            "Valid methods are: :#{@valid_case_methods.join(', :')}") \
            unless @valid_case_methods.include?(options[:case]) || options[:case] == :none
        end

        columns_to_format.each do |col|
          self.sanitization__store[col.name] ||= {}
          self.sanitization__store[col.name].merge!(options.slice(:case, :strip, :collapse, :nullify))
        end

        class_eval <<-EOV
          include Sanitization::ActiveRecordExtension::InstanceMethods
          before_save :sanitization__format_strings
        EOV
      end
Also aliased as: sanitization