class Bundler::URI::MailTo


RFC6068, the mailto URL scheme.

def self.build(args)


m3.to_s # => "mailto:listman@example.com?subject=subscribe"
m3 = Bundler::URI::MailTo.build({:to => 'listman@example.com', :headers => [['subject', 'subscribe']]})

m2.to_s # => "mailto:john@example.com?Subject=Ruby&Cc=jack@example.com"
m2 = Bundler::URI::MailTo.build(['john@example.com', [['Subject', 'Ruby'], ['Cc', 'jack@example.com']]])

m1.to_s # => "mailto:joe@example.com?subject=Ruby"
m1 = Bundler::URI::MailTo.build(['joe@example.com', 'subject=Ruby'])

require 'bundler/vendor/uri/lib/uri'

Examples:

like [['subject', 'subscribe'], ['cc', 'address']].
"subject=subscribe&cc=address", or as an Array of Arrays
The headers can be supplied as a pre-encoded string, such as

If a Hash is used, the keys are the component names preceded by colons.

the components must be supplied as [to, headers].
Components can be provided as an Array or Hash. If an Array is used,

Creates a new Bundler::URI::MailTo object from components, with syntax checking.

== Description
def self.build(args)
  tmp = Util.make_components_hash(self, args)
  case tmp[:to]
  when Array
    tmp[:opaque] = tmp[:to].join(',')
  when String
    tmp[:opaque] = tmp[:to].dup
  else
    tmp[:opaque] = ''
  end
  if tmp[:headers]
    query =
      case tmp[:headers]
      when Array
        tmp[:headers].collect { |x|
          if x.kind_of?(Array)
            x[0] + '=' + x[1..-1].join
          else
            x.to_s
          end
        }.join('&')
      when Hash
        tmp[:headers].collect { |h,v|
          h + '=' + v
        }.join('&')
      else
        tmp[:headers].to_s
      end
    unless query.empty?
      tmp[:opaque] << '?' << query
    end
  end
  super(tmp)
end

def check_headers(v)

* HEADER_REGEXP
Checks the headers +v+ component against either 
def check_headers(v)
  return true unless v
  return true if v.size == 0
  if HEADER_REGEXP !~ v
    raise InvalidComponentError,
      "bad component(expected opaque component): #{v}"
  end
  true
end

def check_to(v)

Checks the to +v+ component. 
def check_to(v)
  return true unless v
  return true if v.size == 0
  v.split(/[,;]/).each do |addr|
    # check url safety as path-rootless
    if /\A(?:%\h\h|[!$&-.0-;=@-Z_a-z~])*\z/ !~ addr
      raise InvalidComponentError,
        "an address in 'to' is invalid as Bundler::URI #{addr.dump}"
    end
    # check addr-spec
    # don't s/\+/ /g
    addr.gsub!(/%\h\h/, Bundler::URI::TBLDECWWWCOMP_)
    if EMAIL_REGEXP !~ addr
      raise InvalidComponentError,
        "an address in 'to' is invalid as uri-escaped addr-spec #{addr.dump}"
    end
  end
  true
end

def headers=(v)

Setter for headers +v+. 
def headers=(v)
  check_headers(v)
  set_headers(v)
  v
end

def initialize(*arg)


the validity of each component.
This method is usually called from Bundler::URI::parse, which checks

no syntax checking.
Creates a new Bundler::URI::MailTo object from generic URL components with

== Description
def initialize(*arg)
  super(*arg)
  @to = nil
  @headers = []
  # The RFC3986 parser does not normally populate opaque
  @opaque = "?#{@query}" if @query && !@opaque
  unless @opaque
    raise InvalidComponentError,
      "missing opaque part for mailto URL"
  end
  to, header = @opaque.split('?', 2)
  # allow semicolon as a addr-spec separator
  # http://support.microsoft.com/kb/820868
  unless /\A(?:[^@,;]+@[^@,;]+(?:\z|[,;]))*\z/ =~ to
    raise InvalidComponentError,
      "unrecognised opaque part for mailtoURL: #{@opaque}"
  end
  if arg[10] # arg_check
    self.to = to
    self.headers = header
  else
    set_to(to)
    set_headers(header)
  end
end

def set_headers(v)

Private setter for headers +v+. 
def set_headers(v)
  @headers = []
  if v
    v.split('&').each do |x|
      @headers << x.split(/=/, 2)
    end
  end
end

def set_to(v)

Private setter for to +v+. 
def set_to(v)
  @to = v
end

def to=(v)

Setter for to +v+. 
def to=(v)
  check_to(v)
  set_to(v)
  v
end

def to_mailtext


# => "To: ruby-list@ruby-lang.org\nSubject: subscribe\nCc: myaddr\n\n\n"
uri.to_mailtext
uri = Bundler::URI.parse("mailto:ruby-list@ruby-lang.org?Subject=subscribe&cc=myaddr")

require 'bundler/vendor/uri/lib/uri'

Example:

Returns the RFC822 e-mail text equivalent of the URL, as a String. 
def to_mailtext
  to = Bundler::URI.decode_www_form_component(@to)
  head = ''
  body = ''
  @headers.each do |x|
    case x[0]
    when 'body'
      body = Bundler::URI.decode_www_form_component(x[1])
    when 'to'
      to << ', ' + Bundler::URI.decode_www_form_component(x[1])
    else
      head << Bundler::URI.decode_www_form_component(x[0]).capitalize + ': ' +
        Bundler::URI.decode_www_form_component(x[1])  + "\n"
    end
  end
  "To: #{to}
ad}
dy}
end

def to_s

Constructs String from Bundler::URI. 
def to_s
  @scheme + ':' +
    if @to
      @to
    else
      ''
    end +
    if @headers.size > 0
      '?' + @headers.collect{|x| x.join('=')}.join('&')
    else
      ''
    end +
    if @fragment
      '#' + @fragment
    else
      ''
    end
end