mandrill_queue 0.1.1

data/lib/mandrill_queue/message/attachments.rb

@@ -0,0 +1,168 @@
+require 'base64'
+require 'mime/types'
+
+module MandrillQueue
+	module Message
+		class Attachments
+			class Attachment
+				ACCESSORS = [:file, :name, :content, :type]
+
+				def initialize(file = nil, options = {}, &block)
+					@options = options
+					@file = file
+
+					if file.is_a?(Hash)
+						@options = file
+						@file = nil
+					end
+
+					load_file if @options[:load_file] && !@file.nil?
+
+					instance_eval(&block) if block_given?
+				end
+
+				def file(*args)
+					if args.count > 0
+						reset!
+						@file = args.first
+					end
+					@file
+				end
+
+				def reset!
+					@file = nil
+					@type = nil
+					@content = nil
+					@name = nil
+				end
+
+				def file_loaded?
+					!@content.nil?
+				end
+
+				def name(*args)
+					@name = args.first if args.count > 0
+
+					@name ||= (File.basename(@file) unless @file.nil?)
+				end
+
+				def type(*args)
+					@type = args.first if args.count > 0
+
+					@type ||= begin
+						unless @file.nil?
+							MIME::Types.type_for(@file).first.to_s
+						end || "application/octet-stream"
+					end
+				end
+
+				def content(*args)
+					if args.count > 0
+						@content = Base64.encode64(args.first)
+					end
+					@content
+				end
+
+				def content64(*args)
+					@content = args.first if args.count > 0
+					@content
+				end
+
+				def load_file
+					return false if file_loaded?
+
+					content(IO.read(@file))
+					# set @name and @type if not already set before getting rid of file
+					name()
+					type()
+					@file = nil
+					self
+				end
+
+				def validate(errors, options = {})
+					options[:as] ||= :attachments
+					errors.push([options[:as], "No file or content for attachment '#{name}'."]) if content64.nil? && file.nil?
+					errors.push([options[:as], "No attachment name given."]) if name.nil?
+					errors.push([options[:as], "File to load (#{file}) does not exist."]) if @file && !file_loaded? && !File.exist?(file)
+				end
+
+				def set!(hash)
+					ACCESSORS.each do |key|
+						instance_variable_set("@#{key}", hash[key])
+					end
+
+					self
+				end
+
+				def to_hash(options = {})
+					hash = {}
+
+					ACCESSORS.each do |key|
+						value = send(key)
+						hash[key] = value if options[:include_nils] || !value.nil?
+					end
+
+					hash
+				end
+
+				alias_method :dsl, :instance_eval
+			end
+
+			module DSL
+				def attachments(&block)
+					@_attachments ||= Attachments.new
+					@_attachments.dsl(&block) if block_given?
+					block_given? ? self : @_attachments
+				end
+			end
+
+			def initialize
+				@_attachments = []
+			end
+
+			def add(*args, &block)
+				@_attachments << attachment_class.new(*args, &block)
+			end
+
+			def attachment_class
+				@_klass ||= Attachment
+			end
+
+			def count
+				@_attachments.count
+			end
+
+			def load_all
+				@_attachments.each(&:load_file)
+			end
+
+			def to_a(options = {})
+				@_attachments.map do |a|
+					a.to_hash(options)
+				end
+			end
+
+			def set!(list)
+				@_attachments = list.map do |obj|
+					attachment_class.new.set!(obj.symbolize_keys)
+				end
+
+				self
+			end
+
+			def attachments
+				@_attachments
+			end
+
+			def validate(errors, options = {})
+				@_attachments.each do |a|
+					a.validate(errors, options)
+				end
+			end
+
+			alias_method :dsl, :instance_eval
+
+			Variables::DSL.include_as(self, :vars)
+		end
+	end
+end

data/lib/mandrill_queue/message/images.rb

@@ -0,0 +1,37 @@
+require 'mime/types'
+require 'mandrill_queue/message/attachments'
+
+module MandrillQueue
+	module Message
+		class Images < Attachments
+			class Image < Attachments::Attachment
+				def image_type?
+					MIME::Types[/^image/].any? { |m| m == type }
+				end
+
+				def validate(errors, options = {})
+					options[:as] ||= :images
+					super(errors, options)
+
+					unless image_type?
+						errors.push([options[:as], "Invalid image mime type."])
+					end
+				end
+			end
+
+			module DSL
+				def images(&block)
+					@_images ||= Attachments.new
+					@_images.dsl(&block) if block_given?
+					block_given? ? self : @_images
+				end
+			end
+
+			# Override default attachment class
+			def attachment_class
+				Image
+			end
+		end
+	end
+end
+

data/lib/mandrill_queue/message/merge_vars.rb

@@ -0,0 +1,24 @@
+require 'mandrill_queue/variables'
+require 'mandrill_queue/message/recipient/data'
+require 'mandrill_queue/message/recipient/variable'
+
+module MandrillQueue
+	module Message
+		class MergeVars < Recipient::Data
+
+			class Var < Recipient::Variable
+				variables :vars
+			end
+
+			var_class Var
+
+			module DSL
+				def merge_vars(*args, &block)
+					@_merge_vars ||= MergeVars.new
+					@_merge_vars.dsl(*args, &block) if args.count > 0 || block_given?
+					block_given? ? self : @_merge_vars
+				end
+			end
+		end
+	end
+end

data/lib/mandrill_queue/message/recipient/data.rb

@@ -0,0 +1,149 @@
+require 'mandrill_queue/errors'
+require 'mandrill_queue/variables'
+require 'mandrill_queue/message/recipient/helpers'
+
+module MandrillQueue
+	module Message
+		module Recipient
+			class Data
+
+				def self.inherited(base)
+					base.class_eval do
+						define_method(base.name.underscore.split('/').last) do
+							@_vars
+						end
+					end
+				end
+
+				def self.var_class(klass = nil)
+					@_var_class = klass unless klass.nil?
+					@_var_class
+				end
+
+				def register_recipient(email, index)
+					raise RecipientDataError, "#{email} has already been registered in recipient index." if recipient_index.has_key?(email)
+					recipient_index[email] = index
+				end
+
+				def recipient_index
+					@_rcpt_index || clear_recipient_index
+				end
+
+				def clear_recipient_index
+					@_rcpt_index = {}
+				end
+
+				def initialize
+					@_vars = []
+				end
+
+				def var_class
+					self.class.var_class
+				end
+
+				def add(*args, &block)
+					recipient = args.first
+					if recipient.is_a?(String)
+						ind = recipient_index[recipient]
+						if ind.nil?
+							@_vars << var_class.new(*args, &block)
+							register_recipient(recipient, @_vars.count - 1)
+						else
+							self[ind].variables.dsl(&block)
+						end
+					elsif recipient.respond_to?(:each)
+						add_objects(*args, &block)
+					elsif !recipient.nil?
+						raise MessageError, "Invalid recipient for #{name}"
+					end
+				end
+
+				alias_method :dsl, :add
+
+				def to_a(options = {})
+					@_vars.map do |v|
+						v.to_hash(options)
+					end
+				end
+
+				def first
+					@_vars.first
+				end
+
+				def last
+					@_vars.last
+				end
+
+				def [](index)
+					@_vars[index]
+				end
+
+				def count
+					@_vars.count
+				end
+
+				def validate(errors)
+					@_vars.each do |v|
+						v.validate(errors)
+					end
+				end
+
+				def set!(list)
+					@_vars = list.map do |obj|
+						var_class.new.set!(obj.symbolize_keys)
+					end
+
+					self
+				end
+
+			protected
+
+				def add_objects(list, recipient_field = :email, fields = nil, &block)
+					if recipient_field.is_a?(Array)
+						fields, recipient_field = recipient_field, :email
+					end
+
+					if block_given?
+						# if a block is given we want to hand the array over
+						# to the block for mapping
+						list.each do |obj|
+							recipient = obj.send(recipient_field)
+							ind = recipient_index[recipient]
+							if ind.nil?
+								var = var_class.new
+								var.recipient = recipient
+								var.variables.dsl(obj, &block)
+								@_vars << var
+								register_recipient(recipient, @_vars.count - 1)
+							else
+								self[ind].variables.dsl(obj, &block)
+							end
+						end
+					else
+						# Include recipient in final var hash if fields not specified
+						# or if explicitly added in fields.
+						includes_recipient = fields.nil? || fields.include?(recipient_field)
+
+						fields << recipient_field unless fields.nil? || includes_recipient
+
+						hashes = Helpers.objects_to_hashes(list, fields)
+
+						hashes.each do |h|
+							recipient = includes_recipient ? h[recipient_field] : h.delete(recipient_field)
+							ind = recipient_index[recipient]
+							if ind.nil?
+								var = var_class.new
+								var.recipient = recipient
+								var.variables.set!(h)
+								@_vars << var
+								register_recipient(recipient, @_vars.count - 1)
+							else
+								self[ind].variables.merge!(h)
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/mandrill_queue/message/recipient/helpers.rb

@@ -0,0 +1,30 @@
+module MandrillQueue
+	module Message
+		module Recipient
+			module Helpers
+				def self.objects_to_hashes(list, fields = nil, options = {})
+					try_methods = options[:try_methods] || [:attributes, :to_hash, :to_h]
+					hashes = []
+					list.each do |obj|
+						hashes << if obj.is_a?(Hash)
+							fields.nil? ? obj.dup : obj.select { |o| fields.include?(o) }
+						elsif fields.nil?
+							meth = try_methods.find { |m| obj.respond_to?(m) }
+							# Add object result or nil
+							unless meth.nil?
+								obj.send(meth)
+							end
+						else
+							hash = {}
+							fields.each do |f|
+								hash[f] = obj.send(f)
+							end
+							hash
+						end
+					end
+					hashes
+				end
+			end
+		end
+	end
+end

data/lib/mandrill_queue/message/recipient/metadata.rb

@@ -0,0 +1,23 @@
+require 'mandrill_queue/errors'
+require 'mandrill_queue/message/recipient/data'
+require 'mandrill_queue/message/recipient/variable'
+
+module MandrillQueue
+	module Message
+		class RecipientMetadata < Recipient::Data
+			class Metadatum < Recipient::Variable
+				variables :values
+			end
+
+			var_class Metadatum
+
+			module DSL
+				def recipient_metadata(*args, &block)
+					@_recipient_metadata ||= RecipientMetadata.new
+					@_recipient_metadata.dsl(*args, &block) if block_given? || args.count > 0
+					block_given? ? self : @_recipient_metadata
+				end
+			end
+		end
+	end
+end

data/lib/mandrill_queue/message/recipient/variable.rb

@@ -0,0 +1,72 @@
+module MandrillQueue
+	module Message
+		module Recipient
+			class Variable
+				class << self
+					attr_reader :var_name
+
+					def variables(name)
+						@var_name = name
+						Variables::DSL.include_as(self, name)
+					end
+				end
+
+				def initialize(recipient = nil, *args, &block)
+					@_recipient = recipient
+					dsl(&block) if block_given?
+				end
+
+				def var_name
+					self.class.var_name
+				end
+
+				def recipient=(value)
+					@_recipient = value
+				end
+
+				def recipient(value = nil)
+					@_recipient = value unless value.nil?
+					@_recipient
+				end
+
+				def var_instance
+					instance_variable_get("@_#{var_name}".to_sym)
+				end
+
+				def variables
+					send(var_name)
+				end
+
+				def var_instance_set(value)
+					instance_variable_set("@_#{var_name}".to_sym, value)
+				end
+
+				def to_hash(options = {})
+					hash = {}
+					hash[:rcpt] = recipient if options[:include_nils] || !recipient.nil?
+					if options[:include_nils] || var_instance
+						hash[var_name] = send(var_name).to_key_value_array(options)
+					end
+					hash
+				end
+
+				def set!(hash)
+					@_recipient = hash[:rcpt]
+					var_instance_set(nil)
+					send(var_name).set!(hash[var_name]) unless hash[var_name].nil?
+					self
+				end
+
+				def dsl(&block)
+					send(var_name).dsl(&block)
+				end
+
+				def validate(errors, options = {})
+					cn = options[:as] || self.class.name.underscore.split('/').last.to_sym
+					errors.push([cn, "Recipient cannot be empty."]) if recipient.blank?
+				end
+			end
+
+		end
+	end
+end

data/lib/mandrill_queue/message/recipients.rb

@@ -0,0 +1,179 @@
+require 'mandrill_queue/errors'
+require 'mandrill_queue/message/recipient/helpers'
+
+module MandrillQueue
+	module Message
+		class Recipients
+			# Define DSL for inclusion in remote classes
+			module DSL
+				def recipients
+					@_recipients ||= Recipients.new
+				end
+
+				def self.include_as(base, name)
+					base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+				def #{name}(email = nil, name = nil, name_field = nil, &block)
+					recipients.dsl(email, name, name_field, :#{name}, &block) if !email.nil? || block_given?
+					block_given? ? self : recipients
+				end
+					RUBY
+				end
+
+				def self.included(base)
+					[:to, :cc, :bcc].each do |x|
+						include_as(base, x)
+					end
+				end
+			end
+
+			class Recipient
+				ACCESSORS = [:type, :name, :email]
+
+				def initialize(email = nil, name = nil, type = nil, &block)
+					@type = type
+					@name = name
+					@email = email
+
+					instance_eval(&block) if block_given?
+				end
+
+				ACCESSORS.each do |key|
+					define_method key do |*args|
+						var_sym = "@#{key}".to_sym
+						if args.count > 0
+							instance_variable_set(var_sym, args.first)
+							args.first
+						else
+							instance_variable_get(var_sym)
+						end
+					end
+				end
+
+				def set!(hash)
+					ACCESSORS.each do |key|
+						instance_variable_set("@#{key}".to_sym, hash[key])
+					end
+
+					self
+				end
+
+				def to_hash(options = {})
+					hash = {}
+					ACCESSORS.each do |key|
+						value = send(key)
+						if options[:include_nils] || !value.nil?
+							hash[key] = value.nil? ? nil : value.to_s
+						end
+					end
+					hash
+				end
+
+				def validate(errors)
+					errors.push([@type, "Email must be set for recipient."]) if email.nil?
+				end
+
+				alias_method :dsl, :instance_exec
+			end
+
+			def initialize
+				@_recipients = []
+			end
+
+			def recipients
+				@_recipients
+			end
+
+			def empty?
+				@_recipients.empty?
+			end
+
+			def add(email = nil, name = nil, name_field = nil, type = nil, &block)
+				if email.respond_to?(:each)
+					add_objects(email, name, name_field, type, &block)
+				elsif !email.is_a?(String)
+					add_objects([email], name, name_field, type, &block)
+				else
+					@_recipients << Recipient.new(email, name, type, &block)
+				end
+			end
+
+			alias_method :dsl, :add
+
+			def to_a(options = {})
+				@_recipients.map do |r|
+					r.to_hash(options)
+				end
+			end
+
+			def first
+				@_recipients.first
+			end
+
+			def last
+				@_recipients.last
+			end
+
+			def [](index)
+				@_recipients[index]
+			end
+
+			def set!(value, type = nil)
+				value = [value] unless value.is_a?(Array)
+
+				@_recipients = value.map do |recipient|
+					obj = Recipient.new
+
+					case recipient
+					when String
+						obj.email recipient
+						raise MessageError, "Must specify a recipient type when calling set! with a string on recipient." if type.nil?
+						obj.type type unless type.nil?
+					when Hash
+						recipient.symbolize_keys!
+						raise MessageError, "#{recipient} must contain email address" if recipient[:email].nil?
+						obj.set!(recipient)
+						obj.type type if obj.type.nil? && !type.nil?
+					else
+						raise MessageError, "#{recipient} is an invalid recipient."
+					end
+
+					obj
+				end
+
+				self
+			end
+
+			def validate(errors)
+				@_recipients.each do |r|
+					r.validate(errors)
+				end
+			end
+
+			protected
+
+			def add_object(obj, email_field = :email, name_field = nil, type = nil, &block)
+				args.first = [args.first]
+				add_objects(*args, &block)
+			end
+
+			def add_objects(list, email_field = :email, name_field = nil, type = nil, &block)
+				if block_given?
+					list.each do |r|
+						obj = Recipient.new
+						obj.dsl(r, &block)
+						obj.type(type)
+						@_recipients << obj
+					end
+				else
+					hashes = MandrillQueue::Message::Recipient::Helpers
+					.objects_to_hashes(list, [email_field, name_field].compact)
+
+					@_recipients += hashes.map do |h|
+						Recipient.new(h[email_field], h[name_field], type, &block)
+					end
+				end
+			end
+
+		end
+	end
+end