effective_email_templates 0.2.8

data/app/views/admin/email_templates/_actions.html.haml

@@ -0,0 +1,2 @@
+%span{:style => 'white-space: nowrap;'}
+  = link_to 'Edit', effective_email_templates.edit_admin_email_template_path(email_template)

data/app/views/admin/email_templates/_form.html.haml

@@ -0,0 +1,9 @@
+= simple_form_for email_template, url: email_template_form_url(email_template) do |f|
+  = f.input :subject
+  = f.input :slug, disabled: true
+  = f.input :from
+  = f.input :cc
+  = f.input :bcc
+  = f.input :body, input_html: { rows: 10 }
+
+  = f.button :submit

data/app/views/admin/email_templates/edit.html.haml

@@ -0,0 +1,3 @@
+%h1 Edit Email Template
+
+= render partial: 'form', locals: { email_template: @email_template }

data/app/views/admin/email_templates/index.html.haml

@@ -0,0 +1,3 @@
+%h1 Email Templates
+
+= render_datatable(@datatable)

data/app/views/effective/email_template_mailer/templated_email.html.haml

@@ -0,0 +1 @@
+= @body

data/config/routes.rb

@@ -0,0 +1,11 @@
+Rails.application.routes.draw do
+  mount EffectiveEmailTemplates::Engine => '/', :as => 'effective_email_templates'
+end
+
+EffectiveEmailTemplates::Engine.routes.draw do
+  if defined?(EffectiveDatatables)
+    namespace :admin do
+      resources :email_templates, only: [:index, :edit, :update]
+    end
+  end
+end

data/db/migrate/01_create_effective_email_templates.rb.erb

@@ -0,0 +1,20 @@
+class CreateEffectiveEmailTemplates < ActiveRecord::Migration
+  def self.up
+    create_table <%= @email_templates_table_name %> do |t|
+      t.string :subject
+      t.string :from
+      t.string :bcc
+      t.string :cc
+      t.string :slug,     :null => false
+      t.text :body,       :null => false
+      t.text :template,   :null => false
+    end
+
+    add_index <%= @email_templates_table_name %>, :slug
+  end
+
+  def self.down
+    drop_table <%= @email_templates_table_name %>
+  end
+end
+

data/lib/effective/liquid_mailer.rb

@@ -0,0 +1,12 @@
+module Effective
+  class LiquidMailer < ::ActionMailer::Base
+    def mail(headers = {}, &block)
+      # this be dangerous and requires ruby 2.0+
+      mail_method = caller_locations(1,1)[0].label
+      email_template = EffectiveEmailTemplates.get(mail_method)
+      headers = headers.merge(email_template.mail_options)
+      super(headers, &block)
+    end
+  end
+end
+

data/lib/effective_email_templates.rb

@@ -0,0 +1,33 @@
+require "effective_email_templates/engine"
+require "effective_email_templates/liquid_resolver"
+require "effective_email_templates/email_view_template"
+require "effective_email_templates/template_importer"
+require "effective_email_templates/version"
+
+require "effective/liquid_mailer"
+Effective::LiquidMailer.send(:append_view_path, EffectiveEmailTemplates::LiquidResolver.new)
+
+module EffectiveEmailTemplates
+
+  mattr_accessor :email_templates_table_name
+  mattr_accessor :authorization_method
+  mattr_accessor :simple_form_options
+  mattr_accessor :layout
+
+  def self.setup
+    yield self
+  end
+
+  def self.authorized?(controller, action, resource)
+    if authorization_method.respond_to?(:call) || authorization_method.kind_of?(Symbol)
+      raise Effective::AccessDenied.new() unless (controller || self).instance_exec(controller, action, resource, &authorization_method)
+    end
+    true
+  end
+
+  def self.get(slug)
+    Effective::EmailTemplate.find_by_slug(slug) || Effective::EmailTemplate.new(slug: slug)
+  end
+
+end
+

data/lib/effective_email_templates/email_view_template.rb

@@ -0,0 +1,29 @@
+module EffectiveEmailTemplates
+  class EmailViewTemplate
+    def initialize( effective_email_template )
+      @effective_email_template = effective_email_template
+    end
+
+    attr_accessor :locals
+    attr_reader :effective_email_template
+
+    def render(view, locals, buffer=nil, &block)
+      # The view object here is an anonymous view object (it has a class
+      # of Class). It has all of the view helper methods inside of it.
+      effective_email_template.render(view.assigns['to_liquid'])
+    end
+
+    def formats
+      [:html]
+    end
+
+    def identifier
+      effective_email_template.slug
+    end
+
+    def type
+      formats.first
+    end
+  end
+end
+

data/lib/effective_email_templates/engine.rb

@@ -0,0 +1,27 @@
+module EffectiveEmailTemplates
+  class Engine < ::Rails::Engine
+    engine_name 'effective_email_templates'
+
+    # Include Helpers to base application
+    initializer 'effective_email_templates.action_controller' do |app|
+      ActiveSupport.on_load :action_controller do
+        helper EffectiveEmailTemplatesHelper
+      end
+    end
+
+    # Include acts_as_email_templatable concern and allow any ActiveRecord object to call it
+    initializer 'effective_email_templates.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        # If you write a concern at all, it should be registered here
+        #ActiveRecord::Base.extend(ActsAsAddressable::ActiveRecord)
+      end
+    end
+
+    # Set up our default configuration options.
+    initializer "effective_email_templates.defaults", :before => :load_config_initializers do |app|
+      eval File.read("#{config.root}/lib/generators/templates/effective_email_templates.rb")
+    end
+
+  end
+end
+

data/lib/effective_email_templates/liquid_resolver.rb

@@ -0,0 +1,46 @@
+module EffectiveEmailTemplates
+  class LiquidResolver < ::ActionView::Resolver
+
+    attr_reader :name, :prefix
+    alias_method :slug, :name
+
+    def find_all(name, prefix=nil, partial=false, details={}, key=nil, locals=[])
+      # key is used for caching which we won't do since
+      # these templates can be updated at any time by
+      # an admin. TODO: expire the resolver's cache when
+      # a template is updated rather than skip caching
+      @name = name
+      @prefix = prefix
+
+      return [] unless liquid_mailer?
+
+      templates = collect_view_templates
+      decorate(templates, [name, prefix, partial], details, locals)
+      templates
+    end
+
+  private
+
+    # Ensures all the resolver information is set in the template.
+    def decorate(templates, path_info, details, locals)
+      templates.each do |t|
+        t.locals = locals
+      end
+    end
+
+    def collect_view_templates
+      effective_email_templates.map do |eet|
+        EmailViewTemplate.new(eet)
+      end
+    end
+
+    def effective_email_templates
+      Array.wrap(Effective::EmailTemplate.find_by_slug(slug))
+    end
+
+    def liquid_mailer?
+      prefix =~ /liquid/
+    end
+  end
+end
+

data/lib/effective_email_templates/template_importer.rb

@@ -0,0 +1,46 @@
+module EffectiveEmailTemplates
+  class TemplateImporter
+    def self.invoke(importer = new)
+      importer.invoke
+    end
+
+    def invoke
+      Dir[Rails.root.join('app', 'views', '**', '*.liquid')].each do |liquid_template_filepath|
+        slug = File.basename(liquid_template_filepath, '.liquid')
+        next if Effective::EmailTemplate.where(slug: slug).present?
+
+        template = Effective::EmailTemplate.new(slug: slug)
+
+        file = File.new(liquid_template_filepath, "r")
+        template = add_template_meta(file, template)
+        template.body = extract_template_body(file)
+        template.save
+        print_errors(template, liquid_template_filepath) unless template.valid?
+      end
+    end
+
+  private
+
+    def add_template_meta(file, template)
+      template.attributes = File.open(file) do |f|
+        attr = YAML::load(f)
+        attr.is_a?(Hash) ? attr : {}
+      end
+      template
+    end
+
+    def extract_template_body file
+      contents = file.read
+      return unless match = contents.match(/(---+(.|\n)+---+)/)
+      contents.gsub(match[1], '').strip
+    end
+
+    def print_errors(template, liquid_template_filepath)
+      puts "ERROR -- There was one or more validation errors while uploading:"
+      puts "  Email Template: #{liquid_template_filepath}"
+      template.errors.each do |attribute, error|
+        puts "  -> #{attribute} #{error}"
+      end
+    end
+  end
+end

data/lib/effective_email_templates/version.rb

@@ -0,0 +1,3 @@
+module EffectiveEmailTemplates
+  VERSION = '0.2.8'
+end

data/lib/generators/effective_email_templates/install_generator.rb

@@ -0,0 +1,32 @@
+module EffectiveEmailTemplates
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Creates an EffectiveEmailTemplates initializer in your application."
+
+      source_root File.expand_path("../../templates", __FILE__)
+
+      def self.next_migration_number(dirname)
+        if not ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def copy_initializer
+        template "effective_email_templates.rb", "config/initializers/effective_email_templates.rb"
+      end
+
+      def create_migration_file
+        @email_templates_table_name = ':' + EffectiveEmailTemplates.email_templates_table_name.to_s
+        migration_template '../../../db/migrate/01_create_effective_email_templates.rb.erb', 'db/migrate/create_effective_email_templates.rb'
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/templates/README

@@ -0,0 +1 @@
+Thanks for using EffectiveEmailTemplates

data/lib/generators/templates/effective_email_templates.rb

@@ -0,0 +1,51 @@
+EffectiveEmailTemplates.setup do |config|
+  # Database table name to store email_templates in.  Default is :email_templates
+  config.email_templates_table_name = :email_templates
+
+  # SimpleForm Options
+  # This Hash of options will be passed into any simple_form_for() calls
+  config.simple_form_options = {}
+
+  # config.simple_form_options = {
+  #   :html => {:class => 'form-horizontal'},
+  #   :wrapper => :horizontal_form,
+  #   :wrapper_mappings => {
+  #     :boolean => :horizontal_boolean,
+  #     :check_boxes => :horizontal_radio_and_checkboxes,
+  #     :radio_buttons => :horizontal_radio_and_checkboxes
+  #   }
+  # }
+
+  # Layout Settings
+  # Configure the Layout per controller, or all at once
+
+  # config.layout = 'application'   # All EffectiveEmailTemplates controllers will use this layout
+  config.layout = {
+    :email_templates => 'application',
+    :admin_email_templates => 'application'
+  }
+
+
+  # Authorization Method
+  #
+  # This method is called by all controller actions with the appropriate action and resource
+  # If the method returns false, an Effective::AccessDenied Error will be raised (see README.md for complete info)
+  #
+  # Use via Proc (and with CanCan):
+  # config.authorization_method = Proc.new { |controller, action, resource| can?(action, resource) }
+  #
+  # Use via custom method:
+  # config.authorization_method = :my_authorization_method
+  #
+  # And then in your application_controller.rb:
+  #
+  # def my_authorization_method(action, resource)
+  #   current_user.is?(:admin)
+  # end
+  #
+  # Or disable the check completely:
+  # config.authorization_method = false
+  config.authorization_method = Proc.new { |controller, action, resource| can?(action, resource) } # CanCan gem
+
+
+end

data/lib/tasks/effective_email_templates/import_default_views.rake

@@ -0,0 +1,5 @@
+namespace :effective_email_templates do
+  task :import_default_views => :environment do
+    EffectiveEmailTemplates::TemplateImporter.invoke
+  end
+end

data/spec/controllers/admin/email_templates_controller_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Admin::EmailTemplatesController do
+  context "as an admin" do
+    before :each do
+      @admin = create(:admin)
+      sign_in @admin
+    end
+
+    describe "#index" do
+      it 'opens' do
+        get :index, :use_route => :effective_email_templates
+        expect(response.status).to eq 200
+      end
+    end
+
+    describe "#new" do
+      it 'opens' do
+        get :new, :use_route => :effective_email_templates
+        expect(response.status).to eq 200
+      end
+    end
+
+    describe "#create" do
+      it 'creates an email template' do
+        expect{
+          post :create, effective_email_template: attributes_for(:email_template), :use_route => :effective_email_templates
+        }.to change(Effective::EmailTemplate,:count).by(1)
+      end
+    end
+
+    context "member actions" do
+      before :each do
+        @email_template = create(:email_template)
+      end
+
+      describe "#edit" do
+        it 'opens' do
+          get :edit, :id => @email_template.id, :use_route => :effective_email_templates
+          expect(response.status).to eq 200
+        end
+      end
+
+      describe "#update" do
+        it 'updates an email template' do
+          attributes = @email_template.attributes
+          old_from = @email_template.from
+          new_from = "gfssljewr@dsfa.com"
+          attributes["from"] = new_from
+          expect{
+            patch :update, id: @email_template.id, effective_email_template: attributes, :use_route => :effective_email_templates
+            @email_template.reload
+          }.to change(@email_template,:from)
+        end
+      end
+    end
+
+  end
+end
+

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.