class Mail::Field

sections 3 and 4 of this standard.
2.2.3. All field bodies MUST conform to the syntax described in
used in header “folding” and “unfolding” as described in section
except for CR and LF. However, a field body may contain CRLF when
colon. A field body may be composed of any US-ASCII characters,
characters that have values between 33 and 126, inclusive), except
name MUST be composed of printable US-ASCII characters (i.e.,
(“:”), followed by a field body, and terminated by CRLF. A field
Header fields are lines composed of a field name, followed by a colon
2.2. Header Fields
===Per RFC 2822
the correct field of class back on new.
field. Works out per RFC what field of field it is being given and returns
Provides a single class to call to create a new structured or unstructured

def <=>(other)

def <=>(other)
  field_order_id <=> other.field_order_id
end

def ==(other)

def ==(other)
  same(other) && Utilities.match_to_s(other.value, value)
end

def create_field(name, value, charset)

def create_field(name, value, charset)
  parse_field(name, value, charset)
rescue Mail::Field::ParseError => e
  field = Mail::UnstructuredField.new(name, value)
  field.errors << [name, value, e]
  field
end

def field

def field
  @field ||= create_field(@name, @unparsed_value, @charset)
end

def field=(field)

def field=(field)
  @field = field
end

def field_class_for(name) #:nodoc:

:nodoc:

def field_class_for(name) #:nodoc:
  FIELDS_MAP[name.to_s.downcase]
end

def field_order_id

def field_order_id
  @field_order_id ||= FIELD_ORDER_LOOKUP.fetch(self.name.to_s.downcase, 100)
end

def initialize(name, value = nil, charset = 'utf-8')

# => #
Mail::Field.new('content-type', ['text', 'plain', {:charset => 'UTF-8'}])

# => #
Mail::Field.new("field-name", 1234)

Values that aren't strings or arrays are coerced to Strings with `#to_s`.

# => #
Mail::Field.new("field-name", "value")

Create a field by name and optional value:

def initialize(name, value = nil, charset = 'utf-8')
  case
  when name.index(Constants::COLON)
    raise ArgumentError, 'Passing an unparsed header field to Mail::Field.new is not supported in Mail 2.8.0+. Use Mail::Field.parse instead.'
  when Utilities.blank?(value)
    @name = name
    @unparsed_value = nil
    @charset = charset
  else
    @name = name
    @unparsed_value = value
    @charset = charset
  end
  @name = FIELD_NAME_MAP[@name.to_s.downcase] || @name
end

def inspect

def inspect
  "#<#{self.class.name} 0x#{(object_id * 2).to_s(16)} #{instance_variables.map do |ivar|
    "#{ivar}=#{instance_variable_get(ivar).inspect}"
  end.join(" ")}>"
end

def method_missing(name, *args, &block)

def method_missing(name, *args, &block)
  field.send(name, *args, &block)
end

def name

def name
  @name
end

def parse(field, charset = 'utf-8')

# => #
Mail::Field.parse("field-name: field data")

Parse a field from a raw header line:

def parse(field, charset = 'utf-8')
  name, value = split(field)
  if name && value
    new name, value, charset
  end
end

def parse_field(name, value, charset)

def parse_field(name, value, charset)
  value = unfold(value) if value.is_a?(String)
  if klass = self.class.field_class_for(name)
    klass.parse(value, charset)
  else
    OptionalField.parse(name, value, charset)
  end
end

def respond_to_missing?(method_name, include_private)

def respond_to_missing?(method_name, include_private)
  field.respond_to?(method_name, include_private) || super
end

def responsible_for?(field_name)

def responsible_for?(field_name)
  name.to_s.casecmp(field_name.to_s) == 0
end

def same(other)

def same(other)
  other.kind_of?(self.class) && Utilities.match_to_s(other.name, name)
end

def split(raw_field) #:nodoc:

:nodoc:

def split(raw_field) #:nodoc:
  if raw_field.index(Constants::COLON)
    name, value = raw_field.split(Constants::COLON, 2)
    name.rstrip!
    if name =~ /\A#{Constants::FIELD_NAME}\z/
      [ name.rstrip, value.strip ]
    else
      Kernel.warn "WARNING: Ignoring unparsable header #{raw_field.inspect}: invalid header name syntax: #{name.inspect}"
      nil
    end
  else
    raw_field.strip
  end
rescue => error
  warn "WARNING: Ignoring unparsable header #{raw_field.inspect}: #{error.class}: #{error.message}"
  nil
end

def to_s

def to_s
  field.to_s
end

def unfold(string)

evaluation.
treated in its unfolded form for further syntactic and semantic
that is immediately followed by WSP. Each header field should be
"unfolding". Unfolding is accomplished by simply removing any CRLF
of a header field to its single line representation is called
The process of moving from this folded multiple-line representation

2.2.3. Long Header Fields

def unfold(string)
  string.gsub(Constants::UNFOLD_WS, '\1')
end

def value

def value
  field.value
end

def value=(val)

def value=(val)
  @field = create_field(name, val, @charset)
end

Modules

Classes