mail-portertech 2.6.2.edge

data/lib/mail/parsers/ragel/ruby/machines/received_machine.rb.rl

@@ -0,0 +1,37 @@
+%%{
+  machine received;
+
+  include rb_actions "rb_actions.rl";
+  include common "../../common.rl";
+
+  getkey data_unpacked[p];
+
+  main := received;
+}%%
+
+module Mail
+  module Parsers
+    module Ragel
+      module ReceivedMachine
+        %%write data;
+
+        def self.parse(data)
+          p = 0
+          eof = data.length
+          stack = []
+
+          actions = []
+          data_unpacked = data.bytes.to_a
+          %%write init;
+          %%write exec;
+
+          if p == eof && cs >= %%{ write first_final; }%%
+            return actions, nil
+          else
+            return [], "Only able to parse up to #{data[0..p]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mail/parsers/ragel/ruby/parser.rb.rl.erb

@@ -0,0 +1,37 @@
+%%{
+  machine <%= parser_name %>;
+
+  include rb_actions "rb_actions.rl";
+  include common "../../common.rl";
+
+  getkey data_unpacked[p];
+
+  main := <%= parser_name %>;
+}%%
+
+module Mail
+  module Parsers
+    module Ragel
+      module <%= parser_name_cc %>
+        %%write data;
+
+        def self.parse(data)
+          p = 0
+          eof = data.length
+          stack = []
+
+          actions = []
+          data_unpacked = data.bytes.to_a
+          %%write init;
+          %%write exec;
+
+          if p == eof && cs >= %%{ write first_final; }%%
+            return actions, nil
+          else
+            return [], "Only able to parse up to #{data[0..p]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mail/parsers/received_parser.rb

@@ -0,0 +1,47 @@
+module Mail::Parsers
+  class ReceivedParser
+
+    def parse(s)
+      actions, error = Ragel.parse(:received, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ReceivedElement, s, error)
+      end
+
+      received = ReceivedStruct.new
+
+      received_tokens_s = date_s = time_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Received Tokens:
+        when :received_tokens_s then received_tokens_s = p
+        when :received_tokens_e
+          received.info = s[received_tokens_s..(p-1)]
+
+        # Date
+        when :date_s then date_s = p
+        when :date_e
+          received.date = s[date_s..(p-1)].strip
+
+        # Time
+        when :time_s then time_s = p
+        when :time_e
+          received.time = s[time_s..(p-1)]
+
+        when :angle_addr_s, :comment_e, :comment_s,
+             :domain_e, :domain_s, :local_dot_atom_e,
+             :local_dot_atom_pre_comment_e,
+             :local_dot_atom_pre_comment_s,
+             :local_dot_atom_s, :qstr_e, :qstr_s,
+             :local_quoted_string_s, :local_quoted_string_e
+          # ignored actions
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ReceivedElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      received
+    end
+  end
+end

data/lib/mail/part.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module Mail
+  class Part < Message
+    
+    # Creates a new empty Content-ID field and inserts it in the correct order
+    # into the Header.  The ContentIdField object will automatically generate
+    # a unique content ID if you try and encode it or output it to_s without
+    # specifying a content id.
+    # 
+    # It will preserve the content ID you specify if you do.
+    def add_content_id(content_id_val = '')
+      header['content-id'] = content_id_val
+    end
+    
+    # Returns true if the part has a content ID field, the field may or may
+    # not have a value, but the field exists or not.
+    def has_content_id?
+      header.has_content_id?
+    end
+    
+    def inline_content_id
+      # TODO: Deprecated in 2.2.2 - Remove in 2.3
+      STDERR.puts("Part#inline_content_id is deprecated, please call Part#cid instead")
+      cid
+    end
+    
+    def cid
+      add_content_id unless has_content_id?
+      uri_escape(unbracket(content_id))
+    end
+    
+    def url
+      "cid:#{cid}"
+    end
+    
+    def inline?
+      header[:content_disposition].disposition_type == 'inline' if header[:content_disposition]
+    end
+    
+    def add_required_fields
+      super
+      add_content_id if !has_content_id? && inline?
+    end
+
+    def add_required_message_fields
+      # Override so we don't add Date, MIME-Version, or Message-ID.
+    end
+    
+    def delivery_status_report_part?
+      (main_type =~ /message/i && sub_type =~ /delivery-status/i) && body =~ /Status:/
+    end
+    
+    def delivery_status_data
+      delivery_status_report_part? ? parse_delivery_status_report : {}
+    end
+    
+    def bounced?
+      if action.is_a?(Array)
+        !!(action.first =~ /failed/i)
+      else
+        !!(action =~ /failed/i)
+      end
+    end
+    
+    
+    # Either returns the action if the message has just a single report, or an
+    # array of all the actions, one for each report
+    def action
+      get_return_values('action')
+    end
+    
+    def final_recipient
+      get_return_values('final-recipient')
+    end
+    
+    def error_status
+      get_return_values('status')
+    end
+
+    def diagnostic_code
+      get_return_values('diagnostic-code')
+    end
+    
+    def remote_mta
+      get_return_values('remote-mta')
+    end
+    
+    def retryable?
+      !(error_status =~ /^5/)
+    end
+
+    private
+    
+    def get_return_values(key)
+      if delivery_status_data[key].is_a?(Array)
+        delivery_status_data[key].map { |a| a.value }
+      else
+        delivery_status_data[key].value
+      end
+    end
+    
+    # A part may not have a header.... so, just init a body if no header
+    def parse_message
+      header_part, body_part = raw_source.split(/#{CRLF}#{WSP}*#{CRLF}/m, 2)
+      if header_part =~ HEADER_LINE
+        self.header = header_part
+        self.body   = body_part
+      else
+        self.header = "Content-Type: text/plain\r\n"
+        self.body   = raw_source
+      end
+    end
+    
+    def parse_delivery_status_report
+      @delivery_status_data ||= Header.new(body.to_s.gsub("\r\n\r\n", "\r\n"))
+    end
+
+  end
+  
+end

data/lib/mail/parts_list.rb

@@ -0,0 +1,57 @@
+module Mail
+  class PartsList < Array
+
+    def attachments
+      Mail::AttachmentsList.new(self)
+    end
+
+    def collect
+      if block_given?
+        ary = PartsList.new
+        each { |o| ary << yield(o) }
+        ary
+      else
+        to_a
+      end
+    end
+
+    undef :map
+    alias_method :map, :collect
+
+    def map!
+      raise NoMethodError, "#map! is not defined, please call #collect and create a new PartsList"
+    end
+
+    def collect!
+      raise NoMethodError, "#collect! is not defined, please call #collect and create a new PartsList"
+    end
+
+    def sort
+      self.class.new(super)
+    end
+
+    def sort!(order)
+      # stable sort should be used to maintain the relative order as the parts are added
+      i = 0;
+      sorted = self.sort_by do |a|
+        # OK, 10000 is arbitrary... if anyone actually wants to explicitly sort 10000 parts of a
+        # single email message... please show me a use case and I'll put more work into this method,
+        # in the meantime, it works :)
+        [get_order_value(a, order), i += 1]
+      end
+      self.clear
+      sorted.each { |p| self << p }
+    end
+
+  private
+
+    def get_order_value(part, order)
+      if part.respond_to?(:content_type) && !part[:content_type].nil?
+        order.index(part[:content_type].string.downcase) || 10000
+      else
+        10000
+      end
+    end
+
+  end
+end

data/lib/mail/patterns.rb

@@ -0,0 +1,37 @@
+# encoding: us-ascii
+module Mail
+  module Patterns
+    white_space = %Q|\x9\x20|
+    text        = %Q|\x1-\x8\xB\xC\xE-\x7f|
+    field_name  = %Q|\x21-\x39\x3b-\x7e|
+    qp_safe     = %Q|\x20-\x3c\x3e-\x7e|
+    
+    aspecial     = %Q|()<>[]:;@\\,."| # RFC5322
+    tspecial     = %Q|()<>@,;:\\"/[]?=| # RFC2045
+    sp           = %Q| |
+    control      = %Q|\x00-\x1f\x7f-\xff|
+    
+    if control.respond_to?(:force_encoding)
+      control = control.force_encoding(Encoding::BINARY)
+    end
+    
+    CRLF          = /\r\n/
+    WSP           = /[#{white_space}]/
+    FWS           = /#{CRLF}#{WSP}*/
+    TEXT          = /[#{text}]/ # + obs-text
+    FIELD_NAME    = /[#{field_name}]+/
+    FIELD_PREFIX  = /\A(#{FIELD_NAME})/
+    FIELD_BODY    = /.+/m
+    FIELD_LINE    = /^[#{field_name}]+:\s*.+$/
+    FIELD_SPLIT   = /^(#{FIELD_NAME})\s*:\s*(#{FIELD_BODY})?$/
+    HEADER_LINE   = /^([#{field_name}]+:\s*.+)$/
+    HEADER_SPLIT  = /#{CRLF}(?!#{WSP})/
+
+    QP_UNSAFE     = /[^#{qp_safe}]/
+    QP_SAFE       = /[#{qp_safe}]/
+    CONTROL_CHAR  = /[#{control}]/n
+    ATOM_UNSAFE   = /[#{Regexp.quote aspecial}#{control}#{sp}]/n
+    PHRASE_UNSAFE = /[#{Regexp.quote aspecial}#{control}]/n
+    TOKEN_UNSAFE  = /[#{Regexp.quote tspecial}#{control}#{sp}]/n
+  end
+end

data/lib/mail/utilities.rb

@@ -0,0 +1,225 @@
+# encoding: utf-8
+module Mail
+  module Utilities
+    include Patterns
+
+    # Returns true if the string supplied is free from characters not allowed as an ATOM
+    def atom_safe?( str )
+      not ATOM_UNSAFE === str
+    end
+
+    # If the string supplied has ATOM unsafe characters in it, will return the string quoted
+    # in double quotes, otherwise returns the string unmodified
+    def quote_atom( str )
+      atom_safe?( str ) ? str : dquote(str)
+    end
+
+    # If the string supplied has PHRASE unsafe characters in it, will return the string quoted
+    # in double quotes, otherwise returns the string unmodified
+    def quote_phrase( str )
+      if RUBY_VERSION >= '1.9'
+        original_encoding = str.encoding
+        str.force_encoding('ASCII-8BIT')
+        if (PHRASE_UNSAFE === str)
+          quoted_str = dquote(str).force_encoding(original_encoding)
+          str.force_encoding(original_encoding)
+          quoted_str
+        else
+          str.force_encoding(original_encoding)
+        end
+      else
+        (PHRASE_UNSAFE === str) ? dquote(str) : str
+      end
+    end
+
+    # Returns true if the string supplied is free from characters not allowed as a TOKEN
+    def token_safe?( str )
+      not TOKEN_UNSAFE === str
+    end
+
+    # If the string supplied has TOKEN unsafe characters in it, will return the string quoted
+    # in double quotes, otherwise returns the string unmodified
+    def quote_token( str )
+      token_safe?( str ) ? str : dquote(str)
+    end
+
+    # Wraps supplied string in double quotes and applies \-escaping as necessary,
+    # unless it is already wrapped.
+    #
+    # Example:
+    #
+    #  string = 'This is a string'
+    #  dquote(string) #=> '"This is a string"'
+    #
+    #  string = 'This is "a string"'
+    #  dquote(string #=> '"This is \"a string\"'
+    def dquote( str )
+      '"' + unquote(str).gsub(/[\\"]/n) {|s| '\\' + s } + '"'
+    end
+
+    # Unwraps supplied string from inside double quotes and
+    # removes any \-escaping.
+    #
+    # Example:
+    #
+    #  string = '"This is a string"'
+    #  unquote(string) #=> 'This is a string'
+    #
+    #  string = '"This is \"a string\""'
+    #  unqoute(string) #=> 'This is "a string"'
+    def unquote( str )
+      if str =~ /^"(.*?)"$/
+        $1.gsub(/\\(.)/, '\1')
+      else
+        str
+      end
+    end
+
+    # Wraps a string in parenthesis and escapes any that are in the string itself.
+    #
+    # Example:
+    #
+    #  paren( 'This is a string' ) #=> '(This is a string)'
+    def paren( str )
+      RubyVer.paren( str )
+    end
+
+    # Unwraps a string from being wrapped in parenthesis
+    #
+    # Example:
+    #
+    #  str = '(This is a string)'
+    #  unparen( str ) #=> 'This is a string'
+    def unparen( str )
+      match = str.match(/^\((.*?)\)$/)
+      match ? match[1] : str
+    end
+
+    # Wraps a string in angle brackets and escapes any that are in the string itself
+    #
+    # Example:
+    #
+    #  bracket( 'This is a string' ) #=> '<This is a string>'
+    def bracket( str )
+      RubyVer.bracket( str )
+    end
+
+    # Unwraps a string from being wrapped in parenthesis
+    #
+    # Example:
+    #
+    #  str = '<This is a string>'
+    #  unbracket( str ) #=> 'This is a string'
+    def unbracket( str )
+      match = str.match(/^\<(.*?)\>$/)
+      match ? match[1] : str
+    end
+
+    # Escape parenthesies in a string
+    #
+    # Example:
+    #
+    #  str = 'This is (a) string'
+    #  escape_paren( str ) #=> 'This is \(a\) string'
+    def escape_paren( str )
+      RubyVer.escape_paren( str )
+    end
+
+    def uri_escape( str )
+      uri_parser.escape(str)
+    end
+
+    def uri_unescape( str )
+      uri_parser.unescape(str)
+    end
+
+    def uri_parser
+      @uri_parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+    end
+
+    # Matches two objects with their to_s values case insensitively
+    #
+    # Example:
+    #
+    #  obj2 = "This_is_An_object"
+    #  obj1 = :this_IS_an_object
+    #  match_to_s( obj1, obj2 ) #=> true
+    def match_to_s( obj1, obj2 )
+      obj1.to_s.casecmp(obj2.to_s) == 0
+    end
+
+    # Capitalizes a string that is joined by hyphens correctly.
+    #
+    # Example:
+    #
+    #  string = 'resent-from-field'
+    #  capitalize_field( string ) #=> 'Resent-From-Field'
+    def capitalize_field( str )
+      str.to_s.split("-").map { |v| v.capitalize }.join("-")
+    end
+
+    # Takes an underscored word and turns it into a class name
+    #
+    # Example:
+    #
+    #  constantize("hello") #=> "Hello"
+    #  constantize("hello-there") #=> "HelloThere"
+    #  constantize("hello-there-mate") #=> "HelloThereMate"
+    def constantize( str )
+      str.to_s.split(/[-_]/).map { |v| v.capitalize }.to_s
+    end
+
+    # Swaps out all underscores (_) for hyphens (-) good for stringing from symbols
+    # a field name.
+    #
+    # Example:
+    #
+    #  string = :resent_from_field
+    #  dasherize ( string ) #=> 'resent_from_field'
+    def dasherize( str )
+      str.to_s.gsub('_', '-')
+    end
+
+    # Swaps out all hyphens (-) for underscores (_) good for stringing to symbols
+    # a field name.
+    #
+    # Example:
+    #
+    #  string = :resent_from_field
+    #  underscoreize ( string ) #=> 'resent_from_field'
+    def underscoreize( str )
+      str.to_s.downcase.gsub('-', '_')
+    end
+
+    if RUBY_VERSION <= '1.8.6'
+
+      def map_lines( str, &block )
+        results = []
+        str.each_line do |line|
+          results << yield(line)
+        end
+        results
+      end
+
+      def map_with_index( enum, &block )
+        results = []
+        enum.each_with_index do |token, i|
+          results[i] = yield(token, i)
+        end
+        results
+      end
+
+    else
+
+      def map_lines( str, &block )
+        str.each_line.map(&block)
+      end
+
+      def map_with_index( enum, &block )
+        enum.each_with_index.map(&block)
+      end
+
+    end
+
+  end
+end