effective_email_templates 0.6.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c60f871f30ff1ce2c6f2adbccc31e906b8d19fba696bbd456f1e8f9b17064215
-  data.tar.gz: d41c1d401f35199b7ec8b80046cade8a364611cd1771bf1e62976fc2a4c27ac7
+  metadata.gz: a7ceefc31750874cc34b906a00ce64e80ee805bdf247cb69ec33d080e3625e28
+  data.tar.gz: ba54f4fc199b22bb8aed8b01d60f7b71ddfec735b6be56fc37d1cee9853f9a3f
 SHA512:
-  metadata.gz: 7466896b837db170f1305d889542b2faa441b39cbe7f511d1845f2a3cff8a0520469f542a13dd76baaf98fcfe85efb927d571e65f851bfa86fca07e5409d23cf
-  data.tar.gz: b536c744a107741e773831552e9beb548cc064bb4fe7e07193deef4e16c3d897743ac7d79b4fc143ea78ebc41483b8f4adb5d9ee5d1943b1fb3ea0ff038bfb3b
+  metadata.gz: e24eb4a7e1fa925844d45de25fab8a7bb9b6b3f4fc631c13ba4418a43e9bb304b6be6e1e7eb16c5396d097d8cb5ac910040464af9e1a7bb2aba5122b40f92c61
+  data.tar.gz: fc6b6f48a42448af82136497ab39ec26a28c9ef60e1db3ef45b42dac8c7c0d7d0d093005e40f6b246e5e671a63a275e8f32ccce34520a6281fd4ff80c821768e

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2014 Code and Effect Inc.
+Copyright 2020 Code and Effect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,20 +1,17 @@
 
 # Effective Email Templates
 
-**This gem is no longer actively maintained**
+Create email templates that an admin can edit and then send.
 
-Create email templates that an admin or any user can safely edit (you're protected from SQL injection and other nastiness).
-Effective Email Templates relies on [Liquid templates](http://liquidmarkup.org/) built by Shopify to profide this safety.
+Rails 3.2.x and higher
 
-Rails 3.2.x and Rails 4 Support
+## effective_email_templates 1.0
 
-## Bootstrap3
+This is the 1.0 series of effective_email_templates.
 
-This is the `bootstrap3` branch of effective_email_templates which supports Twitter Bootstrap 3.
+This requires Twitter Bootstrap 4.
 
-All published effective_email_templates 0.x gems will support Twitter Bootstrap 3 and SimpleForm.
-
-For Bootstrap 4 please see the master branch and/or effective_email_templates 1.x gems.
+Please check out [Effective Email Templates 0.x](https://github.com/code-and-effect/effective_email_templates/tree/bootstrap3) for more information using this gem with Bootstrap 3.
 
 
 ## Getting Started
@@ -22,7 +19,7 @@ For Bootstrap 4 please see the master branch and/or effective_email_templates 1.
 Add to your Gemfile:
 
 ```ruby
-gem 'effective_email_templates', :git => 'https://github.com/code-and-effect/effective_email_templates'
+gem 'effective_email_templates'
 ```
 
 Run the bundle command to install it:
@@ -47,10 +44,11 @@ Then migrate the database:
 rake db:migrate
 ```
 
+## Create Email Templates
 
-## Creating Email Templates
+`link_to 'Email Templates', effective_email_templates.admin_email_templates_path`
 
-This is very similar to creating other emails in Rails.
+To create your first post, visit `/admin/email_templates` and click `New Email Template`.
 
 1. Create a new mailer object (i.e. `/app/mailers/template_mailer.rb`)
     - Mailer objects need to inherit from `Effective::LiquidMailer`
@@ -119,15 +117,15 @@ mail.deliver
 
 ## Authorization
 
-All authorization checks are handled via the config.authorization_method found in the config/initializers/ file.
+All authorization checks are handled via the config.authorization_method found in the `app/config/initializers/effective_email_templates.rb` file.
 
-It is intended for flow through to CanCan or Pundit, but that is not required.
+It is intended for flow through to CanCan or Pundit, but neither of those gems are required.
 
 This method is called by all controller actions with the appropriate action and resource
 
 Action will be one of [:index, :show, :new, :create, :edit, :update, :destroy]
 
-Resource will the appropriate Effective::Something ActiveRecord object or class
+Resource will the appropriate Effective::EmailTemplate object or class
 
 The authorization method is defined in the initializer file:
 
@@ -173,32 +171,20 @@ end
 To allow a user to see the admin area, using CanCan:
 
 ```ruby
+can :manage, Effective::EmailTemplate
 can :admin, :effective_email_templates
 ```
 
-
 ## License
 
-MIT License.  Copyright Code and Effect Inc. http://www.codeandeffect.com
-
-You are not granted rights or licenses to the trademarks of Code and Effect
-
-## TODO
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
 
-- minimize gem dependencies
-- remove unused non-admin routes and config option
-- Add an admin alert if there are mailer methods that do not have associated email templates
-- Show admin what the available arguments are for each template
-- remove `caller` usage from Effective::LiquidMailer (or remove requirement for Ruby 2.0+)
-- add `EffectiveEmailTemplates::present?` to check if a template model is present
-  - notify the app but don't raise an error if template is not present when an email is sent
-- configurable default from address
-- configurable prefix for subject line
-- use autoload rather than require
-- research panoramic gem's usage of the Resolver class and improve our Resolver usage
-- enable multipart emails
-- enable file attachments
-- import factories/fixtures in install task
 
-## Testing
+## Contributing
 
+1. Fork it
+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. Bonus points for test coverage
+6. Create new Pull Request

data/app/controllers/admin/email_templates_controller.rb

@@ -1,16 +1,11 @@
 module Admin
   class EmailTemplatesController < ApplicationController
-    before_action :authenticate_user!   # This is devise, ensure we're logged in.
+    before_action :authenticate_user! if respond_to?(:authenticate_user!)
 
     layout (EffectiveEmailTemplates.layout.kind_of?(Hash) ? EffectiveEmailTemplates.layout[:admin_email_templates] : EffectiveEmailTemplates.layout)
 
     def index
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        @datatable = Effective::Datatables::EmailTemplates.new()
-      else
-        @datatable = EffectiveEmailTemplatesDatatable.new(self)
-      end
-
+      @datatable = EffectiveEmailTemplatesDatatable.new
       @page_title = 'Email Templates'
 
       authorize_effective_email_templates!
@@ -30,10 +25,10 @@ module Admin
       authorize_effective_email_templates!
 
       if @email_template.save
-        flash[:success] = "Email template created successfully"
+        flash[:success] = 'Successfully created email template'
         redirect_to effective_email_templates.admin_email_templates_path
       else
-        flash.now[:error] = "Could not create email template"
+        flash.now[:danger] = 'Unable to create email template'
         render :new
       end
     end
@@ -52,23 +47,37 @@ module Admin
       authorize_effective_email_templates!
 
       if @email_template.update(email_template_params)
-        flash[:success] = "Email template updated successfully"
+        flash[:success] = 'Successfully updated email template'
         redirect_to effective_email_templates.admin_email_templates_path
       else
-        flash.now[:error] = "Could not update email template"
+        flash.now[:danger] = 'Unable to update email template'
         render :edit
       end
     end
 
-    private
+    def destroy
+      @email_template = Effective::EmailTemplate.find(params[:id])
 
-    def email_template_params
-      params.require(:effective_email_template).permit([ :from, :cc, :bcc, :subject, :body ])
+      authorize_effective_email_templates!
+
+      if @email_template.destroy
+        flash[:success] = 'Successfully deleted email template'
+      else
+        flash[:danger] = 'Unable to delete email template'
+      end
+
+      redirect_to effective_email_templates.admin_email_templates_path
     end
 
+    private
+
     def authorize_effective_email_templates!
-      EffectiveEmailTemplates.authorized?(self, :admin, :effective_email_templates)
-      EffectiveEmailTemplates.authorized?(self, action_name.to_sym, @email_template || Effective::EmailTemplate)
+      EffectiveEmailTemplates.authorize!(self, :admin, :effective_email_templates)
+      EffectiveEmailTemplates.authorize!(self, action_name.to_sym, @email_template || Effective::EmailTemplate)
+    end
+
+    def email_template_params
+      params.require(:effective_email_template).permit(EffectiveEmailTemplates.permitted_params)
     end
 
   end

data/app/datatables/effective_email_templates_datatable.rb

@@ -1,14 +1,18 @@
 class EffectiveEmailTemplatesDatatable < Effective::Datatable
   datatable do
     order :subject, :asc
+    length :all
 
+    col :updated_at, visible: false
+    col :created_at, visible: false
     col :id, visible: false
-    col :slug
-    col :subject
+
+    col :template_name, label: 'Name'
     col :from
-    col :cc, visible: false, label: 'CC'
-    col :bcc, visible: false, label: 'BCC'
-    col :body, visible: false
+    col :cc
+    col :bcc
+    col :subject
+    col :body
 
     actions_col partial: '/admin/email_templates/actions', partial_as: 'email_template'
   end
@@ -17,3 +21,4 @@ class EffectiveEmailTemplatesDatatable < Effective::Datatable
     Effective::EmailTemplate.all
   end
 end
+

data/app/mailers/effective/email_templates_mailer.rb

@@ -0,0 +1,22 @@
+module Effective
+  class EmailTemplatesMailer < ::ActionMailer::Base
+
+    def mail(headers = {}, &block)
+      email_template = Effective::EmailTemplate.where(template_name: action_name).first!
+
+      assigns = route_url_assigns(email_template).merge(@assigns || {})
+      rendered = email_template.render(assigns)
+
+      super(rendered.merge(headers))
+    end
+
+    private
+
+    def route_url_assigns(email_template)
+      email_template.template_variables.select { |name| name.ends_with?('_url') }.inject({}) do |h, name|
+        h[name] = public_send(name) if respond_to?(name); h
+      end
+    end
+
+  end
+end

data/app/models/effective/email_template.rb

@@ -1,55 +1,87 @@
-require 'liquid'
-Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-
 module Effective
   class EmailTemplate < ActiveRecord::Base
-
     self.table_name = EffectiveEmailTemplates.email_templates_table_name.to_s
 
-    serialize :template, Liquid::Template
+    CONTENT_TYPES = ['text/plain', 'text/html']
 
-    validate :slug_needs_to_have_simple_format
-    validates :slug,      presence: true, uniqueness: true
-    validates :body,      presence: true
-    validates :subject,   presence: true
-    validates :from,      presence: true
-    validates :template,  presence: true
+    serialize :template_body, Liquid::Template
+    serialize :template_subject, Liquid::Template
+    serialize :template_variables, Array
 
-    before_validation :try_precompile
+    # Attributes
+    # subject           :string
+    # from              :string
+    # cc                :string
+    # bcc               :string
+    # body              :text
+    # content_type      :string
+    #
+    # template_name       :string
+    # template_body       :text
+    # template_subject    :text
+    # template_variables  :text
+    #
+    # timestamps
 
-    def precompile
+    before_validation do
+      self.template_name ||= subject.to_s.parameterize
+      self.content_type ||= CONTENT_TYPES.first
+    end
+
+    before_validation(if: -> { body.present? }) do
       begin
-        self.template = Liquid::Template.parse( body )
-      rescue Liquid::SyntaxError => error
-        errors.add :template, error.message
+        self.template_body = Liquid::Template.parse(body)
+      rescue Liquid::SyntaxError => e
+        errors.add(:body, e.message)
       end
     end
 
-    def mail_options
-      {
-        from: from,
-        subject: subject,
-        cc: cc,
-        bcc: bcc
-      }.delete_if { |_, v| v.blank? }
+    before_validation(if: -> { subject.present? }) do
+      begin
+        self.template_subject = Liquid::Template.parse(subject)
+      rescue Liquid::SyntaxError => e
+        errors.add(:subject, e.message)
+      end
     end
 
-    def render( *args )
-      template.render( *args )
+    validates :subject, presence: true
+    validates :from, presence: true
+    validates :body, presence: true
+    validates :content_type, presence: true, inclusion: { in: CONTENT_TYPES }
+
+    validates :template_name, presence: true
+    validates :template_body, presence: true
+    validates :template_subject, presence: true
+
+    before_save do
+      self.template_variables = find_template_variables
     end
 
-  private
+    def to_s
+      template_name.presence || 'New Email Template'
+    end
 
-    def try_precompile
-      precompile if body_changed?
+    def render(assigns = {})
+      {
+        from: from,
+        cc: cc.presence || false,
+        bcc: bcc.presence || false,
+        content_type: content_type,
+        subject: template_subject.render(assigns),
+        body: template_body.render(assigns)
+      }
     end
 
-    def slug_needs_to_have_simple_format
-      # convert slug to symbol
-      # add error if symbol has non-simple format (i.e. `:"symbol with spaces"` vs `:symbol_with_underscores`)
-      if /[@$"]/ =~ slug.to_sym.inspect || slug.match(/[A-Z]/)
-        errors.add(:slug, 'must have a simple format with no spaces, capital letters, and most punctuation (good: "hello_world", bad: "hello, world")')
-      end
+    private
+
+    def find_template_variables
+      [template_body.presence, template_subject.presence].compact.map do |template|
+        Liquid::ParseTreeVisitor.for(template.root).add_callback_for(Liquid::VariableLookup) do |node|
+          [node.name, *node.lookups].join('.')
+        end.visit
+      end.flatten.uniq.compact
     end
+
   end
+
 end

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

@@ -1,2 +1,5 @@
-%span{:style => 'white-space: nowrap;'}
-  = link_to 'Edit', effective_email_templates.edit_admin_email_template_path(email_template)
+= dropdown(variation: :dropleft) do
+  = dropdown_link_to 'Edit', effective_email_templates.edit_admin_email_template_path(email_template)
+
+  = dropdown_link_to "Delete #{email_template}", effective_email_templates.admin_email_template_path(email_template),
+    data: { method: :delete, confirm: "Really delete #{email_template}?" }

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

@@ -1,9 +1,16 @@
-= 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
+= effective_form_with(model: email_template, url: email_template.persisted? ? effective_email_templates.admin_email_template_path(email_template.id) : effective_email_templates.admin_email_templates_path) do |f|
+  - if f.object.persisted?
+    = f.static_field :template_name, label: 'Name'
+
+  = f.text_field :subject, hint: 'The subject of your email.'
+
+  = f.email_field :from, hint: 'Whom the email will be sent from.'
+
+  = f.text_field :cc
+  = f.text_field :bcc
+
+  = f.select :content_type, Effective::EmailTemplate::CONTENT_TYPES
+
+  = f.text_area :body, hint: 'The content of your email template'
+
+  = f.submit

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

@@ -1,3 +1,3 @@
 %h1.effective-admin-heading= @page_title
 
-= render_datatable(@datatable)
+= render_datatable @datatable

data/app/views/layouts/effective_email_templates_mailer_layout.html.haml

@@ -0,0 +1,7 @@
+!!!
+%html{style: 'background: #fff;'}
+  %head
+    %meta{:content => 'text/html; charset=UTF-8', 'http-equiv' => 'Content-Type'}
+
+  %body{style: 'background: #fff;'}
+    = yield

data/config/effective_email_templates.rb

@@ -1,31 +1,7 @@
 EffectiveEmailTemplates.setup do |config|
-  # Database table name to store email_templates in.  Default is :email_templates
+  # Configure Database Tables
   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
@@ -47,5 +23,20 @@ EffectiveEmailTemplates.setup do |config|
   # config.authorization_method = false
   config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) } # CanCanCan
 
+  # 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: 'admin'
+  }
+
+  # Mailer Settings
+  config.mailer = {
+    subject_prefix: '[example] ',
+    layout: 'effective_email_templates_mailer_layout',
+    deliver_method: nil   # :deliver (rails < 4.2), :deliver_now (rails >= 4.2) or :deliver_later
+  }
 
 end

data/config/routes.rb

@@ -1,11 +1,9 @@
-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
+  namespace :admin do
+    resources :email_templates
   end
 end
+
+Rails.application.routes.draw do
+  mount EffectiveEmailTemplates::Engine => '/', as: 'effective_email_templates'
+end

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

@@ -1,16 +1,22 @@
 class CreateEffectiveEmailTemplates < ActiveRecord::Migration[4.2]
   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
+      t.string    :subject
+      t.string    :from
+      t.string    :bcc
+      t.string    :cc
+
+      t.string    :content_type
+      t.text      :body
+
+      t.string    :template_name
+      t.text      :template_body
+      t.text      :template_subject
+      t.text      :template_variables
+
+      t.timestamps
     end
 
-    add_index <%= @email_templates_table_name %>, :slug
   end
 
   def self.down

data/lib/effective_email_templates/engine.rb

@@ -3,7 +3,7 @@ module EffectiveEmailTemplates
     engine_name 'effective_email_templates'
 
     # Set up our default configuration options.
-    initializer "effective_email_templates.defaults", :before => :load_config_initializers do |app|
+    initializer 'effective_email_templates.defaults', before: :load_config_initializers do |app|
       eval File.read("#{config.root}/config/effective_email_templates.rb")
     end
 

data/lib/effective_email_templates/importer.rb

@@ -0,0 +1,55 @@
+module EffectiveEmailTemplates
+  class Importer
+    def self.import
+      new().execute(overwrite: false)
+    end
+
+    def self.overwrite
+      new().execute(overwrite: true)
+    end
+
+    def execute(overwrite:)
+      Dir[Rails.root.join('app', 'views', '**', '*.liquid')].each do |filepath|
+        name = File.basename(filepath, '.liquid')
+        email_template = Effective::EmailTemplate.find_or_initialize_by(template_name: name)
+
+        if email_template.persisted? && !overwrite
+          puts "SKIPPED #{filename(filepath)}"; next
+        end
+
+        save(email_template, filepath)
+      end
+    end
+
+    private
+
+    def save(email_template, filepath)
+      file = File.new(filepath, 'r')
+
+      attributes = begin
+        content = YAML.load(file)
+        content.kind_of?(Hash) ? content : {}
+      end
+
+      body = File.open(file) do |f|
+        content = f.read
+        match = content.match(/(---+(.|\n)+---+)/)
+        content.gsub(match[1], '').strip if match
+      end
+
+      email_template.assign_attributes(attributes)
+      email_template.assign_attributes(body: body)
+
+      if email_template.save
+        puts "SUCCESS #{filename(filepath)}"
+      else
+        puts "ERROR #{filename(filepath)}: #{email_template.errors.full_messages.to_sentence}"
+      end
+    end
+
+    def filename(filepath)
+      filepath.sub(Rails.root.to_s + '/app/', '')
+    end
+
+  end
+end

data/lib/effective_email_templates/version.rb

@@ -1,3 +1,3 @@
 module EffectiveEmailTemplates
-  VERSION = '0.6.1'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/effective_email_templates.rb

@@ -1,33 +1,37 @@
-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 "liquid"
 require "effective_email_templates/engine"
-
-require "effective/liquid_mailer"
-Effective::LiquidMailer.send(:append_view_path, EffectiveEmailTemplates::LiquidResolver.new)
+require "effective_email_templates/version"
 
 module EffectiveEmailTemplates
 
   mattr_accessor :email_templates_table_name
   mattr_accessor :authorization_method
-  mattr_accessor :simple_form_options
   mattr_accessor :layout
+  mattr_accessor :mailer
 
   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)
+    @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
+
+    return !!authorization_method unless authorization_method.respond_to?(:call)
+    controller = controller.controller if controller.respond_to?(:controller)
+
+    begin
+      !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
+    rescue *@_exceptions
+      false
     end
-    true
   end
 
-  def self.get(slug)
-    Effective::EmailTemplate.find_by_slug(slug) || Effective::EmailTemplate.new(slug: slug)
+  def self.authorize!(controller, action, resource)
+    raise Effective::AccessDenied.new('Access Denied', action, resource) unless authorized?(controller, action, resource)
   end
 
-end
+  def self.permitted_params
+    [:from, :bcc, :cc, :subject, :body, :content_type]
+  end
 
+end