class SBSM::Validator

Constants

ALLOWED_TAGS
BOOLEAN
DATES
ENUMS
EVENTS
FILES
HTML
NUMERIC
PATTERNS
STRINGS
URIS

Public Class Methods

new() click to toggle source
# File lib/sbsm/validator.rb, line 58
def initialize
        reset_errors()
        @boolean = self::class::BOOLEAN.dup
        @dates = self::class::DATES.dup
        @enums = self::class::ENUMS.dup
        @events = self::class::EVENTS.dup
        @files = self::class::FILES.dup
        @html = self::class::HTML.dup
        @numeric = self::class::NUMERIC.dup
        @patterns = self::class::PATTERNS.dup
        @strings = self::class::STRINGS.dup
        @uris = self::class::URIS.dup
end

Public Instance Methods

error?() click to toggle source
# File lib/sbsm/validator.rb, line 71
def error?
        !@errors.empty?
end
perform_validation(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 124
def perform_validation(key, value)
                    value = value.to_s.strip
  # require 'pry'; binding.pry if /event/.match(key.to_s)
  begin
                            if(key==:event)
                                    symbol = value.to_sym
                                    symbol if @events.include?(symbol)
                            elsif(@boolean.include?(key))
                                    validate_boolean(key, value)
                            elsif(@dates.include?(key))
                                    validate_date(key, value)
                            elsif(@enums.has_key?(key))
                                    value if @enums[key].include?(value)
                            elsif(@html.include?(key))
                                    validate_html(value)
                            elsif(@patterns.include?(key))
                                    validate_pattern(key, value)
                            elsif(@numeric.include?(key))
                                    validate_numeric(key, value)
                            elsif(@uris.include?(key))
                                    validate_uri(key, value)
                            elsif(@strings.include?(key))
                                    validate_string(value)
    elsif(@files.include?(key))
      StringIO.new(value)
                            elsif(!Object.methods.include?(key) and self.respond_to?(key, true))
                                    self.send(key, value)
                            end
                    rescue InvalidDataError => e
    SBSM.debug("#{e.key} #{e}")
                            @errors.store(e.key, e)
                    end
            end
reset_errors() click to toggle source
# File lib/sbsm/validator.rb, line 74
def reset_errors
        @errors = {}
end
set_pass(value1, value2) click to toggle source
# File lib/sbsm/validator.rb, line 77
def set_pass(value1, value2)
        valid1 = pass(value1.to_s)
        valid2 = pass(value2.to_s)
        if(value1.to_s.empty?)
                SBSM::InvalidDataError.new(:e_empty_pass, :pass, '')
        elsif(valid1 != valid2)
                SBSM::InvalidDataError.new(:e_non_matching_pass, :pass, '')
        else
                valid1
        end
end
valid_values(key) click to toggle source
# File lib/sbsm/validator.rb, line 88
def valid_values(key)
        key = key.intern if key.is_a? String
        @enums.fetch(key)    {
                if(@boolean.include?(key))
                        ['false', 'true']
                end
        }
end
validate(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 96
            def validate(key, value)
                    value = value.pop if value.is_a? Array
                    return nil if value.nil?
  # SBSM.info("validate #{key} #{value.class} #{value}")
  if value.is_a?(StringIO)
                            if(@files.include?(key))
                                    return validate_file(key, value)
                            else
                                    begin
                                            value = value.read
                                    rescue StandardError => e
                                            p e
                                    end
                            end
                    elsif(value.is_a?(Array)) # TODO::
                            value = value[0]
                            if(@files.include?(key))
                                    return validate_file(key, value)
                            else
                                    begin
                                            value = value.read
                                    rescue StandardError => e
                                            #p e
                                    end
                            end
                    end
  perform_validation(key, value)
end

Private Instance Methods

_validate_html(value, valid=self.class.const_get(:ALLOWED_TAGS)) click to toggle source
# File lib/sbsm/validator.rb, line 227
def _validate_html(value, valid=self.class.const_get(:ALLOWED_TAGS))
                    doc = Hpricot(value.gsub(@@xml_ptrn, ''), :fixup_tags => true)
  (doc/"*").each { |element|
    unless(element.is_a?(Hpricot::Text) \
           || (element.respond_to?(:name) \
               && valid.include?(element.name.downcase)))
      element.swap _validate_html(element.inner_html.to_s)
    end
  }
  valid = doc.to_html
  valid.force_encoding 'UTF-8' if valid.respond_to?(:force_encoding)
  valid
end
confirm_pass(value)
Alias for: pass
default_flavor(value)
Alias for: flavor
email(value) click to toggle source
# File lib/sbsm/validator.rb, line 158
def email(value)
        return if(value.empty?)
        parsed = Mail::Address.new(value)
        if(parsed.nil?)
          raise InvalidDataError.new(:e_invalid_email_address, :email, value)
                elsif (parsed.domain)
                parsed.to_s
        else
                raise InvalidDataError.new(:e_invalid_email_address, :email, value)
        end
rescue => e
        if e.class == SBSM::InvalidDataError
                raise e
        else
                raise InvalidDataError.new(:e_invalid_email_address, :email, value)
        end
end
filename(value) click to toggle source
# File lib/sbsm/validator.rb, line 175
def filename(value)
        if(value == File.basename(value))
                value
        end
end
flavor(value) click to toggle source
# File lib/sbsm/validator.rb, line 180
def flavor(value)
        validate_string(value)
end
Also aliased as: default_flavor
language(value) click to toggle source
# File lib/sbsm/validator.rb, line 184
def language(value)
        validate_string(value)
end
pass(value) click to toggle source
# File lib/sbsm/validator.rb, line 187
          def pass(value)
unless(value.empty?)
                    Digest::MD5::hexdigest(value)
end
          end
Also aliased as: confirm_pass
state_id(value) click to toggle source
# File lib/sbsm/validator.rb, line 194
def state_id(value)
        if(match = @@state_id_ptrn.match(value))
                match[0].to_i
        else
                nil
        end
end
validate_boolean(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 201
def validate_boolean(key, value)
        case value.to_s.downcase
        when 'true', '1', 'y', 'j'
                true
        when 'false', '0', 'n'
                false
        else 
                raise InvalidDataError.new(:e_invalid_boolean, key, value)
        end
end
validate_date(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 211
def validate_date(key, value)
        return nil if (value.empty?)
        begin
                Date.parse(value.tr('.', '-'))
        rescue ArgumentError
                raise InvalidDataError.new(:e_invalid_date, key, value)
        end
end
validate_file(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 219
def validate_file(key, value)
        return nil if value.original_filename.empty?
        value
end
validate_html(value) click to toggle source
# File lib/sbsm/validator.rb, line 223
def validate_html(value)
  _validate_html(value)
end
validate_numeric(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 241
def validate_numeric(key, value)
        return if(value.empty?)
        if(match = @@numeric_ptrn.match(value))
                match[0]
        else
                raise InvalidDataError.new("e_invalid_#{key}", key, value)
        end
end
validate_pattern(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 249
def validate_pattern(key, value)
        pattern = @patterns[key] 
        if(match = pattern.match(value))
                match[0]
        end
end
validate_string(value) click to toggle source
# File lib/sbsm/validator.rb, line 255
          def validate_string(value)
_validate_html(value, [])
          end
validate_uri(key, value) click to toggle source
# File lib/sbsm/validator.rb, line 258
def validate_uri(key, value)
        uri = URI.parse(value)
        if(uri.scheme.nil?)
                uri = URI.parse('http://' << value)
        end
        uri
rescue 
        raise InvalidDataError.new(:e_invalid_uri, key, value)
end