kbaum-mail 2.1.2.1

data/lib/mail/fields/common/address_container.rb

@@ -0,0 +1,16 @@
+module Mail
+  
+  class AddressContainer < Array
+    
+    def initialize(field, list = [])
+      @field = field
+      super(list)
+    end
+
+    def << (address)
+      @field << address
+    end
+
+  end
+  
+end

data/lib/mail/fields/common/common_address.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+module Mail
+  module CommonAddress # :nodoc:
+    
+    module ClassMethods # :nodoc:
+      
+    end
+  
+    module InstanceMethods # :doc:
+      
+      def parse(val = value)
+        unless val.blank?
+          @tree = AddressList.new(val)
+        else
+          nil
+        end
+      end
+      
+      # Allows you to iterate through each address object in the syntax tree
+      def each
+        tree.addresses.each do |address|
+          yield(address)
+        end
+      end
+
+      # Returns the address string of all the addresses in the address list
+      def addresses
+        list = tree.addresses.map { |a| a.address }
+        Mail::AddressContainer.new(self, list)
+      end
+
+      # Returns the formatted string of all the addresses in the address list
+      def formatted
+        list = tree.addresses.map { |a| a.format }
+        Mail::AddressContainer.new(self, list)
+      end
+      
+      # Returns the display name of all the addresses in the address list
+      def display_names
+        list = tree.addresses.map { |a| a.display_name }
+        Mail::AddressContainer.new(self, list)
+      end
+      
+      # Returns the actual address objects in the address list
+      def addrs
+        list = tree.addresses
+        Mail::AddressContainer.new(self, list)
+      end
+      
+      # Returns a hash of group name => address strings for the address list
+      def groups
+        @groups = Hash.new
+        tree.group_recipients.each do |group|
+          @groups[group.group_name.text_value] = get_group_addresses(group.group_list)
+        end
+        @groups
+      end
+      
+      # Returns the addresses that are part of groups
+      def group_addresses
+        groups.map { |k,v| v.map { |a| a.format } }.flatten
+      end
+
+      # Returns the name of all the groups in a string
+      def group_names # :nodoc:
+        tree.group_names
+      end
+      
+      def default
+        addresses
+      end
+
+      def <<(val)
+        case
+        when val.nil?
+          raise ArgumentError, "Need to pass an address to <<"
+        when val.blank?
+          parse(encoded)
+        else
+          parse((formatted + [val]).join(", "))
+        end
+      end
+      
+      private
+      
+      def do_encode(field_name)
+        return '' if value.blank?
+        address_array = tree.addresses.reject { |a| group_addresses.include?(a.encoded) }.compact.map { |a| a.encoded }
+        address_text  = address_array.join(", \r\n\t")
+        group_array = groups.map { |k,v| "#{k}: #{v.map { |a| a.encoded }.join(", \r\n\t")};" }
+        group_text  = group_array.join(" \r\n\t")
+        return_array = [address_text, group_text].reject { |a| a.blank? }
+        "#{field_name}: #{return_array.join(", \r\n\t")}\r\n"
+      end
+
+      def do_decode
+        return nil if value.blank?
+        address_array = tree.addresses.reject { |a| group_addresses.include?(a.decoded) }.map { |a| a.decoded }
+        address_text  = address_array.join(", ")
+        group_array = groups.map { |k,v| "#{k}: #{v.map { |a| a.decoded }.join(", ")};" }
+        group_text  = group_array.join(" ")
+        return_array = [address_text, group_text].reject { |a| a.blank? }
+        return_array.join(", ")
+      end
+
+      # Returns the syntax tree of the Addresses
+      def tree # :nodoc:
+        @tree ||= AddressList.new(value)
+      end
+      
+      def get_group_addresses(group_list)
+        if group_list.respond_to?(:addresses)
+          group_list.addresses.map do |address_tree|
+            Mail::Address.new(address_tree)
+          end
+        else
+          []
+        end
+      end
+
+    end
+    
+    def self.included(receiver) # :nodoc:
+      receiver.send :include, InstanceMethods
+    end
+    
+  end
+end

data/lib/mail/fields/common/common_date.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Mail
+  module CommonDate # :nodoc:
+    
+    module InstanceMethods # :doc:
+      
+      # Returns a date time object of the parsed date
+      def date_time
+        ::DateTime.parse("#{element.date_string} #{element.time_string}")
+      end
+
+      def default
+        date_time
+      end
+      
+      def parse(val = value)
+        unless val.blank?
+          @element = Mail::DateTimeElement.new(val)
+          @tree = @element.tree
+        else
+          nil
+        end
+      end
+
+      private
+      
+      def do_encode(field_name)
+        "#{field_name}: #{value}\r\n"
+      end
+      
+      def do_decode
+        "#{value}"
+      end
+
+      def element
+        @element ||= Mail::DateTimeElement.new(value)
+      end
+      
+      # Returns the syntax tree of the Date
+      def tree
+        @tree ||= element.tree
+      end
+      
+    end
+    
+    def self.included(receiver) # :nodoc:
+      receiver.send :include, InstanceMethods
+    end
+    
+  end
+end

data/lib/mail/fields/common/common_field.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module Mail
+  module CommonField # :nodoc:
+    
+    module ClassMethods # :nodoc:
+      
+    end
+    
+    module InstanceMethods # :doc:
+      
+      def name=(value)
+        @name = value
+      end
+      
+      def name
+        @name
+      end
+      
+      def value=(value)
+        @length = nil
+        @tree = nil
+        @element = nil
+        @value = value
+      end
+      
+      def value
+        @value
+      end
+      
+      def to_s
+        decoded
+      end
+      
+      def default
+        decoded
+      end
+      
+      def field_length
+        @length ||= name.length + value.length + ': '.length
+      end
+      
+      def responsible_for?( val )
+        name.to_s.downcase == val.to_s.downcase
+      end
+
+      private
+
+      def strip_field(field_name, string)
+        if string.is_a?(Array)
+          string.join(', ')
+        else
+          string.to_s.gsub(/#{field_name}:\s+/i, '')
+        end
+      end
+
+    end
+    
+    def self.included(receiver) # :nodoc:
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+    
+  end
+end

data/lib/mail/fields/common/common_message_id.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Mail
+  module CommonMessageId # :nodoc:
+    
+    module ClassMethods # :nodoc:
+      
+    end
+    
+    module InstanceMethods # :doc:
+
+      def element
+        @element ||= Mail::MessageIdsElement.new(value)
+      end
+      
+      def parse(val = value)
+        unless val.blank?
+          @element = Mail::MessageIdsElement.new(val)
+        else
+          nil
+        end
+      end
+      
+      def message_id
+        element.message_id
+      end
+      
+      def message_ids
+        element.message_ids
+      end
+      
+      def default
+        if message_ids.length == 1
+          message_ids[0]
+        else
+          message_ids
+        end
+      end
+
+      private
+      
+      def do_encode(field_name)
+        %Q{#{field_name}: #{message_ids.map { |m| "<#{m}>" }.join(', ')}\r\n}
+      end
+      
+      def do_decode
+        "#{message_ids.map { |m| "<#{m}>" }.join(', ')}"
+      end
+      
+    end
+    
+    def self.included(receiver) # :nodoc:
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+    
+  end
+end

data/lib/mail/fields/common/parameter_hash.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mail
+
+  # ParameterHash is an intelligent Hash that allows you to add
+  # parameter values including the mime extension paramaters that
+  # have the name*0="blah", name*1="bleh" keys, and will just return
+  # a single key called name="blahbleh" and do any required un-encoding
+  # to make that happen
+  class ParameterHash < HashWithIndifferentAccess
+
+    def [](key_name)
+      pairs = select { |k,v| k =~ /^#{key_name}\*/ }
+      pairs = pairs.to_a if RUBY_VERSION >= '1.9'
+      if pairs.empty? # Just dealing with a single value pair
+        super(key_name)
+      else # Dealing with a multiple value pair or a single encoded value pair
+        string = pairs.sort { |a,b| a.first <=> b.first }.map { |v| v.last }.join('')
+        if mt = string.match(/([\w\d\-]+)'(\w\w)'(.*)/)
+          string = mt[3]
+          encoding = mt[1]
+        else
+          encoding = nil
+        end
+        Mail::Encodings.param_decode(string, encoding)
+      end
+    end
+
+    def encoded
+      map.sort { |a,b| a.first <=> b.first }.map do |key_name, value|
+        unless value.ascii_only?
+          value = Mail::Encodings.param_encode(value)
+          key_name = "#{key_name}*"
+        end
+        %Q{#{key_name}="#{value}"}
+      end.join(";\r\n\t")
+    end
+
+  end
+end

data/lib/mail/fields/content_description_field.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# 
+# 
+# 
+module Mail
+  class ContentDescriptionField < UnstructuredField
+    
+    FIELD_NAME = 'content-description'
+    CAPITALIZED_FIELD = 'Content-Description'
+    
+    def initialize(*args)
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      self.parse
+      self
+
+    end
+    
+  end
+end

data/lib/mail/fields/content_disposition_field.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+# 
+# 
+# 
+module Mail
+  class ContentDispositionField < StructuredField
+    
+    FIELD_NAME = 'content-disposition'
+    CAPITALIZED_FIELD = 'Content-Disposition'
+    
+    def initialize(*args)
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      self.parse
+      self
+
+    end
+    
+    def parse(val = value)
+      unless val.blank?
+        @element = Mail::ContentDispositionElement.new(val)
+      end
+    end
+    
+    def element
+      @element ||= Mail::ContentDispositionElement.new(value)
+    end
+
+    def disposition_type
+      element.disposition_type
+    end
+    
+    def parameters
+      @parameters = ParameterHash.new
+      element.parameters.each { |p| @parameters.merge!(p) }
+      @parameters
+    end
+
+    def filename
+      case
+      when !parameters['filename'].blank?
+        @filename = parameters['filename']
+      when !parameters['name'].blank?
+        @filename = parameters['name']
+      else 
+        @filename = nil
+      end
+      @filename
+    end
+
+    # TODO: Fix this up
+    def encoded
+      "#{CAPITALIZED_FIELD}: #{value}\r\n"
+    end
+    
+    def decoded
+      value
+    end
+
+  end
+end

data/lib/mail/fields/content_id_field.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+# 
+# 
+# 
+module Mail
+  class ContentIdField < StructuredField
+    
+    FIELD_NAME = 'content-id'
+    CAPITALIZED_FIELD = "Content-ID"
+    
+    def initialize(*args)
+      @uniq = 1
+      if args.last.blank?
+        self.name = CAPITALIZED_FIELD
+        self.value = generate_content_id
+      else
+        super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      end
+      self.parse
+      self
+
+    end
+    
+    def parse(val = value)
+      unless val.blank?
+        @element = Mail::MessageIdsElement.new(val)
+      end
+    end
+    
+    def element
+      @element ||= Mail::MessageIdsElement.new(value)
+    end
+    
+    def name
+      'Content-ID'
+    end
+    
+    def content_id
+      element.message_id
+    end
+    
+    def to_s
+      "<#{content_id}>"
+    end
+    
+    # TODO: Fix this up
+    def encoded
+      "#{CAPITALIZED_FIELD}: #{to_s}\r\n"
+    end
+    
+    def decoded
+      "#{to_s}"
+    end
+    
+    private
+    
+    def generate_content_id
+      fqdn = ::Socket.gethostname
+      "<#{Mail.random_tag}@#{fqdn}.mail>"
+    end
+    
+  end
+end