griddler 0.6.4 → 1.0.0.pre.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a2cacfe5e74d1231a76e4502ed28c88399fd769
-  data.tar.gz: 3213db391f6032cfa65f6d0fa2e0323b45016001
+  metadata.gz: e799f0b0004bfe2b6628c40f370f2f16eab17223
+  data.tar.gz: b82b19547ba1ed0280e2e16460c54d4c22ed6cd0
 SHA512:
-  metadata.gz: c9cf20906c65491d019e30b68dfd669c5f16f80eca4cbb922410c91f63b338e723e52f1a7912e56a2f6dfc10b041806eb64fe2ce7bc6adfdea3a1038ac88c304
-  data.tar.gz: b047cccc5d6ea2fdfce31da626671fe11de304ec5d338850afacdf1640da27f51d60c31bee2b72d54d9c64db6147c17a9ad4d5d54e93d193e32d5925d1f6e6b7
+  metadata.gz: 240c7e9eda058081f8ee93e55f564f4c2a2683506c40d929cfc8fba43fbcbd7787fd91eef94871c272062ba9ae683a144e50cbcc442ddb2f3d22555c6762d35d
+  data.tar.gz: b5c5a4c2ad91fdaf9816178409cb12daca799ba9dd6be5e7311adf758bc879dfd14cf62e8fa0c7742a79e6c18a00c76b6581ae8ad929daa33af8fa46bc3839e7

data/README.md

@@ -6,133 +6,58 @@ Griddler
 
 ### Receive emails in your Rails app
 
-Griddler is a Rails engine (full plugin) that provides an endpoint for the
-[SendGrid parse api](http://sendgrid.com/docs/API%20Reference/Webhooks/parse.html),
-[Cloudmailin parse api](http://cloudmailin.com),
-[Postmark parse api](http://developer.postmarkapp.com/developer-inbound-parse.html) or
-[Mandrill parse api](http://help.mandrill.com/entries/21699367-Inbound-Email-Processing-Overview)
-[Mailgun routes](http://documentation.mailgun.com/user_manual.html#receiving-messages-via-http-through-a-forward-action)
-that hands off a built email object to a class implemented by you.
+Griddler is a Rails engine that provides an endpoint for the
+[SendGrid](http://sendgrid.com/docs/API%20Reference/Webhooks/parse.html),
+[Cloudmailin](http://cloudmailin.com),
+[Postmark](http://developer.postmarkapp.com/developer-inbound-parse.html),
+[Mandrill](http://help.mandrill.com/entries/21699367-Inbound-Email-Processing-Overview), or
+[Mailgun](http://documentation.mailgun.com/user\_manual.html#receiving-messages-via-http-through-a-forward-action)
+parse APIs that hands off a built email object to a class implemented by you.
 
 Tutorials
 ---------
 
-* SendGrid has done a
+* SendGrid wrote a
   [great tutorial](http://blog.sendgrid.com/receiving-email-in-your-rails-app-with-griddler/)
   on integrating Griddler with your application.
-* And of course, view our own blog post on the subject over at
-  [Giant Robots](http://robots.thoughtbot.com/post/42286882447/handle-incoming-email-with-griddler).
+* We have our own blog post on the subject over at
+  [Giant Robots](http://robots.thoughtbot.com/handle-incoming-email-with-griddler).
 
 Installation
 ------------
 
-Add griddler to your application's Gemfile and run `bundle install`:
+1. Add `griddler` and an [adapter] gem to your application's Gemfile
+   and run `bundle install`.
 
-```ruby
-gem 'griddler'
-```
-A route is needed for the endpoint which receives `POST` messages. Currently,
-the route is automatically appended to the route table like so:
-
-```ruby
-email_processor POST /email_processor(.:format)   griddler/emails#create
-```
+   [adapter]: #adapters
 
-**NOTE: This behavior is deprecated and will be removed by version 0.7.0 in favor
-of manually adding the route.**
+2. A route is needed for the endpoint which receives `POST` messages. To add the
+   route, in `config/routes.rb` you may either use the provided routing method
+   `mount_griddler` or set the route explicitly. Examples:
 
-To manually add the route, in `config/routes.rb` you may either use the provided
-routing method `mount_griddler` or set the route explicitly. Examples:
+   ```ruby
+   # config/routes.rb
 
-```ruby
-# mount using default path
-mount_griddler
+   # mount using default path: /email_processor
+   mount_griddler
 
-# mount using a custom path
-mount_griddler('/email/incoming')
+   # mount using a custom path
+   mount_griddler('/email/incoming')
 
-# the "get off my lawn", DIY approach:
-post '/email_processor' => 'griddler/emails#create'
-```
+   # the DIY approach:
+   post '/email_processor' => 'griddler/emails#create'
+   ```
 
-Defaults
---------
+### Configuration Options
 
-By default Griddler will look for a class to be created in your application
-called EmailProcessor with a class method implemented, named process, taking
-in one argument (presumably `email`). For example, in `./lib/email_processor.rb`:
-
-```ruby
-class EmailProcessor
-  def self.process(email)
-    # all of your application-specific code here - creating models,
-    # processing reports, etc
-  end
-end
-```
-
-The contents of the `email` object passed into your process method is an object
-that responds to:
-
-* `.to`
-* `.from`
-* `.cc`
-* `.subject`
-* `.body`
-* `.raw_text`
-* `.raw_html`
-* `.raw_body`
-* `.attachments`
-* `.headers`
-* `.raw_headers`
-
-Each of those has some sensible defaults.
-
-`.raw_body`, `.raw_headers`, and `.subject` will contain the obvious
-values found in the email, the raw values from those fields.
-
-`.body` will contain the full contents of the email body **unless** there is a
-line in the email containing the string `-- Reply ABOVE THIS LINE --`. In that
-case `.body` will contain everything before that line.
-
-`.to` will contain an array of hashes. Each hash will have the following
-information of each recipient:
-
-  * `token`: All the text before the email's "@". We've found that this is the
-  most often used portion of the email address and consider it to be the token
-  we'll key off of for interaction with our application.
-
-  * `host`: All the text after the email's "@". This is important to filter
-  the recipients sent to the application vs emails to other domains. More
-  info below on the Upgrading to 0.5.0 section.
-
-  * `email`: The email address of the recipient.
-
-  * `full`: The whole recipient field. E.g, `Some User <hello@example.com>`
-  * `name`: The name of the recipient. E.g, `Some User`
-
-`.from` will default to the `email` value of a hash like `.to`, and can be
-configured to return the full hash.
-
-`.cc` behaves and can be configured like `.to`. If the adapter does not
-pass along a `cc` key then the headers will be parsed.
-
-`.attachments` will contain an array of attachments as multipart/form-data files
-which can be passed off to attachment libraries like Carrierwave or Paperclip.
-
-`.headers` will contain a hash of header names and values as parsed by the Mail
-gem. Headers will only be parsed if the adapter supports a headers option.
-
-Configuration Options
----------------------
-
-An initializer can be created to control some of the options in Griddler. Defaults
-are shown below with sample overrides following. In `config/initializers/griddler.rb`:
+An initializer can be created to control some of the options in Griddler.
+Defaults are shown below with sample overrides following. In
+`config/initializers/griddler.rb`:
 
 ```ruby
 Griddler.configure do |config|
-  config.processor_class = EmailProcessor # MyEmailProcessor
-  config.processor_method = :process # :custom_method
+  config.processor_class = EmailProcessor # CommentViaEmail
+  config.processor_method = :process # :create_comment (A method on CommentViaEmail)
   config.to = :hash # :full, :email, :token
   config.cc = :email # :full, :hash, :token
   config.from = :email # :full, :token, :hash
@@ -145,21 +70,63 @@ Griddler.configure do |config|
 end
 ```
 
-* `config.processor_class` is the class Griddler will use to handle your incoming emails.
-* `config.processor_method` is the method Griddler will call on the processor class when handling your incoming emails.
-* `config.reply_delimiter` is the string searched for that will split your body.
-* `config.to`, `config.cc` and `config.from` are the format of the returned value for that
-  address in the email object. `:hash` will return all options within a -- (surprise!) -- hash.
-* `config.email_service` tells Griddler which email service you are using. The
-  supported email service options are `:sendgrid` (the default), `:cloudmailin`
-  (expects multipart format), `:postmark` and `:mandrill`.
+| Option             | Meaning
+| ------             | -------
+| `processor_class`  | The class Griddler will use to handle your incoming emails.
+| `processor_method` | The method Griddler will call on the processor class when handling your incoming emails.
+| `reply_delimiter`  | The string searched for that will split your body.
+| `email_service`    | Tells Griddler which email service you are using. The supported email service options are `:sendgrid` (the default), `:cloudmailin` (expects multipart format), `:postmark` and `:mandrill`. You will also need to have an appropriate [adapter] gem included in your Gemfile.
+| `to`, `config.cc` and `config.from` | The format of the returned value for that address in the email object. `:hash` will return all options within a -- (surprise!) -- hash.
+
+By default Griddler will look for a class named `EmailProcessor` with a class
+method named `process`, taking in one argument, a `Griddler::Email` instance
+representing the incoming email.  For example, in `./lib/email_processor.rb`:
+
+```ruby
+class EmailProcessor
+  def self.process(email)
+    # all of your application-specific code here - creating models,
+    # processing reports, etc
+  end
+end
+```
+
+Griddler::Email attributes
+--------------------------
+
+| Attribute      | Description
+| -------------- | -----------
+| `#to`          | An array of hashes containing recipient address information.  See [Email Addresses](#email-addresses) for more information.
+| `#from`        | A hash containing the sender address information.
+| `#cc`          | An array of hashes containing cc email address information.
+| `#subject`     | The subject of the email message.
+| `#body`        | The full contents of the email body **unless** there is a line in the email containing the string `-- Reply ABOVE THIS LINE --`. In that case `.body` will contain everything before that line.
+| `#raw_text`    | The raw text part of the body.
+| `#raw_html`    | The raw html part of the body.
+| `#raw_body`    | The raw body information provided by the email service.
+| `#attachments` | An array of `File` objects containing any attachments.
+| `#headers`     | A hash of headers parsed by `Mail::Header`.
+| `#raw_headers` | The raw headers included in the message.
+
+### Email Addresses
+
+Gridder::Email provides email addresses as hashes. Each hash will have the following
+information of each recipient:
+
+| Key | Value
+| --- | -----
+| `:token` | All the text before the email's "@". We've found that this is the most often used portion of the email address and consider it to be the token we'll key off of for interaction with our application.
+| `:host` | All the text after the email's "@". This is important to filter the recipients sent to the application vs emails to other domains. More info below on the Upgrading to 0.5.0 section.
+| `:email` | The email address of the recipient.
+| `:full` | The whole recipient field (e.g., `Some User <hello@example.com>`).
+| `:name` | The name of the recipient (e.g., `Some User`).
 
 Testing In Your App
 -------------------
 
-You may want to create a factory for when testing the integration of Griddler into
-your application. If you're using factory\_girl this can be accomplished with the
-following sample factory.
+You may want to create a factory for when testing the integration of Griddler
+into your application. If you're using factory\_girl this can be accomplished
+with the following sample factory:
 
 ```ruby
 factory :email, class: OpenStruct do
@@ -175,7 +142,7 @@ factory :email, class: OpenStruct do
       ActionDispatch::Http::UploadedFile.new({
         filename: 'img.png',
         type: 'image/png',
-        tempfile: File.new("#{File.expand_path File.dirname(__FILE__)}/fixtures/img.png")
+        tempfile: File.new("#{File.expand_path(File.dirname(__FILE__))}/fixtures/img.png")
       })
     ]}
   end
@@ -186,76 +153,49 @@ Bear in mind, if you plan on using the `:with_attachment` trait, that this
 example assumes your factories are in `spec/factories.rb` and you have
 an image file in `spec/fixtures/`.
 
-To use it in your test(s) just build with `email = build(:email)`
+To use it in your tests, build with `email = build(:email)`
 or `email = build(:email, :with_attachment)`.
 
 Adapters
 --------
 
-`Griddler::Email` expects certain parameters to be in place for proper parsing
-to occur. When writing an adapter, ensure that the `normalized_params` method
-of your adapter returns a hash with these keys:
-
-* `:to` The recipient field
-* `:from` The sender field
-* `:subject` Email subject
-* `:text` The text body of the email
-* `:html` The html body of the email, nil or empty string if not present
-* `:attachments` (can be an empty array) Array of attachments to the email
-* `:headers` (optional) The raw headers of the email
-* `:charsets` (optional) A JSON string containing the character sets of the
-  fields extracted from the message
-
-Upgrading to Griddler 0.5.0
----------------------------
-
-Because of an issue with the way Griddler handled recipients in the `To` header,
-a breaking change was introduced in Griddler 0.5.0 that requires a minor change
-to `EmailProcessor` or `processor_class`.
-
-Previously, a single address was returned from `Griddler::Email#to`. Moving
-forward, this field will always be an array. Generally speaking, you will want
-to do something like this to handle the change:
+Depending on the service you want to use Griddler with, you'll need to add an
+adapter gem in addition to `griddler`.
 
-```ruby
-# before
-def initialize(email)
-  @to = email.to
-  @from = email.from
-  @body = email.body
-end
-
-# after
-def initialize(email)
-  @to = pick_meaningful_recipient(email.to)
-  @from = email.from
-  @body = email.body
-end
+| Service     | Adapter
+| -------     | -------
+| sendgrid    | [griddler-sendgrid]
+| mandrill    | [griddler-mandrill]
 
-private
+[griddler-sendgrid]: https://github.com/thoughtbot/griddler-sendgrid
+[griddler-mandrill]: https://github.com/wingrunr21/griddler-mandrill
 
-def pick_meaningful_recipient(recipients)
-  recipients.find { |address| address =~ /@mydomain.com$/ }
-end
-```
+Writing an Adapter
+------------------
 
-Using Griddler with Mandrill
-----------------------------
+Griddler can theoretically work with any email => POST service. In order to work
+correctly, adapters need to have their POST parameters restructured.
 
-When adding a webhook in their administration panel, Mandrill will issue a HEAD
-request to check if the webhook is valid (see
-[Adding Routes](http://help.mandrill.com/entries/21699367-Inbound-Email-Processing-Overview)).
-If the HEAD request fails, Mandrill will not allow you to add the webhook.
-Since Griddler is only configured to handle POST requests, you will not be able
-to add the webhook as-is. To solve this, add a temporary route to your
-application that can handle the HEAD request:
-
-```ruby
-# routes.rb
-get "/email_processor", to: proc { [200, {}, ["OK"]] }, as: "mandrill_head_test_request"
-```
-
-Once you have correctly configured Mandrill, you can go ahead and delete this code.
+`Griddler::Email` expects certain parameters to be in place for proper parsing
+to occur. When writing an adapter, ensure that the `normalized_params` method of
+your adapter returns a hash with these keys:
+
+| Parameter      | Contents
+| ---------      | --------
+| `:to`          | The recipient field
+| `:from`        | The sender field
+| `:subject`     | Email subject
+| `:text`        | The text body of the email
+| `:html`        | The html body of the email, nil or empty string if not present
+| `:attachments` | Array of attachments to the email. Can be an empty array.
+| `:headers`     | The raw headers of the email. **Optional**.
+| `:charsets`    | A JSON string containing the character sets of the fields extracted from the message. **Optional**.
+
+All keys are required unless otherwise stated.
+
+Adapters should be provided as gems. If you write an adapter, let us know and we
+will add it to this README. See [griddler-sendgrid] for an example
+implementation.
 
 More Information
 ----------------
@@ -269,7 +209,7 @@ More Information
 * [Mandrill](http://mandrill.com)
 * [Mandrill Docs](http://help.mandrill.com/forums/21092258-Inbound-Email-Processing)
 * [Mailgun](http://mailgun.com)
-* [Mailgun Docs](http://documentation.mailgun.com/user_manual.html#receiving-forwarding-and-storing-messages)
+* [Mailgun Docs](http://documentation.mailgun.com/user\_manual.html#receiving-forwarding-and-storing-messages)
 
 Credits
 -------
@@ -279,13 +219,8 @@ Griddler was written by Caleb Thompson and Joel Oliveira.
 Large portions of the codebase were extracted from thoughtbot's
 [Trajectory](http://www.apptrajectory.com).
 
+Thanks to our [contributors](https://github.com/thoughtbot/griddler/contributors)!
+
 ![thoughtbot](http://thoughtbot.com/images/tm/logo.png)
 
 The names and logos for thoughtbot are trademarks of thoughtbot, inc.
-
-License
--------
-
-Griddler is Copyright © 2014 Caleb Thompson, Joel Oliveira and thoughtbot. It is
-free software, and may be redistributed under the terms specified in the LICENSE
-file.

data/Rakefile

@@ -4,6 +4,7 @@ begin
   require 'bundler/gem_tasks'
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  exit 1
 end
 
 Bundler::GemHelper.install_tasks

data/lib/griddler.rb

@@ -6,11 +6,14 @@ require 'griddler/email'
 require 'griddler/email_parser'
 require 'griddler/configuration'
 require 'griddler/route_extensions'
-require 'griddler/adapters/sendgrid_adapter'
+require 'griddler/adapter_registry'
 require 'griddler/adapters/cloudmailin_adapter'
 require 'griddler/adapters/postmark_adapter'
-require 'griddler/adapters/mandrill_adapter'
 require 'griddler/adapters/mailgun_adapter'
 
-module Griddler
-end
+require 'griddler/sendgrid'
+require 'griddler/mandrill'
+
+Griddler.adapter_registry.register(:cloudmailin, Griddler::Adapters::CloudmailinAdapter)
+Griddler.adapter_registry.register(:postmark, Griddler::Adapters::PostmarkAdapter)
+Griddler.adapter_registry.register(:mailgun, Griddler::Adapters::MailgunAdapter)

data/lib/griddler/adapter_registry.rb

@@ -0,0 +1,28 @@
+module Griddler
+  class AdapterRegistry
+    DEFAULT_ADAPTER = :sendgrid
+
+    def initialize
+      @registry = {}
+    end
+
+    def register(adapter_name, adapter_class)
+      if adapter_name == DEFAULT_ADAPTER
+        @registry[:default] = adapter_class
+      end
+      @registry[adapter_name] = adapter_class
+    end
+
+    def [](adapter_name)
+      @registry[adapter_name]
+    end
+
+    def fetch(key, &block)
+      @registry.fetch(key, &block)
+    end
+  end
+
+  def self.adapter_registry
+    @adapter_registry ||= AdapterRegistry.new
+  end
+end

data/lib/griddler/adapters/mailgun_adapter.rb

@@ -12,7 +12,7 @@ module Griddler
 
       def normalize_params
         params.merge(
-          to: recipients,
+          to: tos,
           cc: ccs,
           text: params['body-plain'],
           html: params['body-html'],
@@ -25,24 +25,32 @@ module Griddler
 
       attr_reader :params
 
-      def recipients
-        params[:recipient].split(',')
+      def tos
+        to = param_or_header(:To)
+        to = params[:recipient] unless to
+        to.split(',').map(&:strip)
       end
 
       def ccs
-        cc = if params[:Cc].present?
-          params[:Cc]
-        else
-          extract_header_cc
-        end
+        cc = param_or_header(:Cc)
         cc.split(',').map(&:strip)
       end
 
-      def extract_header_cc
-        header = params['message-headers'].select{|h|
-          h.first == 'Cc'
-        }.first
-        header.to_a.last
+      def extract_header(key)
+        return nil unless params['message-headers'].present?
+
+        headers = params['message-headers'].select do |h|
+          h.first.to_s == key.to_s
+        end
+        headers.flatten.last
+      end
+
+      def param_or_header(key)
+        if params[key].present?
+          params[key]
+        else
+          extract_header(key)
+        end
       end
 
       def attachment_files

data/lib/griddler/configuration.rb

@@ -42,7 +42,18 @@ module Griddler
     end
 
     def processor_class
-      @processor_class ||= EmailProcessor
+      @processor_class ||=
+        begin
+          if Kernel.const_defined?(:EmailProcessor)
+            EmailProcessor
+          else
+            raise NameError.new(<<-ERROR.strip_heredoc, 'EmailProcessor')
+              To use Griddler, you must either define `EmailProcessor` or configure a
+              different processor. See https://github.com/thoughtbot/griddler#defaults for
+              more information.
+            ERROR
+          end
+        end
     end
 
     def processor_method
@@ -54,27 +65,11 @@ module Griddler
     end
 
     def email_service
-      @email_service_adapter ||= adapter_class[:sendgrid]
+      @email_service_adapter ||= Griddler.adapter_registry[:sendgrid]
     end
 
     def email_service=(new_email_service)
-      if new_email_service == :default
-        new_email_service = :sendgrid
-      end
-
-      @email_service_adapter = adapter_class.fetch(new_email_service) { raise Griddler::Errors::EmailServiceAdapterNotFound }
-    end
-
-    private
-
-    def adapter_class
-      {
-        sendgrid: Griddler::Adapters::SendgridAdapter,
-        cloudmailin: Griddler::Adapters::CloudmailinAdapter,
-        postmark: Griddler::Adapters::PostmarkAdapter,
-        mandrill: Griddler::Adapters::MandrillAdapter,
-        mailgun: Griddler::Adapters::MailgunAdapter
-      }
+      @email_service_adapter = Griddler.adapter_registry.fetch(new_email_service) { raise Griddler::Errors::EmailServiceAdapterNotFound }
     end
   end
 end

data/lib/griddler/testing.rb

@@ -0,0 +1,57 @@
+require 'action_dispatch'
+
+module Griddler::Testing
+  def upload_1
+    @upload_1 ||= UploadedImage.new('photo1.jpg').file
+  end
+
+  def upload_2
+    @upload_2 ||= UploadedImage.new('photo2.jpg').file
+  end
+
+  def normalize_params(params)
+    Griddler::Sendgrid::Adapter.normalize_params(params)
+  end
+
+  class UploadedImage
+    def initialize(name)
+      @name = name
+    end
+
+    def file
+      ActionDispatch::Http::UploadedFile.new({
+        filename: @name,
+        type: 'image/jpeg',
+        tempfile: fixture_file
+      })
+    end
+
+    private
+
+    def fixture_file
+      cwd = File.expand_path File.dirname(__FILE__)
+      File.new(File.join(cwd, '..', '..', 'spec', 'fixtures', @name))
+    end
+  end
+end
+
+shared_examples_for 'Griddler adapter' do |adapter, service_params|
+  it 'adapts params to expected values' do
+    Griddler.configuration.email_service = adapter
+
+    normalized_params = Griddler.configuration.email_service.normalize_params(service_params)
+
+    Array.wrap(normalized_params).each do |params|
+      email = Griddler::Email.new(params)
+
+      email.to.should eq([{
+        token: 'hi',
+        host: 'example.com',
+        full: 'Hello World <hi@example.com>',
+        email: 'hi@example.com',
+        name: 'Hello World',
+      }])
+      email.cc.should eq ['emily@example.com']
+    end
+  end
+end

data/lib/griddler/version.rb

@@ -1,3 +1,3 @@
 module Griddler
-  VERSION = "0.6.4"
+  VERSION = "1.0.0-alpha.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: griddler
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 1.0.0.pre.alpha.1
 platform: ruby
 authors:
 - Caleb Thompson
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-13 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -97,21 +97,19 @@ files:
 - Rakefile
 - app/controllers/griddler/emails_controller.rb
 - config/initializers/griddler.rb
-- config/routes.rb
 - lib/griddler.rb
+- lib/griddler/adapter_registry.rb
 - lib/griddler/adapters/cloudmailin_adapter.rb
 - lib/griddler/adapters/mailgun_adapter.rb
-- lib/griddler/adapters/mandrill_adapter.rb
 - lib/griddler/adapters/postmark_adapter.rb
-- lib/griddler/adapters/sendgrid_adapter.rb
 - lib/griddler/configuration.rb
 - lib/griddler/email.rb
 - lib/griddler/email_parser.rb
 - lib/griddler/engine.rb
 - lib/griddler/errors.rb
 - lib/griddler/route_extensions.rb
+- lib/griddler/testing.rb
 - lib/griddler/version.rb
-- lib/tasks/griddler_tasks.rake
 homepage: http://thoughtbot.com
 licenses: []
 metadata: {}
@@ -130,9 +128,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/config/routes.rb

@@ -1,3 +0,0 @@
-Rails.application.routes.draw do
-  post '/email_processor' => 'griddler/emails#create', as: :email_processor
-end

data/lib/griddler/adapters/mandrill_adapter.rb

@@ -1,71 +0,0 @@
-module Griddler
-  module Adapters
-    class MandrillAdapter
-      def initialize(params)
-        @params = params
-      end
-
-      def self.normalize_params(params)
-        adapter = new(params)
-        adapter.normalize_params
-      end
-
-      def normalize_params
-        events.map do |event|
-          {
-            to: recipients(:to, event),
-            cc: recipients(:cc, event),
-            from: full_email([ event[:from_email], event[:from_name] ]),
-            subject: event[:subject],
-            text: event.fetch(:text, ''),
-            html: event.fetch(:html, ''),
-            raw_body: event[:raw_msg],
-            attachments: attachment_files(event)
-          }
-        end
-      end
-
-      private
-
-      attr_reader :params
-
-      def events
-        @events ||= ActiveSupport::JSON.decode(params[:mandrill_events]).map do |event|
-          event['msg'].with_indifferent_access
-        end
-      end
-
-      def recipients(field, event)
-        Array.wrap(event[field]).map { |recipient| full_email(recipient) }
-      end
-
-      def full_email(contact_info)
-        email = contact_info[0]
-        if contact_info[1]
-          "#{contact_info[1]} <#{email}>"
-        else
-          email
-        end
-      end
-
-      def attachment_files(event)
-        attachments = event[:attachments] || Array.new
-        attachments.map do |key, attachment|
-          ActionDispatch::Http::UploadedFile.new({
-            filename: attachment[:name],
-            type: attachment[:type],
-            tempfile: create_tempfile(attachment)
-          })
-        end
-      end
-
-      def create_tempfile(attachment)
-        filename = attachment[:name]
-        tempfile = Tempfile.new(filename, Dir::tmpdir, encoding: 'ascii-8bit')
-        tempfile.write(Base64.decode64(attachment[:content]))
-        tempfile.rewind
-        tempfile
-      end
-    end
-  end
-end

data/lib/griddler/adapters/sendgrid_adapter.rb

@@ -1,39 +0,0 @@
-module Griddler
-  module Adapters
-    class SendgridAdapter
-      def initialize(params)
-        @params = params
-      end
-
-      def self.normalize_params(params)
-        adapter = new(params)
-        adapter.normalize_params
-      end
-
-      def normalize_params
-        params.merge(
-          to: recipients(:to),
-          cc: recipients(:cc),
-          attachments: attachment_files,
-        )
-      end
-
-      private
-
-      attr_reader :params
-
-      def recipients(key)
-        ( params[key] || '' ).split(',')
-      end
-
-      def attachment_files
-        params.delete('attachment-info')
-        attachment_count = params[:attachments].to_i
-
-        attachment_count.times.map do |index|
-          params.delete("attachment#{index + 1}".to_sym)
-        end
-      end
-    end
-  end
-end

data/lib/tasks/griddler_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :griddler do
-#   # Task goes here
-# end