markbates-blabber_mouth 0.1.0.20090714164111

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009 markbates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,29 @@
+This gem provides a simple API for creating emails within a Mack application.
+
+A simple BlabberMouth model would look like this:
+
+  class WelcomeEmail
+    include BlabberMouth
+  end
+  
+To use this in your application you would do something like the following:
+ 
+  mail = WelcomeEmail.new
+  mail.to = "foo@example.com"
+  mail.from = "me@example.com"
+  mail.subject = "Hello"
+  mail.body(:plain, "This is my plain text body")
+  mail.body(:html, "This is my <b>HTML</b> body")
+  mail.attach(BlabberMouth::Attachment.new("/path/to/my/image_file.png"))
+  mail.attach(BlabberMouth::Attachment.new("/path/to/my/pdf_file.pdf"))
+  mail.deliver
+  
+This gem currently has an adapter for TMail, but it can support any mailing
+framework under the covers with the creation of a simple adapter class.
+
+Currently implemented delivery handlers are: SMTP (default), sendmail, and test.
+
+== Testing
+
+When testing you can get access to delivered emails with the delivered_notifiers
+method. After each tests these emails will be flushed our of the test handler.

data/lib/blabber_mouth.rb

@@ -0,0 +1,28 @@
+require 'configatron'
+require 'genosaurus'
+require 'validatable'
+require 'tmail'
+require 'xmpp4r'
+require 'xmpp4r-simple'
+require 'activesupport'
+
+fl = File.join(File.dirname(__FILE__), "blabber_mouth")
+
+require File.join(fl, "settings")
+require File.join(fl, "errors")
+require File.join(fl, "attachment")
+require File.join(fl, "notifier_generator", "notifier_generator")
+
+[:utils, :delivery_handlers, :adapters, :rendering].each do |dir|
+  Dir.glob(File.join(fl, dir.to_s, "**/*.rb")).each do |h|
+    require h
+  end
+end
+
+require File.join(fl, "blabber_mouth")
+
+require File.join(fl, "validations")
+
+require File.join(fl, "testing")
+
+require File.join(fl, "loader")

data/lib/blabber_mouth/adapters/base.rb

@@ -0,0 +1,30 @@
+module BlabberMouth
+  module Adapters # :nodoc:
+    # All mail adapters need to extend this class.
+    class Base
+      
+      # The origina BlabberMouth object passed in.
+      attr_accessor :bm_notifier
+      
+      def initialize(mail) # :nodoc:
+        self.bm_notifier = mail
+      end
+      
+      # The transformed (ie, converted, object)
+      def transformed(*args)
+        raise NoMethodError.new('transformed')
+      end
+      
+      # Convert the BlabberMouth object to the adapted object.
+      def convert(*args)
+        raise NoMethodError.new('convert')
+      end
+      
+      # The RAW encoded String ready for delivery via SMTP, Sendmail, etc...
+      def deliverable(*args)
+        raise NoMethodError.new('deliverable')
+      end
+      
+    end # Base
+  end # Adapters
+end # BlabberMouth

data/lib/blabber_mouth/adapters/tmail.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), "base")
+require 'base64'
+
+module BlabberMouth
+  module Adapters # :nodoc:
+    # Converts a BlabberMouth object into a TMail object.
+    class Tmail < BlabberMouth::Adapters::Base
+      
+      # Returns the underlying TMail object.
+      # Raises BlabberMouth::Errors::UnconvertedNotifier if the convert method hasn't
+      # been called first.
+      def transformed
+        raise BlabberMouth::Errors::UnconvertedNotifier.new if @tmail.nil?
+        @tmail
+      end
+      
+      # Returns the ready to be delivered encoded String
+      def deliverable
+        transformed.encoded
+      end
+      
+      # Converts the BlabberMouth object to a TMail object.
+      def convert
+        @tmail = TMail::Mail.new 
+        @tmail.to =           bm_notifier.to
+        @tmail.cc =           bm_notifier.cc
+        @tmail.bcc =          bm_notifier.bcc
+        @tmail.reply_to =     bm_notifier.reply_to
+        @tmail.from =         bm_notifier.from
+        @tmail.subject =      bm_notifier.subject
+        @tmail.date =         bm_notifier.date_sent
+        @tmail.mime_version = bm_notifier.mime_version
+
+        # set text and html bodies
+        main_body = TMail::Mail.new
+        unless bm_notifier.body(:plain).blank?
+          text = TMail::Mail.new
+          text.content_type = "text/plain"
+          text.body = bm_notifier.body(:plain)
+          main_body.parts << text
+        end
+        unless bm_notifier.body(:html).blank?
+          html = TMail::Mail.new
+          html.content_type = "text/html"
+          html.body = bm_notifier.body(:html)
+          main_body.parts << html
+        end
+
+        unless main_body.parts.empty?
+          main_body.content_type = "multipart/alternative"
+          if bm_notifier.attachments.any? # there's an attachment
+            @tmail.parts << main_body
+          else
+            if main_body.parts.size == 1
+              @tmail.body = main_body.parts.first.body
+            else
+              @tmail.parts << main_body
+            end
+          end
+        end
+
+        # set attachments, if any.
+        bm_notifier.attachments.each do |at|
+          attachment = TMail::Mail.new
+          attachment.body = Base64.encode64(at.body)
+          attachment.transfer_encoding = "Base64"
+          attachment.content_type = "application/octet-stream"
+          attachment['Content-Disposition'] = "attachment; filename=#{at.file_name}"
+          @tmail.parts << attachment
+        end
+        
+        @tmail.content_type = bm_notifier.content_type
+      end
+      
+    end # Tmail
+  end # Adapters
+end # BlabberMouth

data/lib/blabber_mouth/adapters/xmpp_msg.rb

@@ -0,0 +1,59 @@
+module BlabberMouth
+  module Adapters # :nodoc:
+    
+    class XmppMsgContainer 
+      attr_accessor :messages
+      attr_accessor :recipients
+      def initialize
+        self.messages = []
+        self.recipients = []
+      end
+      
+      def find_message_by_recipient(rcpt)
+        self.messages.find { |x| x.to.to_s == rcpt.to_s }
+      end
+      
+    end
+    
+    # All mail adapters need to extend this class.
+    class Xmpp < BlabberMouth::Adapters::Base
+      include Jabber
+      
+      # The transformed (ie, converted, object)
+      def transformed
+        raise BlabberMouth::Errors::UnconvertedNotifier.new if @xmpp_msg.nil?
+        return @xmpp_container
+      end
+      
+      # Convert the BlabberMouth object to the adapted object.
+      def convert
+        settings = configatron.blabber_mouth.xmpp_settings
+        arr = [bm_notifier.to].flatten
+        @xmpp_container = XmppMsgContainer.new
+        @xmpp_container.recipients = arr
+        
+        arr.each do |rcpt|
+          xmpp_msg = Message::new
+          xmpp_msg.set_type(:normal)
+          xmpp_msg.set_to(rcpt)
+          xmpp_msg.set_from(bm_notifier.from)
+          xmpp_msg.set_subject(bm_notifier.subject)
+          xmpp_msg.set_type(settings.message_type)
+          unless bm_notifier.body(:plain).blank?
+            xmpp_msg.set_body(bm_notifier.body(:plain))
+          end
+
+          @xmpp_container.messages << xmpp_msg
+        end
+        
+        return @xmpp_container
+      end
+      
+      # The RAW encoded String ready for delivery via SMTP, Sendmail, etc...
+      def deliverable
+        return @xmpp_container
+      end
+      
+    end # Base
+  end # Adapters
+end # BlabberMouth

data/lib/blabber_mouth/attachment.rb

@@ -0,0 +1,29 @@
+module BlabberMouth
+  # Creates an attachment for a BlabberMouth object.
+  class Attachment
+    
+    # Returns a String representing the body of the attachment. This String is NOT encoded in anyway!
+    attr_accessor :body
+    # Returns the name of the attached file.
+    attr_accessor :file_name
+    
+    def initialize(body = nil)
+      unless body.nil?
+        self.add_file(body) if body.is_a?(String)
+        self.add_io(body) if body.is_a?(IO)
+      end
+    end
+    
+    # Takes an IO object and sets the body. You'll need to explicity set the file_name afterwards.
+    def add_io(io)
+      self.body = io.read
+    end
+    
+    # Takes a path to a file, reads it in, and sets the file_name based on the path.
+    def add_file(file)
+      self.file_name = File.basename(file)
+      self.body = File.read(file)
+    end
+    
+  end # Attachment
+end # BlabberMouth

data/lib/blabber_mouth/blabber_mouth.rb

@@ -0,0 +1,181 @@
+# The heart and soul of the mack-notifier package.
+module BlabberMouth
+  
+  attr_accessor :to
+  attr_accessor :cc
+  attr_accessor :bcc
+  attr_accessor :from
+  attr_accessor :reply_to
+  attr_accessor :subject
+  attr_accessor :date_sent
+  attr_accessor :mime_version
+  attr_accessor :content_type
+  
+  # A helper method that takes a Hash and will populate the notification with the key/value pairs of that Hash.
+  # Use body_* to set a body part.
+  def build(options = {})
+    options.each do |k,v|
+      k = k.to_s
+      unless k.match(/^body_/)
+        self.send("#{k}=", v)
+      else
+        k.gsub!("body_", "")
+        self.body(k, v)
+      end
+    end
+  end
+  
+  # If called with two parameters it will set the value of the body type to the second parameter.
+  # 
+  # Example:
+  #   body(:plain, "hello") # => sets the 'plain' body to "hello"
+  # 
+  # If called with just one parameter it will return the value of that body type. If the value is nil
+  # the template for that body type will be rendered.
+  #
+  # Example:
+  #   body(:plain) # => "hello"
+  #   body(:html) # => will call the html.erb template for this notifier.
+  def body(part, value = nil)
+    part = part.to_sym
+    if value.nil?
+      body = bodies[part]
+      if body.blank?
+        bodies[part] = build_template(part)
+        return bodies[part]
+      else
+        return body
+      end
+    else
+      bodies[part] = value
+    end
+  end
+  
+  # Returns the mime_version of the notification, defaults to "1.0"
+  def mime_version
+    (@mime_version ||= "1.0")
+  end
+  
+  # This will attempt to determine the content type of the notification, unless one is already specified. 
+  def content_type
+    return @content_type unless @content_type.blank?
+    if has_attachments?
+      return "multipart/mixed"
+    elsif !body(:plain).blank? && !body(:html).blank?
+      return "multipart/alternative"
+    elsif body(:html)
+      return "text/html"
+    else
+      return "text/plain"
+    end
+  end
+  
+  # Returns the date sent, defaults to Time.now
+  def date_sent
+    (@date_sent ||= Time.now)
+  end
+  
+  # Returns the reply to address, defaults to the from address.
+  def reply_to
+    (@reply_to || self.from)
+  end
+  
+  # Adds a BlabberMouth::Attachment to the notifier.
+  # Raise ArgumentError if the parameter is not a BlabberMouth::Attachment
+  def attach(file)
+    raise ArgumentError.new unless file.is_a?(BlabberMouth::Attachment)
+    attachments << file
+  end
+  
+  # Returns true if there are attachments.
+  def has_attachments?
+    !attachments.empty?
+  end
+  
+  # Returns the attachments Array.
+  def attachments
+    @attachments ||= []
+  end
+  
+  # Delivers the notification with the configured BlabberMouth::DeliveryHandlers class.
+  # Returns false if there are any errors.
+  def deliver(handler = deliver_with)
+    begin
+      deliver!(handler)
+    rescue Exception => e
+      return false
+    end
+    return true
+  end
+  
+  # Delivers the email with the configured BlabberMouth::DeliveryHandlers class.
+  def deliver!(handler = deliver_with)
+    "BlabberMouth::DeliveryHandlers::#{handler.to_s.camelcase}".constantize.deliver(self)
+  end
+  
+  # Returns all the recipients of this notifier.
+  def recipients
+    [self.to, self.cc, self.bcc].flatten.compact
+  end
+  
+  # Returns a ready to be delivered, encoded, version of the notification.
+  def deliverable(adap = adapter)
+    adap = "BlabberMouth::Adapters::#{adap.to_s.camelcase}".constantize.new(self)
+    adap.convert
+    adap.deliverable
+  end
+  
+  # This method returns the adapter that will transform the BlabberMouth object
+  # and prepare it for delivery. This method returns the configatron.notifier.adapter
+  # parameter. Override this in your BlabberMouth class to specify a different adapter
+  # or change the configatron parameter to globally affect all your Notifiers.
+  # 
+  # Default: :tmail
+  def adapter
+    configatron.blabber_mouth.adapter
+  end
+  
+  # This method returns the delivery handler that will delivers the BlabberMouth object.
+  # This method returns the configatron.blabber_mouth.deliver_with parameter. Override this in 
+  # your BlabberMouth class to specify a different handler or change the configatron 
+  # parameter to globally affect all your Notifiers.
+  # 
+  # Default: :sendmail
+  def deliver_with
+    configatron.blabber_mouth.deliver_with
+  end
+  
+  private
+  def bodies
+    @bodies ||= {}
+  end
+  
+  def build_template(format)
+    path = File.join(configatron.blabber_mouth.paths.templates, self.class.to_s.underscore, "#{format}.erb")
+    if File.exists?(path)
+      template = ERB.new(File.read(path))
+      return template.result(Template.new(self).binder)
+    end
+    # begin
+    #   vt = BlabberMouth::Rendering::ViewTemplate.new(:notifier, self.class.to_s.underscore, {:locals => {:notifier => self}, :format => format.to_s})
+    #   return vt._compile_and_render
+    # rescue BlabberMouth::Errors::ResourceNotFound => e
+    # end
+    return nil
+  end
+  
+  class Template
+
+    attr_accessor :notifier
+
+    def initialize(notifier)
+      self.notifier = notifier
+    end
+    
+    def binder
+      binding
+    end
+    
+  end
+  
+end # BlabberMouth

data/lib/blabber_mouth/delivery_handlers/sendmail.rb

@@ -0,0 +1,19 @@
+module BlabberMouth
+  module DeliveryHandlers # :nodoc:
+    # Delivers BlabberMouth objects using sendmail.
+    module Sendmail
+      
+      def self.deliver(mail)
+        sendmail_settings = configatron.blabber_mouth.sendmail
+        sendmail_args = sendmail_settings.arguments
+        sendmail_args += " -f \"#{mail.reply_to}\"" if mail.reply_to
+        IO.popen("#{sendmail_settings.location} #{sendmail_args}","w+") do |sm|
+          sm.print(mail.deliverable.gsub(/\r/, ''))
+          sm.flush
+        end
+      end
+      
+    end # Sendmail
+    
+  end # DeliveryHandlers
+end # BlabberMouth

data/lib/blabber_mouth/delivery_handlers/smtp.rb

@@ -0,0 +1,18 @@
+require 'net/smtp'
+module BlabberMouth
+  module DeliveryHandlers # :nodoc:
+    # Delivers BlabberMouth objects using Net::SMTP.
+    module Smtp
+      
+      def self.deliver(mail)
+        smtp_settings = configatron.blabber_mouth.smtp
+        Net::SMTP.start(smtp_settings.address, smtp_settings.port, 
+                        smtp_settings.domain, smtp_settings.retrieve(:user_name, nil), 
+                        smtp_settings.retrieve(:password, nil), smtp_settings.retrieve(:authentication, nil)) do |smtp|
+          smtp.sendmail(mail.deliverable, mail.reply_to, mail.recipients)
+        end
+      end
+      
+    end # Smtp
+  end # DeliveryHandlers
+end # BlabberMouth

data/lib/blabber_mouth/delivery_handlers/test.rb

@@ -0,0 +1,15 @@
+module BlabberMouth
+  module DeliveryHandlers # :nodoc:
+    # Delivers BlabberMouth objects to an Array.
+    module Test
+      
+      def self.deliver(notifier)
+        NotifierRegistry.add(notifier)
+      end
+      
+      class NotifierRegistry < BlabberMouth::Utils::RegistryList # :nodoc:
+      end
+      
+    end # Test
+  end # DeliveryHandlers
+end # BlabberMouth

data/lib/blabber_mouth/delivery_handlers/xmpp_transport.rb

@@ -0,0 +1,76 @@
+module BlabberMouth
+  module DeliveryHandlers # :nodoc:
+    # Delivers BlabberMouth objects using XMPP (Jabber)
+    module XmppTransport
+      
+      def self.check_availability(client, recipients)
+        buddies = {}
+        recipients.each do |rcpt|
+          buddies[rcpt] = :offline
+        end
+
+        # try to get the presence update
+        sleep(1)
+        client.presence_updates do |update|
+          from = update[0].to_s
+          presence = update[1].to_s
+          if buddies.has_key?(from)
+            buddies[from] = presence
+          end
+          Mack.logger.info "#{from} --> #{presence}"
+        end
+        return buddies
+      end
+      
+      def self.deliver_message(client, xmpp_msg, wait_for_response, xmpp_errors)
+        Mack.logger.info "#{xmpp_msg.to} is online, delivering message"
+        client.deliver(xmpp_msg.to, xmpp_msg)
+        loop do
+          client.received_messages { |ret_msg| @msg_received = true if ret_msg.body == "ack" }
+          break if @msg_received or @error
+        end if wait_for_response
+        return xmpp_errors
+      end
+      
+      def self.deliver(xmpp_msg)
+        @ex ||= BlabberMouth::Errors::XmppError.new("xmpp error")
+        xmpp_settings = configatron.blabber_mouth.xmpp
+        jid_str = xmpp_settings.jid
+        jid_str += ("/" + xmpp_settings.jid_resource) if !jid_str.index("/")
+        password = xmpp_settings.password
+        client = Jabber::Simple.new(jid_str, password)
+        thr = Thread.new {
+          begin
+            xmpp_msg = xmpp_msg.deliverable
+            Timeout::timeout(20) do
+              buddies = check_availability(client, xmpp_msg.recipients)
+
+              online_buddies = buddies.keys.reject { |x| buddies[x].to_sym == :offline }
+              offline_buddies = buddies.keys.reject { |x| buddies[x].to_sym == :online }
+
+              if !offline_buddies.empty?
+                # there are offline buddies, log the errors
+                offline_buddies.each do |buddy|
+                  err = BlabberMouth::Errors::XmppUserNotOnline.new(buddy)
+                  @ex.add_error(:offline, err)
+                end
+              end
+              
+              online_buddies.each do |buddy|
+                deliver_message(client, xmpp_msg.find_message_by_recipient(buddy), xmpp_settings.wait_for_response, @ex)
+              end
+              
+              raise @ex if !@ex.empty?
+            end # timeout
+          rescue Timeout::Error => ex
+            @error = ex
+          rescue Exception => ex
+          end
+        }
+        
+        thr.join
+        raise @ex if !@ex.empty?
+      end
+    end # XmppTransport
+  end # DeliveryHandlers
+end # BlabberMouth

data/lib/blabber_mouth/errors.rb

@@ -0,0 +1,55 @@
+module BlabberMouth
+  module Errors # :nodoc:
+  
+    class UnconvertedNotifier < StandardError
+      def initialize # :nodoc:
+        super("You must convert the BlabberMouth object first!")
+      end
+    end # UnconvertedNotifier
+  
+    class XmppError < StandardError
+      def initialize(msg)
+        super(msg)
+        self.error_hash = {}
+      end
+    
+      def add_error(type, msg)
+        self.error_hash[type] ||= []
+        self.error_hash[type] << msg
+      end
+    
+      def get_error(type)
+        self.error_hash[type]
+      end
+    
+      def empty?
+        self.error_hash.empty?
+      end
+    
+      attr_accessor :error_hash
+    end
+  
+    class XmppAuthenticationError < StandardError
+      def initialize(user)
+        super("Cannot authenticate: #{user} to xmpp server")
+      end
+    end
+  
+    class XmppUserNotOnline < StandardError
+      def initialize(user)
+        super("user #{user} is not online")
+      end
+    end
+  
+    class XmppSendError < StandardError
+      attr_reader :code
+      attr_reader :msg
+    
+      def initialize(code, msg)
+        super("Cannot send message. Code=#{code}, Msg=#{msg}")
+        @code = code
+        @msg = msg
+      end
+    end
+  end # Errors
+end # BlabberMouth

data/lib/blabber_mouth/loader.rb

@@ -0,0 +1,8 @@
+# If the notifiers directory does not exist, create it.
+path = configatron.blabber_mouth.paths.models
+FileUtils.mkdir_p(path)
+
+# Require all notifiers
+Dir.glob(File.join(path, "**/*.rb")).each do |notifier|
+  require File.expand_path(notifier)
+end

data/lib/blabber_mouth/notifier_generator/manifest.yml

@@ -0,0 +1,12 @@
+notifier_template:
+  type: file
+  template_path: <%= File.join(templates_directory_path, "app", "notifiers", "notifier.rb.template") %>
+  output_path: <%= File.join(configatron.blabber_mouth.paths.models, "#{file_name}.rb") %>
+text_template:
+  type: file
+  template_path: <%= File.join(templates_directory_path, "app", "notifiers", "plain.erb.template") %>
+  output_path: <%= File.join(configatron.blabber_mouth.paths.templates, file_name, "plain.erb") %>
+html_template:
+  type: file
+  template_path: <%= File.join(templates_directory_path, "app", "notifiers", "html.erb.template") %>
+  output_path: <%= File.join(configatron.blabber_mouth.paths.templates, file_name, "html.erb") %>

data/lib/blabber_mouth/notifier_generator/notifier_generator.rb

@@ -0,0 +1,23 @@
+# Generates the necessary files for a basic notifier.
+# 
+# Example:
+#   rake generate:notifier name=welcome_email
+# generates the following files:
+#   app/notifiers/welcome_email.rb
+#   app/notifiers/templates/welcome_email/text.erb
+#   app/notifiers/templates/welcome_email/html.erb
+#   test/unit/welcome_email_spec.rb # => if using RSpec
+#   test/unit/welcome_email_test.rb # => if using Test::Unit::TestCase
+class NotifierGenerator < Genosaurus
+  
+  require_param :name
+  
+  def file_name # :nodoc:
+    param(:name).underscore.downcase
+  end
+  
+  def class_name # :nodoc:
+    param(:name).camelcase
+  end
+  
+end

data/lib/blabber_mouth/notifier_generator/templates/app/notifiers/html.erb.template

@@ -0,0 +1,2 @@
+<!-- Use this file to create your HTML version of your email.
+Access to your BlabberMouth class is available via the notifier method. -->

data/lib/blabber_mouth/notifier_generator/templates/app/notifiers/notifier.rb.template

@@ -0,0 +1,3 @@
+class <%= class_name %>
+  include BlabberMouth
+end

data/lib/blabber_mouth/notifier_generator/templates/app/notifiers/plain.erb.template

@@ -0,0 +1,2 @@
+# Use this file to create your plain text version of your email.
+# Access to your BlabberMouth class is available via the notifier method.

data/lib/blabber_mouth/rendering/type/mailer.rb

@@ -0,0 +1,14 @@
+# module Rendering # :nodoc:
+#   module Type # :nodoc:
+#     class Notifier < BlabberMouth::Rendering::Type::FileBase # :nodoc:
+#       
+#       def render
+#         x_file = BlabberMouth::Paths.notifier_templates(self._render_value, self._options[:format])
+#         render_file(x_file)
+#       end
+#       
+#     end # BlabberMouth
+#   end # Type
+# end # Rendering
+# 
+# BlabberMouth::Rendering::Engine::Registry.instance.register(:notifier, :erb)

data/lib/blabber_mouth/settings.rb

@@ -0,0 +1,28 @@
+if defined?(RAILS_ENV)
+  configatron.blabber_mouth.set_default(:env, RAILS_ENV)
+  configatron.blabber_mouth.paths.set_default(:models, File.join(RAILS_ROOT, 'app', 'notifiers'))
+  configatron.blabber_mouth.paths.set_default(:templates, File.join(RAILS_ROOT, 'app', 'notifiers', 'templates'))
+else
+  configatron.blabber_mouth.set_default(:env, 'development')
+  configatron.blabber_mouth.paths.set_default(:models, File.join(FileUtils.pwd, 'app', 'notifiers'))
+  configatron.blabber_mouth.paths.set_default(:templates, File.join(FileUtils.pwd, 'app', 'notifiers', 'templates'))
+end
+
+configatron.blabber_mouth.paths.set_default(:templates, File.join(configatron.blabber_mouth.paths.models, 'templates'))
+
+configatron.blabber_mouth.sendmail.set_default(:location, '/usr/sbin/sendmail')
+configatron.blabber_mouth.sendmail.set_default(:arguments, '-i -t')
+configatron.blabber_mouth.smtp.set_default(:address, 'localhost')
+configatron.blabber_mouth.smtp.set_default(:port, 25)
+configatron.blabber_mouth.smtp.set_default(:domain, 'localhost.localdomain')
+configatron.blabber_mouth.set_default(:deliver_with, (configatron.blabber_mouth.env == "test" ? "test" : "smtp"))
+configatron.blabber_mouth.set_default(:adapter, 'tmail')
+
+# xmpp settings
+configatron.blabber_mouth.xmpp.set_default(:jid, 'h_test@jabber80.com')
+configatron.blabber_mouth.xmpp.set_default(:jid_resource, 'work')
+configatron.blabber_mouth.xmpp.set_default(:password, 'test1234')
+configatron.blabber_mouth.xmpp.set_default(:message_type, :chat)
+configatron.blabber_mouth.xmpp.set_default(:wait_for_response, true)
+configatron.blabber_mouth.xmpp.set_default(:response_wait_time, 20)
+configatron.blabber_mouth.xmpp.set_default(:response_message, "ack")

data/lib/blabber_mouth/testing.rb

@@ -0,0 +1,47 @@
+if configatron.blabber_mouth.env == "test"
+  
+  # Used for testing this method will return any emails that have been 'sent' using BlabberMouth::DeliveryHandlers::Test.
+  # These emails will get 'flushed' after each test.
+  def delivered_notifiers
+    BlabberMouth::DeliveryHandlers::Test::NotifierRegistry.registered_items
+  end
+  
+  if defined?(Spec)
+
+    Spec::Runner.configure do |config|
+
+      config.before(:each) do
+        BlabberMouth::DeliveryHandlers::Test::NotifierRegistry.reset!
+      end
+
+      config.after(:each) do
+        BlabberMouth::DeliveryHandlers::Test::NotifierRegistry.reset!
+      end
+
+    end
+    
+  else
+  
+    module Test # :nodoc:
+      module Unit # :nodoc:
+        class TestCase # :nodoc:
+
+          # Let's alias the run method in the class above us so we can create a new one here
+          # but still reference it.
+          alias_instance_method :run, :super_run
+
+          # We need to wrap the run method so we can do things like
+          # run a cleanup method if it exists
+          def run(result, &progress_block) # :nodoc:
+            @__res = super_run(result)
+            BlabberMouth::DeliveryHandlers::Test::NotifierRegistry.reset!
+            @__res
+          end
+
+        end # TestCase
+      end # Unit
+    end # Test
+    
+  end
+  
+end

data/lib/blabber_mouth/utils/registry_list.rb

@@ -0,0 +1,82 @@
+require 'singleton'
+module BlabberMouth
+  module Utils
+    # This is a general purpose Singleton Registry class.
+    # It takes the drudgery out of creating registry classes, that
+    # are, let's face it, all pretty much the same.
+    class RegistryList
+      include Singleton
+      
+      # The list of registered items
+      attr_reader :registered_items
+      
+      def initialize # :nodoc:
+        reset!
+      end
+      
+      # Override this method to set the initial state of the registered_items Array.
+      # By default this list is empty.
+      def initial_state
+        []
+      end
+      
+      # Resets the registered_items list to the list specified by the initial_state method.
+      def reset!
+        @registered_items = self.initial_state.dup
+      end
+      
+      # Adds an object to the list at a specified position. By default the position is last.
+      def add(klass, position = self.registered_items.size)
+        self.registered_items.insert(position, klass)
+        self.registered_items.uniq!
+        self.registered_items.compact!
+      end
+      
+      # Removes an object from the list.
+      def remove(klass)
+        self.registered_items.delete(klass)
+      end
+      
+      class << self
+        
+        # Returns the list of registered items.
+        def registered_items
+          self.instance.registered_items
+        end
+        
+        # Emptys out the list of registered_items.
+        def clear!
+          registered_items.clear
+        end
+        
+        # Resets the registered_items list to the list specified by the initial_state method.
+        def reset!
+          self.instance.reset!
+        end
+        
+        # Adds an object to the list at a specified position. By default the position is last.
+        def add(klass, position = registered_items.size)
+          self.instance.add(klass, position)
+        end
+        
+        # Removes an object from the list.
+        def remove(klass)
+          self.instance.remove(klass)
+        end
+        
+        # Moves an object to the top of the registered_items list.
+        def move_to_top(klass)
+          self.instance.add(klass, 0)
+        end
+        
+        # Moves an object to the bottom of the registered_items list.
+        def move_to_bottom(klass)
+          remove(klass)
+          self.instance.add(klass)
+        end
+        
+      end
+      
+    end # RegistryList
+  end # Utils
+end # BlabberMouth

data/lib/blabber_mouth/validations.rb

@@ -0,0 +1,97 @@
+module BlabberMouth
+  # Includes the validatable gem into your Notifier.
+  # http://validatable.rubyforge.org
+  module Validatable
+
+    def self.included(base)
+      base.instance_eval do
+        include ::Validatable
+        alias_method "unvalidated_deliver!", "deliver!"
+      end
+      
+      base.class_eval do
+        
+        class << self
+          
+          # Adds common validations to your BlabberMouth class.
+          # These include:
+          #   validates_presence_of :to
+          #   validates_presence_of :from
+          #   validates_presence_of :subject
+          #   validates_email_format_of :to
+          #   validates_email_format_of :from
+          def common_notifier_validations
+            validates_presence_of :to
+            validates_presence_of :from
+            validates_presence_of :subject
+            validates_email_format_of :to
+            validates_email_format_of :from
+          end
+          
+          # Validates the email format of the column specified against the email_validation_regex method.
+          # This will drill into arrays as well, if that's what your column is.
+          def validates_email_format_of(column, options = {})
+            options = {:logic => lambda{
+              [send(column)].flatten.each_with_index do |addr, i|
+                errors.add(column, "[#{addr}] is not valid") unless addr.to_s.downcase.match(self.class.email_validation_regex)
+              end
+            }}.merge(options)
+            validates_each :to, options
+          end
+          
+          def email_validation_regex
+            regex = <<-EOF
+            [a-z0-9!#$\%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$\%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
+            EOF
+            /#{regex.strip}/
+          end
+          
+        end # class << self
+      end # class_eval
+    end # included
+    
+    # Raises a RuntimeError if the email you are trying to deliver is not valid.
+    def deliver!(handler = deliver_with)
+      raise 'Notification is Invalid!' unless self.valid?
+      unvalidated_deliver!(handler)
+    end
+    
+    # Returns false if the email is not valid.
+    # If the email is valid and an exception is raised when trying to deliver it
+    # false is returned and the exception is added to the errors array, with the
+    # key :deliver.
+    def deliver(handler = deliver_with)
+      return false unless self.valid?
+      begin
+        "BlabberMouth::DeliveryHandlers::#{handler.to_s.camelcase}".constantize.deliver(self)
+      rescue Exception => e
+        self.errors.add(:deliver, e.message)
+        return false
+      end
+      return true
+    end
+    
+    def errors_for(name)
+      self.errors.on(name.to_sym)
+    end
+    
+  end # Validatable
+end # BlabberMouth
+
+module Validatable # :nodoc:
+  class ValidationBase #:nodoc:
+    
+    # This fixes a bug with reloading of Validatable classes.
+    def raise_error_if_key_is_dup(klass) # :nodoc:
+      vals = {}
+      klass.validations.each do |v|
+        vals[v.key] = v
+      end
+      klass.validations.clear
+      vals.each do |k,v|
+        klass.validations << v
+      end
+    end # raise_error_if_key_is_dup
+    
+  end # ValidationBase
+end # Validatable

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: markbates-blabber_mouth
+version: !ruby/object:Gem::Version 
+  version: 0.1.0.20090714164111
+platform: ruby
+authors: 
+- markbates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tmail
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: validatable
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.6.7
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r-simple
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.8
+    version: 
+description: "blabber_mouth was developed by: markbates"
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- lib/blabber_mouth/adapters/base.rb
+- lib/blabber_mouth/adapters/tmail.rb
+- lib/blabber_mouth/adapters/xmpp_msg.rb
+- lib/blabber_mouth/attachment.rb
+- lib/blabber_mouth/blabber_mouth.rb
+- lib/blabber_mouth/delivery_handlers/sendmail.rb
+- lib/blabber_mouth/delivery_handlers/smtp.rb
+- lib/blabber_mouth/delivery_handlers/test.rb
+- lib/blabber_mouth/delivery_handlers/xmpp_transport.rb
+- lib/blabber_mouth/errors.rb
+- lib/blabber_mouth/loader.rb
+- lib/blabber_mouth/notifier_generator/manifest.yml
+- lib/blabber_mouth/notifier_generator/notifier_generator.rb
+- lib/blabber_mouth/notifier_generator/templates/app/notifiers/html.erb.template
+- lib/blabber_mouth/notifier_generator/templates/app/notifiers/notifier.rb.template
+- lib/blabber_mouth/notifier_generator/templates/app/notifiers/plain.erb.template
+- lib/blabber_mouth/rendering/type/mailer.rb
+- lib/blabber_mouth/settings.rb
+- lib/blabber_mouth/testing.rb
+- lib/blabber_mouth/utils/registry_list.rb
+- lib/blabber_mouth/validations.rb
+- lib/blabber_mouth.rb
+- README
+- LICENSE
+has_rdoc: false
+homepage: ""
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: magrathea
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: blabber_mouth
+test_files: []
+