sendgrid-ruby 1.1.6 → 6.6.2

data/lib/sendgrid/mail.rb

@@ -1,182 +0,0 @@
-require 'json'
-require 'smtpapi'
-require 'mimemagic'
-
-module SendGrid
-  class Mail
-    attr_accessor :to, :to_name, :from, :from_name, :subject, :text, :html, :cc, :cc_name,
-                  :bcc, :bcc_name, :reply_to, :date, :smtpapi, :attachments, :content, :template
-
-    def initialize(params = {})
-      params.each do |k, v|
-        send(:"#{k}=", v) unless v.nil?
-      end
-
-      yield self if block_given?
-    end
-
-    def add_to(email, name = nil)
-      if email.is_a?(Array)
-        to.concat(email)
-      else
-        to << email
-      end
-      add_to_name(name) if name
-    end
-
-    def to
-      @to ||= []
-    end
-
-    def to_name
-      @to_name ||= []
-    end
-
-    def add_to_name(name)
-      if name.is_a?(Array)
-        to_name.concat(name)
-      else
-        to_name << name
-      end
-    end
-
-    def cc
-      @cc ||= []
-    end
-
-    def cc_name
-      @cc_name ||= []
-    end
-
-    def add_cc(email, name = nil)
-      if email.is_a?(Array)
-        cc.concat(email)
-      else
-        cc << email
-      end
-      add_cc_name(name) if name
-    end
-
-    def add_cc_name(name)
-      if name.is_a?(Array)
-        cc_name.concat(name)
-      else
-        cc_name << name
-      end
-    end
-
-    def bcc
-      @bcc ||= []
-    end
-
-    def bcc_name
-      @bcc_name ||= []
-    end
-
-    def add_bcc(email, name = nil)
-      if email.is_a?(Array)
-        bcc.concat(email)
-      else
-        bcc << email
-      end
-      add_bcc_name(name) if name
-    end
-
-    def add_bcc_name(name)
-      if name.is_a?(Array)
-        bcc_name.concat(name)
-      else
-        bcc_name << name
-      end
-    end
-
-    def add_attachment(path, name = nil)
-      mime_type = MimeMagic.by_path(path)
-      file = Faraday::UploadIO.new(path, mime_type)
-      name ||= File.basename(file)
-      attachments << {file: file, name: name}
-    end
-
-    def headers
-      @headers ||= {}
-    end
-
-    def attachments
-      @attachments ||= []
-    end
-
-    def contents
-      @contents ||= []
-    end
-
-    def add_content(path, cid)
-      mime_type = MimeMagic.by_path(path)
-      file = Faraday::UploadIO.new(path, mime_type)
-      name ||= File.basename(file)
-      contents << {file: file, cid: cid, name: name}
-    end
-
-    def smtpapi
-      @smtpapi ||= Smtpapi::Header.new
-    end
-
-    def smtpapi_json
-      if !template.nil? && template.is_a?(Template)
-        template.add_to_smtpapi(smtpapi)
-      end
-
-      smtpapi.to_json
-    end
-
-    # rubocop:disable Style/HashSyntax
-    def to_h
-      payload = {
-        :from => from,
-        :fromname => from_name,
-        :subject => subject,
-        :to => to,
-        :toname => to_name,
-        :date => date,
-        :replyto => reply_to,
-        :cc => cc,
-        :ccname => cc_name,
-        :bcc => bcc,
-        :bccname => bcc_name,
-        :text => text,
-        :html => html,
-        :'x-smtpapi' => smtpapi_json,
-        :content => ({":default"=>"0"} unless contents.empty?),
-        :files => ({":default"=>"0"} unless attachments.empty? and contents.empty?)
-        # If I don't define a default value, I get a Nil error when
-        # in attachments.each do |file|
-        #:files => ({} unless attachments.empty?)
-      }.reject {|_, v| v.nil? || v.empty?}
-
-      payload.delete(:'x-smtpapi') if payload[:'x-smtpapi'] == '{}'
-
-      payload[:to] = payload[:from] if payload[:to].nil? and not smtpapi.to.empty?
-
-      unless attachments.empty?
-        attachments.each do |file|
-          payload[:files][file[:name]] = file[:file]
-        end
-        if payload[:files].has_key?(":default")
-          payload[:files].delete(":default")
-        end
-      end
-
-      unless contents.empty?
-        contents.each do |content|
-          payload[:content][content[:name]] = content[:cid]
-          payload[:files][content[:name]] = content[:file]
-        end
-        if payload[:content].has_key?(":default")
-          payload[:content].delete(":default")
-        end
-      end
-
-      payload
-    end
-    # rubocop:enable Style/HashSyntax
-  end
-end

data/lib/sendgrid/recipient.rb

@@ -1,29 +0,0 @@
-require 'smtpapi'
-
-module SendGrid
-  class Recipient
-    class NoAddress < StandardError; end
-
-    attr_reader :address, :substitutions
-
-    def initialize(address)
-      @address = address
-      @substitutions = {}
-
-      raise NoAddress, 'Recipient address cannot be nil' if @address.nil?
-    end
-
-    def add_substitution(key, value)
-      substitutions[key] = value
-    end
-
-    def add_to_smtpapi(smtpapi)
-      smtpapi.add_to(@address)
-
-      @substitutions.each do |key, value|
-        existing = smtpapi.sub[key] || []
-        smtpapi.add_substitution(key, existing + [value])
-      end
-    end
-  end
-end

data/lib/sendgrid/response.rb

@@ -1,14 +0,0 @@
-require 'json'
-
-module SendGrid
-  class Response
-    attr_reader :code, :headers, :body, :raw_body
-
-    def initialize(params)
-      @code = params[:code]
-      @headers = params[:headers]
-      @body = JSON.parse(params[:body])
-      @raw_body = params[:body]
-    end
-  end
-end

data/lib/sendgrid/template.rb

@@ -1,26 +0,0 @@
-require 'smtpapi'
-
-module SendGrid
-  class Template
-    attr_reader :id, :recipients
-
-    def initialize(id)
-      @id = id
-      @recipients = []
-    end
-
-    def add_recipient(recipient)
-      recipients << recipient
-    end
-
-    def add_to_smtpapi(smtpapi)
-      return if smtpapi.nil?
-
-      smtpapi.tap do |api|
-        api.add_filter(:templates, :enable, 1)
-        api.add_filter(:templates, :template_id, id)
-        recipients.each { |r| r.add_to_smtpapi(smtpapi) }
-      end
-    end
-  end
-end

data/lib/sendgrid/template_mailer.rb

@@ -1,59 +0,0 @@
-module SendGrid
-  class InvalidClient < StandardError; end
-  class InvalidTemplate < StandardError; end
-  class InvalidRecipients < StandardError; end
-
-  class TemplateMailer
-
-    # This class is responsible for coordinating the responsibilities
-    #  of various models in the gem.
-    # It makes use of the Recipient, Template and Mail models to create
-    #  a single work flow, an example might look like:
-    #
-    # users = User.where(email: ['first@gmail.com', 'second@gmail.com'])
-    #
-    # recipients = []
-    #
-    # users.each do |user|
-    #   recipient = SendGrid::Recipient.new(user.email)
-    #   recipient.add_substitution('first_name', user.first_name)
-    #   recipient.add_substitution('city', user.city)
-    #
-    #   recipients << recipient
-    # end
-    #
-    # template = SendGrid::Template.new('MY_TEMPLATE_ID')
-    #
-    # client = SendGrid::Client.new(api_user: my_user, api_key: my_key)
-    #
-    # mail_defaults = {
-    #   from: 'admin@email.com',
-    #   html: '<h1>I like email</h1>',
-    #   text: 'I like email',
-    #   subject: 'Email is great',
-    # }
-    #
-    # mailer = SendGrid::TemplateMailer.new(client, template, recipients)
-    # mailer.mail(mail_defaults)
-    def initialize(client, template, recipients = [])
-      @client = client
-      @template = template
-      @recipients = recipients
-
-      raise InvalidClient, 'Client must be present' if @client.nil?
-      raise InvalidTemplate, 'Template must be present' if @template.nil?
-      raise InvalidRecipients, 'Recipients may not be empty' if @recipients.empty?
-
-      @recipients.each do |recipient|
-        @template.add_recipient(recipient)
-      end
-    end
-
-    def mail(params = {})
-      mail = Mail.new(params)
-
-      mail.template = @template
-      @client.send(mail.to_h)
-    end
-  end
-end

data/spec/lib/sendgrid/client_spec.rb

@@ -1,87 +0,0 @@
-require 'json'
-require 'spec_helper'
-require 'webmock/rspec'
-
-describe 'SendGrid::Client' do
-  it 'should accept a username and password' do
-    expect(SendGrid::Client.new(api_user: 'test', api_key: 'test')).to be_an_instance_of(SendGrid::Client)
-  end
-
-  it 'should accept an api key' do
-    expect(SendGrid::Client.new(api_key: 'sendgrid_123')).to be_an_instance_of(SendGrid::Client)
-  end
-
-  it 'should build the default url' do
-    expect(SendGrid::Client.new.url).to eq('https://api.sendgrid.com')
-  end
-
-  it 'should build a custom url' do
-    expect(SendGrid::Client.new(port: 3000, host: 'foo.sendgrid.com', protocol: 'tacos').url).to eq('tacos://foo.sendgrid.com:3000')
-  end
-
-  it 'should use the default endpoint' do
-    expect(SendGrid::Client.new.endpoint).to eq('/api/mail.send.json')
-  end
-
-  it 'accepts a block' do
-    expect { |b| SendGrid::Client.new(&b) }.to yield_control
-  end
-
-  describe ':send' do
-    it 'should make a request to sendgrid' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'success'}.to_json, status: 200, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_key: 'abc123')
-      mail = SendGrid::Mail.new
-      res = client.send(mail)
-      expect(res.code).to eq(200)
-    end
-
-    it 'should have an auth header when using an api key' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'success'}.to_json, status: 200, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_key: 'abc123')
-      mail = SendGrid::Mail.new
-
-      client.send(mail)
-
-      expect(WebMock).to have_requested(:post, 'https://api.sendgrid.com/api/mail.send.json')
-        .with(headers: {'Authorization' => 'Bearer abc123'})
-    end
-
-    it 'should have a username + password when using them' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'success'}.to_json, status: 200, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_user: 'foobar', api_key: 'abc123')
-      mail = SendGrid::Mail.new
-
-      res = client.send(mail)
-
-      expect(WebMock).to have_requested(:post, 'https://api.sendgrid.com/api/mail.send.json')
-        .with(body: 'api_key=abc123&api_user=foobar')
-    end
-
-    it 'should raise a SendGrid::Exception if status is not 200' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'error', errors: ['Bad username / password']}.to_json, status: 400, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_user: 'foobar', api_key: 'abc123')
-      mail = SendGrid::Mail.new
-
-      expect {client.send(mail)}.to raise_error(SendGrid::Exception)
-    end
-
-    it 'should not raise a SendGrid::Exception if raise_exceptions is disabled' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'error', errors: ['Bad username / password']}.to_json, status: 400, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_user: 'foobar', api_key: 'abc123', raise_exceptions: false)
-      mail = SendGrid::Mail.new
-
-      expect {client.send(mail)}.not_to raise_error
-    end
-  end
-end

data/spec/lib/sendgrid/mail_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-describe 'SendGrid::Mail' do
-  before(:each) do
-    @mail = SendGrid::Mail.new
-  end
-
-  it 'should create an instance' do
-    expect(SendGrid::Mail.new).to be_an_instance_of(SendGrid::Mail)
-  end
-
-  describe 'add_to_name' do
-    it 'should accept a name' do
-      @mail.add_to_name('Frank Foo')
-      expect(@mail.to_name).to eq(['Frank Foo'])
-    end
-
-    it 'should accept an array of names' do
-      @mail.add_to_name(['Frank Foo', 'Bob Bar'])
-      expect(@mail.to_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'add_to' do
-    it 'should accept an email' do
-      @mail.add_to('foo@example.com')
-      expect(@mail.to).to eq(['foo@example.com'])
-
-      @mail.add_to('bar@example.com')
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an email and name' do
-      @mail.add_to('foo@example.com', 'Frank Foo')
-      expect(@mail.to).to eq(['foo@example.com'])
-      expect(@mail.to_name).to eq(['Frank Foo'])
-
-      @mail.add_to('bar@example.com', 'Bob Bar')
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.to_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-
-    it 'should accept an array of emails' do
-      @mail.add_to(['foo@example.com', 'bar@example.com'])
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an array of emails and names' do
-      @mail.add_to(['foo@example.com', 'bar@example.com'], ['Frank Foo', 'Bob Bar'])
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.to_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'add_cc' do
-    it 'should accept an email' do
-      @mail.add_cc('foo@example.com')
-      expect(@mail.cc).to eq(['foo@example.com'])
-    end
-
-    it 'should accept an email and a name' do
-      @mail.add_cc('foo@example.com', 'Frank Foo')
-      expect(@mail.cc).to eq(['foo@example.com'])
-      expect(@mail.cc_name).to eq(['Frank Foo'])
-    end
-
-    it 'should accept an array of emails' do
-      @mail.add_cc(['foo@example.com', 'bar@example.com'])
-      expect(@mail.cc).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an array of emails and names' do
-      @mail.add_cc(['foo@example.com', 'bar@example.com'], ['Frank Foo', 'Bob Bar'])
-      expect(@mail.cc).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.cc_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'add_bcc' do
-    it 'should accept an email' do
-      @mail.add_bcc('foo@example.com')
-      expect(@mail.bcc).to eq(['foo@example.com'])
-    end
-
-    it 'should accept an email and a name' do
-      @mail.add_bcc('foo@example.com', 'Frank Foo')
-      expect(@mail.bcc).to eq(['foo@example.com'])
-      expect(@mail.bcc_name).to eq(['Frank Foo'])
-    end
-
-    it 'should accept an array of emails' do
-      @mail.add_bcc(['foo@example.com', 'bar@example.com'])
-      expect(@mail.bcc).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an array of emails and names' do
-      @mail.add_bcc(['foo@example.com', 'bar@example.com'], ['Frank Foo', 'Bob Bar'])
-      expect(@mail.bcc).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.bcc_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'to' do
-    it 'should be set' do
-      @mail.to = 'foo@example.com'
-      expect(@mail.to).to eq('foo@example.com')
-    end
-  end
-
-  describe 'from_name' do
-    it 'should be set' do
-      @mail.from_name = 'Frank Foo'
-      expect(@mail.from_name).to eq('Frank Foo')
-    end
-  end
-
-  describe 'reply_to' do
-    it 'should be set' do
-      @mail.reply_to = 'foo@example.com'
-      expect(@mail.reply_to).to eq('foo@example.com')
-    end
-  end
-
-  describe 'smtpapi_json' do
-    before do
-      @mail.template = template
-    end
-
-    context 'a template has been set' do
-      let(:template) { SendGrid::Template.new(anything) }
-
-      it 'adds the template to the smtpapi header' do
-        expect(@mail.template).to receive(:add_to_smtpapi).with(@mail.smtpapi)
-        expect(@mail.smtpapi).to receive(:to_json)
-
-        @mail.to_h
-      end
-    end
-
-    context 'no template has been set' do
-      let(:template) { nil }
-
-      it 'does not add anything to the smtpapi header' do
-        expect_any_instance_of(SendGrid::Template).to_not receive(:add_to_smtpapi)
-        expect(@mail.smtpapi).to receive(:to_json)
-
-        @mail.to_h
-      end
-    end
-  end
-end

data/spec/lib/sendgrid/recipient_spec.rb

@@ -1,91 +0,0 @@
-require_relative '../../../lib/sendgrid/recipient'
-
-module SendGrid
-  describe Recipient do
-    subject { described_class.new(anything) }
-
-    describe '#initialize' do
-      it 'sets the address instance var' do
-        expect(subject.instance_variable_get(:@address)).to_not be_nil
-      end
-
-      it 'sets substitutions to an empty hash' do
-        expect(subject.instance_variable_get(:@substitutions)).to eq({})
-      end
-
-      context 'initialized with nil' do
-        it 'raises an error' do
-          expect do
-            described_class.new(nil)
-          end.to raise_error(Recipient::NoAddress, 'Recipient address cannot be nil')
-        end
-      end
-    end
-
-    describe '#add_substitution' do
-      it 'adds the key and value to the substitutions hash' do
-        subject.add_substitution(:foo, :bar)
-        expect(subject.substitutions).to have_key(:foo)
-        expect(subject.substitutions[:foo]).to eq(:bar)
-      end
-
-      context 'the same substiution key already exists' do
-        before do
-          subject.add_substitution(:foo, :bar)
-        end
-
-        it 'replaces the value' do
-          subject.add_substitution(:foo, :baz)
-          expect(subject.substitutions).to have_key(:foo)
-          expect(subject.substitutions[:foo]).to eq(:baz)
-        end
-      end
-    end
-
-    describe '#add_to_smtpapi' do
-      let(:substitutions) { { foo: :bar, baz: :qux } }
-      let(:smtp_api) { Smtpapi::Header.new }
-      before do
-        substitutions.each do |key, value|
-          subject.add_substitution(key, value)
-        end
-      end
-
-      it 'adds the address' do
-        expect(smtp_api).to receive(:add_to)
-        subject.add_to_smtpapi(smtp_api)
-      end
-
-      it 'calls add_substitution as many times as there are substitution keys' do
-        substitutions.each do |key, value|
-          expect(smtp_api).to receive(:add_substitution).with(key, [value])
-        end
-
-        subject.add_to_smtpapi(smtp_api)
-      end
-
-      context 'a substitution for the same key already exists' do
-        let(:substitutions) { { foo: :bar } }
-        let(:added_value) { [:bar, :rab] }
-
-        before do
-          smtp_api.add_substitution(:foo, [:rab])
-        end
-
-        it 'adds to it' do
-          expect(smtp_api).to receive(:add_substitution).with(:foo, array_including(added_value))
-          subject.add_to_smtpapi(smtp_api)
-        end
-      end
-
-      context 'substitutions is empty' do
-        let(:substitutions) { {} }
-
-        it 'does nothing' do
-          expect(smtp_api).to_not receive(:add_substitution)
-          subject.add_to_smtpapi(smtp_api)
-        end
-      end
-    end
-  end
-end