template_mailer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83b2af7df86d4e00961e7e7863e1278b3d87cc17
+  data.tar.gz: d330298ec3ace4d7975c389ddeb3855ace67b47e
+SHA512:
+  metadata.gz: 762b21bb217c393ac8bd12be866503b18d766c33aa2b7d7e8845a0626a900513305b2e7b16e7bc956467721cc3560bdc5366b859057ebbc758d973f542ff5c84
+  data.tar.gz: ffd9d59f7f8b6e473eed31f686f43174c7d214df590274a438a195c25f3b861a8031d63b1f51e8e4696a23acd085215098576dd5ccabe78b097e77fa5bf55794

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in template_mailer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Peter Wood
+
+MIT License
+
+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.md

@@ -0,0 +1,135 @@
+# TemplateMailer
+
+The Template Mailer library provides functionality to encapsulate the creation
+and dispatch of emails. The emails sent by the library are created from templates
+stored locally and allows for the creation of emails that are both HTML and/or
+textual based. The library makes use of the [Tilt](https://github.com/rtomayko/tilt)
+template library and the [Pony](https://github.com/benprew/pony libraries and
+aspects of these interactions are exposed via configuration settings.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'template_mailer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install template_mailer
+
+## Usage
+
+To make use of the library you first need to require in the Tilt functionality
+for the templating systems that you want to support and then require in the
+template mailer library. So, for example, if you wanted to make use of ERB as
+your templating engine then you would do the following...
+
+```ruby
+require "tilt/erb"
+require "template_mailer"
+```
+
+Next you want to create a ```Mailer``` class instance. To do this you will need
+to specify a number of configuration settings as parameters to the constructor.
+The parameters needed include the path to the directory containing your template
+files as well as the mechanism that you want to use when dispatching emails. The
+default mechanism, inherited from Pony, is ```sendmail``` but throughout the
+rest of this document the assumption will be that you want to send your email via
+an SMTP server. So, assuming your templates are stored in the ```/templates```
+folder the code to create a ```Mailer``` might look as follows...
+
+```ruby
+mailer = TemplateMailer::Mailer.new(directory: "/templates",
+                                    server: {address:              'mymail.smtp.com',
+														   port:                 '587',
+														   enable_starttls_auto: true,
+														   user_name:            'mymailuser',
+														   password:             'password',
+														   authentication:       :login,
+														   domain:               "mydomain.com"},
+                                    via: :smtp)
+```
+
+Once you have a ```Mailer``` instance you can use it to create an email. To create
+an email you call the ```generate_mail()``` method on the mailer and give it the
+name of the template that you want to generate the email from. The template name
+equates to the name of the file or files containing the templates to be generated
+minus any extensions. So, for example, if you had a template file in the template
+directory called ```test_message.html.erb``` then the template name to specify to
+the ```Mailer``` would be ```test_message```.
+
+Note that if you want your email message to contain details for HTML and text only
+based clients then create to files in the template directory with ```.text``` and
+```.html``` extension. The ```Mailer``` will find both of these templates and
+generate content from them both for the email message to be sent.
+
+Note that when calling ```generate_mail()``` you can pass a Hash of context
+parmaeters as the second parameter to the method call. The values within this
+Hash will be available to populate the message templates with. So, for example,
+if you wanted to pass in a parameter called full name you would make a call that
+looked like this...
+
+```ruby
+mailer.generate_mail("my_template", full_name: "John Smith")
+```
+
+To send the email generated simply call ```send()``` on the value returned from
+the call to the ```generate_mail()``` method. The call to ```send()``` should be
+accompanied by the final set of details needed to send the email such as the list
+of recipients for the message, the title to be given to the email and possibly the
+email address that the message will appear to come from. For example, a send
+might look as follows...
+
+```ruby
+mailer.send(from: "me@mydomain.com",
+            recipients: ["first.person@mydomain.com", "second.person@mydomain.com"],
+            subject: "Test Message")
+```
+
+### Advanced Usage
+
+Having all potential email templates within a single directory could ultimately
+become difficult to manage. To support a hierarchical directory structure an
+instance of the ```Mailer``` class will support stepping down through a list of
+subdirectories to pick out a particular template. For example, lets say that you
+wanted to keep all emails relating to account creation and maintenance in a
+subdirectory beneath the mail template directory called ```accounts```. To send
+a template called ```create``` from this directory you could create the
+```Mailer``` as outlined above and then do the following...
+
+```ruby
+message = mailer.accounts.generate_mail("create")
+```
+
+The call to ```mailer.accounts``` automatically creates a new ```Mailer``` instance
+based on the subdirectory. As this works this way you can chain calls like this
+together so, if you had a template called 'verify' that was stored in a subfolder
+of the accounts folder called create you could create a messasge based on it as
+follows...
+
+```ruby
+message = mailer.accounts.create.generate_mail("verify")
+```
+
+Note that the call to ```generate_mail()``` here can be replaced with the name of
+the template as the ```Mailer``` instance will recognise that this relates to an
+existing template and automatically call ```generate_mail()``` for you. This
+means that previous call could be changed to...
+
+```ruby
+message = mailer.account.create.verify
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/template_mailer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/template_mailer/exceptions.rb

@@ -0,0 +1,4 @@
+module TemplateMailer
+  class TemplateMailerError < StandardError
+  end
+end

data/lib/template_mailer/logging_helper.rb

@@ -0,0 +1,11 @@
+module TemplateMailer
+  module LoggingHelper
+  	def log
+  		if !@logger
+  			@logger = Logger.new(STDOUT)
+  			@logger.level = Logger::UNKNOWN
+  		end
+  		@logger
+  	end
+  end
+end

data/lib/template_mailer/mail_message.rb

@@ -0,0 +1,70 @@
+module TemplateMailer
+  class MailMessage
+  	# Constructor for the MailMessage class.
+  	#
+  	# ==== Parameters
+  	# options::  An options Hash. The following keys are recognised within this
+    #            Hash...
+    #             * :html - The HTML content for the email message. Both this and
+    #               text can be specified but at least one of them should be.
+    #             * :text - The textual content for the email message. Both this
+    #               and :html can be specified but at least one should be.
+    #             * :server - When SMTP is the preferred email mecahnism (see the
+    #               :via option) then this value should be a Hash of the parameters
+    #               that will be used to talk to the SMTP server.
+    #             * :via - The email mechanism to use to dispatch email messages.
+    #               options are :sendmail (the default) or :smtp. If :smtp is
+    #               specified then the :server option should also be given a
+    #               value.
+  	def initialize(options={})
+  		@html   = options[:html]
+  		@text   = options.fetch(:text, options[:txt])
+      @server = options[:server]
+      @via    = options.fetch(:via, :sendmail)
+  	end
+  	attr_reader :html, :text
+
+    # This method attempts to send the contents of a mail message to a specified
+    # set of recipients.
+    #
+    # ==== Parameters
+    # options::  A Hash of the options to be used when sending the email.
+    #            Recognised keys in this Hash are :subject (a String containing
+    #            the email title), :recipients (either a String or Array list
+    #            of email addresses that the message should be sent to) and
+    #            :from (the email address that will be set as the message
+    #            source).
+  	def send(options={})
+  	  if !options.include?(:recipients) || [nil, "", []].include?(options[:recipients])
+  		  raise TemplateMailerError, "No recipients specified for email."
+  		end
+  		Pony.mail(send_settings(options))
+  	end
+  	alias :dispatch :send
+
+  private
+
+    # This method assembles a Hash of configuration settings to be given to the
+    # Pony library to dispatch an email.
+    #
+    # ==== Parameters
+    # settings::  A Hash of the base server settings to be used when putting\
+    #             the complete settings together.
+    def send_settings(settings)
+    	output             = {to: settings[:recipients]}
+    	output[:subject]   = settings[:subject]
+    	output[:html_body] = @html if (@html || "") != ""
+    	output[:body]      = @text if (@text || "") != ""
+      output[:from]      = settings[:from] if settings.include?(:from)
+      output.merge(pony_settings(settings))
+    end
+
+    # This method is used internally to assemble configuration settings that are
+    # specific to dispatching an email via SMTP through the Pony library.
+    def pony_settings(settings)
+    	output = {via: @via}
+  		output[:via_options] = @server if @via == :smtp
+    	output
+    end
+  end
+end

data/lib/template_mailer/mailer.rb

@@ -0,0 +1,135 @@
+module TemplateMailer
+  class Mailer
+    include LoggingHelper
+
+    # Constructor for the Mailer class.
+    #
+    # ==== Parameters
+    # options::  A Hash of the options to be used by the Mailer. Recognised
+    #            option settings are...
+    #              * :directory - The root directory that the mailer will use
+    #                when looking for template files. If not specified or if the
+    #                value specified does not exist then the current working
+    #                directory is assumed to have a subdirectory called templates
+    #                and that will be used.
+    #              * :logger - The logger to be used by the mailer. Defaults to
+    #                using a null logger.
+    #              * :server - Configuration details used to talk to the SMTP
+    #                server to send emails. See the :via option.
+    #              * :via - A indication of the mailing method to be used when
+    #                dispatching emails. Viable options are :sendmail (the
+    #                default) or :smtp. If :smtp is specified then server
+    #                details should also be specified.
+    def initialize(options={})
+      @logger     = options[:logger]
+      @directory  = TemplateDirectory.new(template_directory(options[:directory]))
+      @via        = options.fetch(:via, :sendmail)
+      @server     = options[:server]
+    end
+    attr_reader :server, :via
+
+    # Fetches the path to the template directory being used by the mailer.
+    def directory
+      @directory.path
+    end
+
+    # This method creates a new Mailer instance by using the details of the
+    # current mailer and extending the directory used with the name passed
+    # in.
+    #
+    # ==== Parameters
+    # name::  The name of the folder to be appended to the directory being
+    #         used by the mailer that the call is being made on.
+    def subdirectory(name)
+      Mailer.new(directory: File.join(directory, name.to_s),
+                 logger:    log,
+                 server:    @server,
+                 via:       @via)
+    end
+
+    # Generates a MailMessage for a named template in the template directory.
+    #
+    # ==== Parameters
+    # template::  The name of the template to generate the email from.
+    # context::   A Hash of the variables to be used when generating the email
+    #             templates. Defaults to an empty Hash.
+    def generate_mail(template, context={})
+      log.debug "Constructing a mail message based on the '#{template}' template."
+      factory = TemplateFactory.new(@directory.path, log)
+      content = factory.manufacture(template, context)
+      MailMessage.new({server: @server, via: @via}.merge(content))
+    end
+
+    # This method overrides the default implementation to return true for
+    # anything that represents a valid Ruby method name. Everything else
+    # is delegated to the parent class.
+    def respond_to?(name, all=false)
+      method_name?(name) || super
+    end
+
+    # This method checks the template directory for a subdirectory for the
+    # given name. If a subdirectory is found then the call becomes an
+    # equivalent to a call to the subdirectory() method. If template
+    # matching the name passed in is instead found then this is equivalent
+    # to a call to the generate_mail() method. If all other options are
+    # exhausted then the parent class version of this method is invoked.
+    def method_missing(name, *arguments, &block)
+      if directory_exists?(@directory.path, name.to_s)
+        subdirectory(name)
+      elsif @directory.exists?(name.to_s)
+        generate_mail(name, arguments.empty? ? {} : arguments[0])
+      else
+        super
+      end
+    end
+
+  private
+
+    def method_name?(name)
+      return /[@$"]/ !~ name.inspect
+    end
+
+    def settings
+      {directory: @directory.path, engines: @engines.values, logger: log}
+    end
+
+    def generate_template(path, context={})
+      raise TemplateMailerError, "The '#{path}' template files does not exist." if !File.exist?(path)
+      raise TemplateMailerError, "Insufficient permission to read the '#{path}' file." if !File.readable?(path)
+
+      pathname = Pathname.new(path)
+      engine   = @engines[Pathname.new(path).extname]
+      raise TemplateMailerError, "No template engine configured to process the '#{path}' template file." if engine.nil?
+
+      log.debug "Processing the '#{path}' template file with an instance of the #{engine.class.name} class."
+      engine.process(pathname, context)
+    end
+
+    def template_directory(path)
+      output = File.join(Dir.getwd, "templates")
+      if path && path.strip != ""
+        if directory_exists?(path)
+          output = path
+        else
+          log.warn "The '#{path}' path either does not exist or is not a directory. Default will be used."
+        end
+      end
+      log.debug "Using '#{output}' as the mailer templates directory."
+      output
+    end
+
+    def directory_exists?(*components)
+      path = File.join(*components)
+      File.exist?(path) && File.directory?(path)
+    end
+
+    def file_exists?(*components)
+      path = path(*components)
+      File.exist?(path) && File.file?(path)
+    end
+
+    def path(*components)
+      File.join(*components)
+    end
+  end
+end

data/lib/template_mailer/template_directory.rb

@@ -0,0 +1,65 @@
+module TemplateMailer
+  class TemplateDirectory
+    include LoggingHelper
+
+    # Constructor for the TemplateDirectory class.
+    #
+    # ==== Parameters
+    # path::    The path to the template directory.
+    # logger::  The logger to be used by the directory object.
+    def initialize(path,logger=nil)
+      @pathname   = Pathname.new(path)
+      @logger     = logger
+      scan_templates
+    end
+    attr_reader :pathname, :engines, :extensions
+
+    # Returns a String containing the template directory path.
+    def path
+      @pathname.to_s
+    end
+
+    # Returns an array of the template files within the directory.
+    def template_files
+    	[].concat(@templates)
+    end
+
+    # Checks whether at least one template file with a given name exists within
+    # the template directory.
+    #
+    # ==== Parameters
+    # name::  The name of the template. This should be the file name, not
+    #         including base path details or extensions.
+    def exists?(name)
+    	!template_paths(name).empty?
+    end
+
+    # Retrieves a list of paths for all template files within a template
+    # directory that match a given template name.
+    #
+    # ==== Parameters
+    # name::  The name of the template. This should be the file name, not
+    #         including base path details or extensions.
+    def template_paths(name)
+    	@templates.inject([]) do |list, path|
+    		file_name = File.basename(path)
+    		file_name[0, name.length] == name.to_s ? list << path : list
+    	end
+    end
+
+  private
+
+    # Scans the files in the template directory to generate a list of files
+    # recognised as templates based on extensions from the object itself and
+    # the engine it possesses.
+    def scan_templates
+    	@templates = Dir.glob(File.join(path, "*")).inject([]) do |list, file_path|
+        log.debug "Checking if #{file_path} is a recognised template file."
+        file_name = File.basename(file_path)
+        log.debug "#{file_path} is a template file." if !(Tilt[file_name]).nil?
+        list << file_path if !(Tilt[file_name]).nil?
+        list
+    	end
+    end
+  end
+end

data/lib/template_mailer/template_factory.rb

@@ -0,0 +1,84 @@
+module TemplateMailer
+  class TemplateFactory
+  	include LoggingHelper
+
+  	# Constructor for the template factory class.
+  	#
+  	# ==== Parameters
+  	# directory::   The path to the directory containing the template files.
+    # logger::      The logger to be used by the factory. Defaults to nil.
+  	def initialize(directory, logger=nil)
+  		@directory = TemplateDirectory.new(directory, logger)
+  		@logger    = logger
+    end
+
+    # Fetches the template directory being used by the factory.
+    def directory
+    	@directory.path
+    end
+
+    # Checks whether one or more template files exist for a given name.
+    #
+    # ==== Parameters
+    # name::  The name of the template to check for. A template name should be
+    #         the template file name without extension(s).
+    def exists?(name)
+    	@directory.exists?(name)
+    end
+
+    # This method 'manufactures' a set of templates based on the template name.
+    # Manufacturing involves finding all instance of a template and then using
+    # the template engine to generate the results of the template including the
+    # elements of the context passed in. The return value from this method will
+    # be a Hash of the templates generated (there may be more than one) keyed
+    # on the base file types used to generate the template instance. If a
+    # matching template cannot be found then an empty Hash is returned.
+    #
+    # ==== Parameters
+    # name::     The name of the template to manufacture. Template names equate
+    #            to template file names minus extensions.
+    # context::  A Hash of settings that will be made available to the template
+    #            engine when the template is instantiated. Defaults to {}. 
+    def manufacture(name, context={})
+      paths = @directory.template_paths(name)
+    	log.debug "Manufacture requested for the '#{name}' template. Context:\n#{context}\nFound #{paths.size} matching template files."
+    	paths.inject({}) do |store, path|
+    		key    = file_base_type(path)
+        engine = Tilt.new(path)
+    		log.debug "Generating template for the #{path} template file as type '#{key}'."
+    		store[key] = engine.render(nil, context)
+    		store
+    	end
+    end
+
+    # Same as the manufacture() method except this version raises an exception
+    # if no matching templates are found.
+    #
+    # ==== Parameters
+    # name::     The name of the template to manufacture. Template names equate
+    #            to template file names minus extensions.
+    # context::  A Hash of settings that will be made available to the template
+    #            engine when the template is instantiated. Defaults to {}. 
+    def manufacture!(name, context={})
+    	output = manufacture(name, context)
+    	raise TemplateMailerError, "Unable to locate a template with the name '#{name}'." if output.empty?
+    	output
+    end
+
+  private
+
+    # Generate a Symbol based on the base type for a file. The base type for
+    # template files will be the first extension that the file has rather than
+    # the second (e.g. :html for a file called template.html.erb).
+    #
+    # ==== Parameters
+    # path::  The path and name of the template file to generate the base type
+    #         for.
+    def file_base_type(path)
+  		file_name = File.basename(path)
+  		extension = File.extname(file_name)
+  		file_name = file_name[0, file_name.length - extension.length]
+  		(File.extname(file_name)[1..-1]).to_sym
+    end
+  end
+end

data/lib/template_mailer/version.rb

@@ -0,0 +1,3 @@
+module TemplateMailer
+  VERSION = "0.0.1"
+end

data/lib/template_mailer.rb

@@ -0,0 +1,14 @@
+require "tilt"
+require "logger"
+require "pathname"
+require "pony"
+require "template_mailer/version"
+require "template_mailer/exceptions"
+require "template_mailer/logging_helper"
+require "template_mailer/template_directory"
+require "template_mailer/template_factory"
+require "template_mailer/mail_message"
+require "template_mailer/mailer"
+
+module TemplateMailer
+end

data/spec/data/more_templates/another_template.text.erb

@@ -0,0 +1 @@
+This is another test template.

data/spec/data/test_template_1.txt

@@ -0,0 +1 @@
+A simple template.

data/spec/data/test_template_2.txt.erb

@@ -0,0 +1 @@
+Template File 2

data/spec/data/test_template_3.html.erb

@@ -0,0 +1 @@
+<h1>Test Template 3</h1>

data/spec/data/test_template_4.html.erb

@@ -0,0 +1 @@
+<h1>T4: <%= one %>, '<%= two %>'</h1>

data/spec/data/test_template_4.text.erb

@@ -0,0 +1 @@
+T4: <%= one %>, '<%= two %>'

data/spec/data/test_template_4.txt.erb

@@ -0,0 +1 @@
+T4: <%= one %>, '<%= two %>'

data/spec/mail_message_spec.rb

@@ -0,0 +1,66 @@
+describe TemplateMailer::MailMessage do
+	let(:recipients) {
+		["one@test.com", "two@test.com"]
+	}
+	let(:from) {
+		"sender@somewhere.com"
+	}
+	let(:title) {
+		"Test Email"
+	}
+	let(:html_body) {
+		"<h1>HTML message.</h1>"
+	}
+	let(:text_body) {
+		"Text message."
+	}
+	let(:server) {
+		{address:        "smtp.test.com",
+     port:           "25",
+     user_name:      "user",
+     password:       "password",
+     authentication: :plain,
+     domain:         "localhost.localdomain"}
+	}
+	subject {
+		TemplateMailer::MailMessage.new(html:   html_body,
+                                    server: server,
+                                    text:   text_body,
+                                    via:    :smtp)
+	}
+
+  describe "#send()" do
+  	let(:server_settings) {
+  		{body:        text_body,
+  		 from:        from,
+  		 html_body:   html_body,
+  		 subject:     title,
+  		 to:          recipients,
+  		 via:         :smtp,
+  		 via_options: server}
+  	}
+
+  	it "invokes the Pony.mail() method when called with valid parameters" do
+  		expect(Pony).to receive(:mail).with(server_settings).once
+  		subject.send(from: from, recipients: recipients, subject: title)
+  	end
+
+  	it "raises an exception when invoked without specifying recipients" do
+  		expect {
+  			subject.send()
+  		}.to raise_exception(TemplateMailer::TemplateMailerError, "No recipients specified for email.")
+  	end
+
+  	it "raises an exception when invoked with an empty recipient list" do
+  		expect {
+  			subject.send(recipients: [])
+  		}.to raise_exception(TemplateMailer::TemplateMailerError, "No recipients specified for email.")
+  	end
+
+  	it "raises an exception when invoked with a blank recipient string" do
+  		expect {
+  			subject.send(recipients: "")
+  		}.to raise_exception(TemplateMailer::TemplateMailerError, "No recipients specified for email.")
+  	end
+  end
+end

data/spec/mailer_spec.rb

@@ -0,0 +1,62 @@
+describe TemplateMailer::Mailer do
+	let(:template_directory) {
+		File.join(Dir.getwd, "spec", "data")
+	}
+	let(:subdirectory) {
+		"more_templates"
+	}
+	let(:server) {
+		{address:        "smtp.test.com",
+     port:           "25",
+     user_name:      "user",
+     password:       "password",
+     authentication: :plain,
+     domain:         "localhost.localdomain"}
+	}
+	subject {
+		TemplateMailer::Mailer.new(directory: template_directory,
+			                         server:    server,
+			                         via:       :smtp)
+	}
+
+	describe "#directory()" do
+		it "returns a String containing the template directory path" do
+			expect(subject.directory).to eq(template_directory)
+		end
+	end
+
+	describe "#subdirectory()" do
+		let(:subdirectory_path) {
+			File.join(template_directory, subdirectory)
+		}
+
+		it "creates a new Mailer instance pointing at the appropriate subdirectory" do
+			mailer = subject.subdirectory(subdirectory)
+			expect(mailer).not_to be_nil
+			expect(mailer.class).to eq(TemplateMailer::Mailer)
+			expect(mailer.directory).to eq(subdirectory_path)
+		end
+	end
+
+	describe "#generate_mail()" do
+		it "generates a MailMessage with appropriate content" do
+			message = subject.generate_mail("test_template_4", one: 1, two: "TWO")
+			expect(message).not_to be_nil
+			expect(message.class).to eq(TemplateMailer::MailMessage)
+			expect(message.html).to eq("<h1>T4: 1, 'TWO'</h1>")
+			expect(message.text).to eq("T4: 1, 'TWO'")
+		end
+	end
+
+	describe "#method_missing()" do
+		it "calls the #subdirectory() method if the method invoked matches a subdirectory name" do
+			expect(subject).to receive(:subdirectory).with(subdirectory.to_sym).once
+			subject.more_templates
+		end
+
+		it "calls the #generate_mail() method of the method invoked matches a template" do
+			expect(subject).to receive(:generate_mail).with(:test_template_2, {}).once
+			subject.test_template_2
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,99 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require "template_mailer"
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/template_directory_spec.rb

@@ -0,0 +1,54 @@
+require "tilt/erb"
+
+describe TemplateMailer::TemplateDirectory do
+	let(:path) {
+		File.join(Dir.getwd, "spec", "data")
+	}
+	subject {
+		TemplateMailer::TemplateDirectory.new(path)
+	}
+
+	describe "#path()" do
+		it "returns the path to the template directory" do
+			expect(subject.path).to eq(path)
+		end
+	end
+
+	describe "#template_files()" do
+		let(:file_paths) {
+			Dir.glob(File.join(path, "*.erb"))
+		}
+
+		it "returns a list of matching template paths for the directory" do
+			paths = subject.template_files
+			expect(paths.size).to eq(file_paths.size)
+			file_paths.each do |file_path|
+				expect(paths).to include(file_path)
+			end
+		end
+	end
+
+	describe "#exists?()" do
+		it "returns true for a template that exists" do
+			expect(subject.exists?("test_template_2")).to eq(true)
+		end
+
+		it "returns false for a template that does not exist" do
+			expect(subject.exists?("does_not_exist")).to eq(false)
+		end
+	end
+
+	describe "#template_paths()" do
+		let(:paths) {
+			[File.join(path, "test_template_3.html.erb")]
+		}
+
+		it "returns a list of template paths given an existing template name" do
+			expect(subject.template_paths("test_template_3")).to eq(paths)
+		end
+
+		it "returns an empty array if given the name of a template that does not exist" do
+			expect(subject.template_paths("does_not_exist")).to eq([])
+		end
+	end
+end

data/spec/template_factory_spec.rb

@@ -0,0 +1,41 @@
+describe TemplateMailer::TemplateFactory do
+	let(:directory) {
+		File.join(Dir.getwd, "spec", "data")
+	}
+	subject {
+		TemplateMailer::TemplateFactory.new(directory)
+	}
+
+	describe "#directory()" do
+		it "returns the path to the template directory" do
+			expect(subject.directory).to eq(directory)
+		end
+	end
+
+	describe "#manufacture()" do
+		let(:context) {
+			{one: 1, two: "Two"}
+		}
+		let(:templates) {
+			{html: "<h1>T4: 1, 'Two'</h1>",
+			 text: "T4: 1, 'Two'",
+			 txt:  "T4: 1, 'Two'"}
+		}
+
+		it "returns an empty Hash if given the name of a template that does not exist" do
+			expect(subject.manufacture("does_not_exist")).to eq({})
+		end
+
+		it "generates template entries for all available template files" do
+			expect(subject.manufacture("test_template_4", context)).to eq(templates)
+		end
+	end
+
+	describe "#manufacture!()" do
+		it "raises an exception if a matching template is not found" do
+			expect {
+				subject.manufacture!("does_not_exist")
+			}.to raise_exception(TemplateMailer::TemplateMailerError, "Unable to locate a template with the name 'does_not_exist'.")
+		end
+	end
+end

data/template_mailer.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'template_mailer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "template_mailer"
+  spec.version       = TemplateMailer::VERSION
+  spec.authors       = ["Peter Wood"]
+  spec.email         = ["pwood@blacknorth.com"]
+  spec.summary       = %q{A simple library that uses the Tilt and Pony libraries to generate and dispatch emails.}
+  spec.description   = %q{Template Mailer is a library that can be used to send emails that are created from templates. It makes use of the Tilt library to support a wide variety of templating systems and the Pony library for integration with mail servers.}
+  spec.homepage      = "https://github.com/free-beer/template_mailer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+
+  spec.add_dependency "pony", "~> 1.11"
+  spec.add_dependency "tilt", "~> 2.0"
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: template_mailer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Peter Wood
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Template Mailer is a library that can be used to send emails that are
+  created from templates. It makes use of the Tilt library to support a wide variety
+  of templating systems and the Pony library for integration with mail servers.
+email:
+- pwood@blacknorth.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/template_mailer.rb
+- lib/template_mailer/exceptions.rb
+- lib/template_mailer/logging_helper.rb
+- lib/template_mailer/mail_message.rb
+- lib/template_mailer/mailer.rb
+- lib/template_mailer/template_directory.rb
+- lib/template_mailer/template_factory.rb
+- lib/template_mailer/version.rb
+- spec/data/more_templates/another_template.text.erb
+- spec/data/test_template_1.txt
+- spec/data/test_template_2.txt.erb
+- spec/data/test_template_3.html.erb
+- spec/data/test_template_4.html.erb
+- spec/data/test_template_4.text.erb
+- spec/data/test_template_4.txt.erb
+- spec/mail_message_spec.rb
+- spec/mailer_spec.rb
+- spec/spec_helper.rb
+- spec/template_directory_spec.rb
+- spec/template_factory_spec.rb
+- template_mailer.gemspec
+homepage: https://github.com/free-beer/template_mailer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A simple library that uses the Tilt and Pony libraries to generate and dispatch
+  emails.
+test_files:
+- spec/data/more_templates/another_template.text.erb
+- spec/data/test_template_1.txt
+- spec/data/test_template_2.txt.erb
+- spec/data/test_template_3.html.erb
+- spec/data/test_template_4.html.erb
+- spec/data/test_template_4.text.erb
+- spec/data/test_template_4.txt.erb
+- spec/mail_message_spec.rb
+- spec/mailer_spec.rb
+- spec/spec_helper.rb
+- spec/template_directory_spec.rb
+- spec/template_factory_spec.rb