griddler-acd 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0bbff6edeef08baf0c4cfc81727aef71984e8064
+  data.tar.gz: e622fa41d89c7ca9513c0a21752b51d05a5f2b30
+SHA512:
+  metadata.gz: 20ee0b0ce115d5a9bb41e0f4e6084d0a187ca9249e4edf4f1713ccc1f5f2377479da328367249ce7cef6f1879e6ca8501f8e4e40e61944225ae06e766b007237
+  data.tar.gz: 3cf2ede21b125530f4bd26d95b953842d02d2dc3428e21122d04b650a60399f050f149be7793a302d46b3b23d76d026a65f87e4f3b86b5744cc5237cdbd5d2ef

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Caleb Thompson, Joel Oliveira and thoughtbot, inc.
+
+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,212 @@
+Griddler
+========
+
+[![Build Status](https://travis-ci.org/thoughtbot/griddler.png?branch=master)](https://travis-ci.org/thoughtbot/griddler)
+[![Code Climate](https://codeclimate.com/github/thoughtbot/griddler.png)](https://codeclimate.com/github/thoughtbot/griddler)
+
+### Receive emails in your Rails app
+
+Griddler is a Rails engine that provides an endpoint for services that convert
+incoming emails to HTTP POST requests. It parses these POSTs and hands off a
+built email object to a class implemented by you.
+
+Tutorials
+---------
+
+* SendGrid wrote a
+  [great tutorial](http://blog.sendgrid.com/receiving-email-in-your-rails-app-with-griddler/)
+  on integrating Griddler with your application.
+* We have our own blog post on the subject over at
+  [Giant Robots](http://robots.thoughtbot.com/handle-incoming-email-with-griddler).
+
+Installation
+------------
+
+1. Add `griddler` and an [adapter] gem to your application's Gemfile
+   and run `bundle install`.
+
+   [adapter]: #adapters
+
+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:
+
+   ```ruby
+   # config/routes.rb
+
+   # mount using default path: /email_processor
+   mount_griddler
+
+   # mount using a custom path
+   mount_griddler('/email/incoming')
+
+   # the DIY approach:
+   post '/email_processor' => 'griddler/emails#create'
+   ```
+
+### 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`:
+
+```ruby
+Griddler.configure do |config|
+  config.processor_class = EmailProcessor # CommentViaEmail
+  config.processor_method = :process # :create_comment (A method on CommentViaEmail)
+  config.reply_delimiter = '-- REPLY ABOVE THIS LINE --'
+  config.email_service = :sendgrid # :cloudmailin, :postmark, :mandrill, :mailgun
+end
+```
+
+| 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`, `:mandrill` and `:mailgun`. You will also need to have an appropriate [adapter] gem included in your Gemfile.
+
+By default Griddler will look for a class named `EmailProcessor` with a 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 initialize(email)
+    @email = email
+  end
+
+  def process
+    # all of your application-specific code here - creating models,
+    # processing reports, etc
+
+    # here's an example of model creation
+    user = User.find_by_email(@email.from[:email])
+    user.posts.create!(
+      subject: @email.subject,
+      body: @email.body
+    )
+  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:
+
+```ruby
+factory :email, class: OpenStruct do
+  # Assumes Griddler.configure.to is :hash (default)
+  to [{ full: 'to_user@email.com', email: 'to_user@email.com', token: 'to_user', host: 'email.com', name: nil }]
+  from 'user@email.com'
+  subject 'email subject'
+  body 'Hello!'
+  attachments {[]}
+
+  trait :with_attachment do
+    attachments {[
+      ActionDispatch::Http::UploadedFile.new({
+        filename: 'img.png',
+        type: 'image/png',
+        tempfile: File.new("#{File.expand_path(File.dirname(__FILE__))}/fixtures/img.png")
+      })
+    ]}
+  end
+end
+```
+
+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 tests, build with `email = build(:email)`
+or `email = build(:email, :with_attachment)`.
+
+Adapters
+--------
+
+Depending on the service you want to use Griddler with, you'll need to add an
+adapter gem in addition to `griddler`.
+
+| Service     | Adapter
+| -------     | -------
+| sendgrid    | [griddler-sendgrid]
+| mandrill    | [griddler-mandrill]
+| mailgun     | [griddler-mailgun]
+| postmark    | [griddler-postmark]
+
+[griddler-sendgrid]: https://github.com/thoughtbot/griddler-sendgrid
+[griddler-mandrill]: https://github.com/wingrunr21/griddler-mandrill
+[griddler-mailgun]: https://github.com/bradpauly/griddler-mailgun
+[griddler-postmark]: https://github.com/r38y/griddler-postmark
+
+Writing an Adapter
+------------------
+
+Griddler can theoretically work with any email => POST service. In order to work
+correctly, adapters need to have their POST parameters restructured.
+
+`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.
+
+Credits
+-------
+
+Griddler was written by Caleb Thompson and Joel Oliveira.
+
+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.

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+  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
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/app/controllers/griddler/emails_controller.rb

@@ -0,0 +1,25 @@
+class Griddler::EmailsController < ActionController::Base
+  def create
+    normalized_params.each do |p|
+      process_email Griddler::Email.new(p)
+    end
+
+    head :ok
+  end
+
+  private
+
+  delegate :processor_class, :processor_method, :email_service, to: :griddler_configuration
+
+  def normalized_params
+    Array.wrap(email_service.normalize_params(params))
+  end
+
+  def process_email(email)
+    processor_class.new(email).public_send(processor_method)
+  end
+
+  def griddler_configuration
+    Griddler.configuration
+  end
+end

data/config/initializers/griddler.rb

@@ -0,0 +1 @@
+require 'griddler'

data/lib/griddler.rb

@@ -0,0 +1,9 @@
+require 'rails/engine' if defined?(::Rails::Engine)
+require 'action_view'
+require 'griddler/errors'
+require 'griddler/engine'
+require 'griddler/email'
+require 'griddler/email_parser'
+require 'griddler/configuration'
+require 'griddler/route_extensions'
+require 'griddler/adapter_registry'

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/configuration.rb

@@ -0,0 +1,52 @@
+module Griddler
+  @@configuration = nil
+
+  def self.configure
+    @@configuration = Configuration.new
+
+    if block_given?
+      yield configuration
+    end
+
+    configuration
+  end
+
+  def self.configuration
+    @@configuration || configure
+  end
+
+  class Configuration
+    attr_accessor :processor_class, :processor_method, :reply_delimiter
+
+    def processor_class
+      @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
+      @processor_method ||= :process
+    end
+
+    def reply_delimiter
+      @reply_delimiter ||= 'Reply ABOVE THIS LINE'
+    end
+
+    def email_service
+      @email_service_adapter ||= Griddler.adapter_registry[:default]
+    end
+
+    def email_service=(new_email_service)
+      @email_service_adapter = Griddler.adapter_registry.fetch(new_email_service) { raise Griddler::Errors::EmailServiceAdapterNotFound }
+    end
+  end
+end

data/lib/griddler/email.rb

@@ -0,0 +1,84 @@
+require 'htmlentities'
+
+module Griddler
+  class Email
+    include ActionView::Helpers::SanitizeHelper
+    attr_reader :to, :from, :cc, :subject, :body, :raw_body, :raw_text, :raw_html,
+      :headers, :raw_headers, :attachments
+
+    def initialize(params)
+      @params = params
+
+      @to = recipients(:to)
+      @from = extract_address(params[:from])
+      @subject = params[:subject]
+
+      @body = extract_body
+      @raw_text = params[:text]
+      @raw_html = params[:html]
+      @raw_body = @raw_text.presence || @raw_html
+
+      @headers = extract_headers
+
+      @cc = recipients(:cc)
+
+      @raw_headers = params[:headers]
+
+      @attachments = params[:attachments]
+    end
+
+    private
+
+    attr_reader :params
+
+    def config
+      @config ||= Griddler.configuration
+    end
+
+    def recipients(type)
+      params[type].to_a.map { |recipient| extract_address(recipient) }
+    end
+
+    def extract_address(address)
+      EmailParser.parse_address(address)
+    end
+
+    def extract_body
+      EmailParser.extract_reply_body(text_or_sanitized_html)
+    end
+
+    def extract_headers
+      EmailParser.extract_headers(params[:headers])
+    end
+
+    def extract_cc_from_headers(headers)
+      EmailParser.extract_cc(headers)
+    end
+
+    def text_or_sanitized_html
+      text = clean_text(params.fetch(:text, ''))
+      text.presence || clean_html(params.fetch(:html, '')).presence
+    end
+
+    def clean_text(text)
+      clean_invalid_utf8_bytes(text)
+    end
+
+    def clean_html(html)
+      cleaned_html = clean_invalid_utf8_bytes(html)
+      cleaned_html = strip_tags(cleaned_html)
+      cleaned_html = HTMLEntities.new.decode(cleaned_html)
+      cleaned_html
+    end
+
+    def clean_invalid_utf8_bytes(text)
+      if !text.valid_encoding?
+        text = text
+          .force_encoding('ISO-8859-1')
+          .encode('UTF-8')
+      end
+
+      text
+    end
+  end
+end

data/lib/griddler/email_parser.rb

@@ -0,0 +1,91 @@
+# Parse emails from their full format into a hash containing full email, host,
+# local token, and the raw argument.
+#
+# Some Body <somebody@example.com>
+# # => {
+#   token: 'somebody',
+#   host: 'example.com',
+#   email: 'somebody@example.com',
+#   full: 'Some Body <somebody@example.com>',
+# }
+require 'mail'
+
+module Griddler::EmailParser
+  def self.parse_address(full_address)
+    email_address = extract_email_address(full_address)
+    name = extract_name(full_address)
+    token, host = split_address(email_address)
+    {
+      token: token,
+      host: host,
+      email: email_address,
+      full: full_address,
+      name: name,
+    }
+  end
+
+  def self.extract_reply_body(body)
+    if body.blank?
+      ""
+    else
+      remove_reply_portion(body)
+        .split(/[\r]*\n/)
+        .reject do |line|
+          line =~ /^\s+>/ ||
+            line =~ /^\s*Sent from my /
+        end.
+        join("\n").
+        strip
+    end
+  end
+
+  def self.extract_headers(raw_headers)
+    header_fields = Mail::Header.new(raw_headers).fields
+
+    header_fields.inject({}) do |header_hash, header_field|
+      header_hash[header_field.name.to_s] = header_field.value.to_s
+      header_hash
+    end
+  end
+
+  private
+
+  def self.reply_delimeter_regex
+    delimiter = Array(Griddler.configuration.reply_delimiter).join('|')
+    %r{#{delimiter}}
+  end
+
+  def self.extract_email_address(full_address)
+    full_address.split('<').last.delete('>').strip
+  end
+
+  def self.extract_name(full_address)
+    full_address = full_address.strip
+    name = full_address.split('<').first.strip
+    if name.present? && name != full_address
+      name
+    end
+  end
+
+  def self.split_address(email_address)
+    email_address.try :split, '@'
+  end
+
+  def self.regex_split_points
+    [
+      reply_delimeter_regex,
+      /^\s*[-]+\s*Original Message\s*[-]+\s*$/i,
+      /^\s*--\s*$/,
+      /^\s*\>?\s*On.*\r?\n?\s*.*\s*wrote:\r?\n?$/,
+      /On.*wrote:/,
+      /From:.*$/i,
+      /^\s*\d{4}\/\d{1,2}\/\d{1,2}\s.*\s<.*>?$/i
+    ]
+  end
+
+  def self.remove_reply_portion(body)
+    regex_split_points.inject(body) do |result, split_point|
+      result.split(split_point).first || ""
+    end
+  end
+end

data/lib/griddler/engine.rb

@@ -0,0 +1,9 @@
+module Griddler
+  class Engine < ::Rails::Engine
+    initializer 'griddler.routes',
+      after: 'action_dispatch.prepare_dispatcher' do |app|
+
+      ActionDispatch::Routing::Mapper.send :include, Griddler::RouteExtensions
+    end
+  end if defined?(::Rails::Engine)
+end

data/lib/griddler/errors.rb

@@ -0,0 +1,9 @@
+module Griddler
+  class Error < StandardError
+  end
+
+  module Errors
+    class EmailServiceAdapterNotFound < Griddler::Error
+    end
+  end
+end

data/lib/griddler/route_extensions.rb

@@ -0,0 +1,7 @@
+module Griddler
+  module RouteExtensions
+    def mount_griddler(path='/email_processor')
+      post path => 'griddler/emails#create', as: :email_processor
+    end
+  end
+end

data/lib/griddler/testing.rb

@@ -0,0 +1,89 @@
+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)
+
+      expect(email.to).to eq([{
+        token: 'hi',
+        host: 'example.com',
+        full: 'Hello World <hi@example.com>',
+        email: 'hi@example.com',
+        name: 'Hello World',
+      }])
+      expect(email.cc).to eq [{
+        token: 'emily',
+        host: 'example.com',
+        email: 'emily@example.com',
+        full: 'emily@example.com',
+        name: nil
+      }]
+    end
+  end
+end
+
+RSpec::Matchers.define :be_normalized_to do |expected|
+  failure_message do |actual|
+    message = ""
+    expected.each do |k, v|
+      if actual[k] != expected[k]
+        message << "expected :#{k} to be normalized to #{expected[k].inspect}, "\
+          "but received #{actual[k].inspect}\n"
+      end
+    end
+    message
+  end
+
+  description do
+    "be normalized to #{expected}"
+  end
+
+  match do |actual|
+    expected.each do |k, v|
+      case v
+      when Regexp then expect(actual[k]).to =~ v
+      else expect(actual[k]).to === v
+      end
+    end
+  end
+end

data/lib/griddler/version.rb

@@ -0,0 +1,3 @@
+module Griddler
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: griddler-acd
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Caleb Thompson
+- Joel Oliveira
+- thoughtbot
+- Swift
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- cjaysson@gmail.com
+- joel@thoughtbot.com
+- theycallmeswift@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/controllers/griddler/emails_controller.rb
+- config/initializers/griddler.rb
+- lib/griddler.rb
+- lib/griddler/adapter_registry.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
+homepage: http://thoughtbot.com
+licenses: []
+metadata: {}
+post_install_message: |
+  When upgrading from a Griddler version previous to 0.5.0, it is important that
+  you view https://github.com/thoughtbot/griddler/#upgrading-to-griddler-050 for
+  upgrade information.
+rdoc_options: []
+require_paths:
+- app
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: SendGrid Parse API client Rails Engine
+test_files: []
+has_rdoc: