gatling_gun 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 720840ea4789f10af01fed82114a0b7b35e9100c
+  data.tar.gz: 6018e0b11b67eee0cc9f214533346deaf4563536
+SHA512:
+  metadata.gz: 60f345655d88720db97a6318ad41f3d08096a5db9cb67e31f0dc8fc9a63506eb56e1ac36c2bef60ae7c5ee33c27045423d957b87ad44337a81c995dfb40a87a4
+  data.tar.gz: dbfc985229161a8ab2feb416d743106c1b895c8e5669927800439713cca7cd0025ed625145dd5876755529b125b751662bb5f5c38f25d455e45d2259c471fc18

data/.gitignore

@@ -1,4 +1,6 @@
+Gemfile.lock
+.ruby-gemset
+.ruby-version
 pkg
-
 .DS_Store
 **/.DS_Store

data/.rubocop.yml

@@ -0,0 +1,95 @@
+AndOr:
+  Enabled: false
+
+StringLiterals:
+  Enabled: false
+
+AccessorMethodName:
+  Enabled: false
+
+ClassLength:
+  Max: 300
+
+Documentation:
+  Enabled: false
+
+Encoding:
+  Enabled: false
+
+BracesAroundHashParameters:
+  Enabled: false
+
+Blocks:
+  Enabled: false
+
+ClassVars:
+  Enabled: false
+
+CollectionMethods:
+  Enabled: false
+
+CyclomaticComplexity:
+  Max: 16
+
+HandleExceptions:
+  Enabled: false
+
+HashSyntax:
+  Enabled: false
+
+IfUnlessModifier:
+  Enabled: false
+
+LineLength:
+  Max: 183
+
+MethodLength:
+  Max: 40
+
+Metrics/PerceivedComplexity:
+  Max: 8
+
+MultilineBlockChain:
+  Enabled: false
+
+NestedTernaryOperator:
+  Enabled: false
+
+Not:
+  Enabled: false
+
+NumericLiterals:
+  Enabled: false
+
+ParameterLists:
+  Enabled: false
+
+ParenthesesAroundCondition:
+  Enabled: false
+
+ParenthesesAsGroupedExpression:
+  Enabled: false
+
+RedundantBegin:
+  Enabled: false
+
+RedundantSelf:
+  Enabled: false
+
+RescueException:
+  Enabled: false
+
+RescueModifier:
+  Enabled: false
+
+Semicolon:
+  Enabled: false
+
+SignalException:
+  Enabled: false
+
+SingleLineBlockParams:
+  Enabled: false
+
+WordArray:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 James Edward Gray II and Brian Muller
+
+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.markdown

@@ -5,29 +5,30 @@ Gatling Gun is a library that helps you blast out a group of emails.  It's a
 simple wrapper over
 [SendGrid's Newsletter API](http://docs.sendgrid.com/documentation/api/newsletter-api/).
 
-Install
+Installation
 -------
 
-If you want to use this code in a Rails application, just add it to your
-Gemfile:
+Add this line to your application's Gemfile:
 
-    gem "gatling_gun"
-
-To use the code in a non-Rails application, first install the gem:
-
-    gem install gatling_gun
+```ruby
+gem "gatling_gun"
+```
 
 Then require the library in your code:
 
-    require "gatling_gun"
+```ruby
+require "gatling_gun"
+```
 
-Either way, you will want to setup Gatling Gun as your application loads.  I
+You will probably want to setup Gatling Gun as your application loads.  I
 recommend just setting a constant you can then refer to throughout your
 application.  In Rails, I would put the following code in
 `config/initializers/gatling_gun.rb`.  Setup is easy, just add you SendGrid
 credentials:
 
-    SendGrid = GatlingGun.new("USERNAME", "PASSWORD")
+```ruby
+SendGrid = GatlingGun.new("USERNAME", "PASSWORD")
+```
 
 Usage
 -----
@@ -35,37 +36,45 @@ Usage
 The minimal steps to create and send a newsletter would be something like the
 following.  First, you need an identity to send from:
 
-    SendGrid.add_identity( "test", name:    "Test User",
-                                   email:   "test@subinterest.com",
-                                   address: "513 Cinnamon Dr.",
-                                   city:    "Edmond",
-                                   state:   "OK",
-                                   zip:     "73003",
-                                   country: "USA" )
+```ruby
+SendGrid.add_identity( "test", name:    "Test User",
+		               email:   "test@subinterest.com",
+                               address: "513 Cinnamon Dr.",
+                               city:    "Edmond",
+                               state:   "OK",
+                               zip:     "73003",
+                               country: "USA" )
+```
 
 Then you can create a newsletter using that identity:
 
-    SendGrid.add_newsletter( "episode1", identity: "test",
-                                         subject:  "Episode 1",
-                                         text:     "The Text Body",
-                                         html:     "<h1>The HTML Body</h1>" )
+```ruby
+SendGrid.add_newsletter( "episode1", identity: "test",
+                                     subject:  "Episode 1",
+                                     text:     "The Text Body",
+                                     html:     "<h1>The HTML Body</h1>" )
+```
 
 Next you need to create a list of recipients, add some emails to it, and attach 
 that list to the newsletter:
 
-    SendGrid.add_list("subscribers")
-    SendGrid.add_emails( "subscribers", [ { name:  "James Edward Gray II",
-                                            email: "james@graysoftinc.com" },
-                                          { name:  "Admin",
-                                            email: "admin@graysoftinc.com" } ] )
-    SendGrid.add_recipients("episode1", "subscribers")
+```ruby
+SendGrid.add_list("subscribers")
+SendGrid.add_emails("subscribers", [ { name:  "James Edward Gray II",
+                                       email: "james@graysoftinc.com" },
+                                     { name:  "Admin",
+                                       email: "admin@graysoftinc.com" } ] )
+SendGrid.add_recipients("episode1", "subscribers")
+```
 
 Of course, you could reuse identities and recipient lists for future newsletter
 messages without needing to recreate them.
 
 Finally, you can schedule when to have the message sent:
 
-    SendGrid.add_schedule("episode1", at: Time.now + 10 * 60)
+```ruby
+SendGrid.add_schedule("episode1", at: Time.now + 10 * 60)
+```
 
 That would sent it 10 minutes from now, but you can adjust the time to whenever
 you desire or even leave it out to send now.

data/Rakefile

@@ -1,6 +1,14 @@
-require "rubygems/package_task"
+require 'bundler/gem_tasks'
+require 'rdoc/task'
+require 'rake/testtask'
 
-load(File.join(File.dirname(__FILE__), "gatling_gun.gemspec"))
-Gem::PackageTask.new(SPEC) do |package|
-  # do nothing:  I just need a gem but this block is required
+# need some tests!
+# task :default => [:test]
+
+desc 'Create documentation'
+Rake::RDocTask.new('doc') do |rdoc|
+  rdoc.title = "A Ruby library wrapping SendGrid's Newsletter API."
+  rdoc.rdoc_dir = 'docs'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/gatling_gun.gemspec

@@ -1,30 +1,18 @@
-DIR     = File.dirname(__FILE__)
-LIB     = File.join(DIR, *%w[lib gatling_gun.rb])
-VERSION = open(LIB) { |lib|
-  lib.each { |line|
-    if v = line[/^\s*VERSION\s*=\s*(['"])(\d\.\d\.\d)\1/, 2]
-      break v
-    end
-  }
-}
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'gatling_gun'
 
-SPEC = Gem::Specification.new do |s|
-  s.name        = "gatling_gun"
-  s.version     = VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["James Edward Gray II"]
-  s.email       = ["james@graysoftinc.com"]
-  s.homepage    = "https://github.com/okrb/gatling_gun"
+Gem::Specification.new do |s|
+  s.name        = 'gatling_gun'
+  s.version     = GatlingGun::VERSION
+  s.authors     = ['James Edward Gray II', 'Brian Muller']
+  s.email       = ['bamuller@gmail.com']
+  s.homepage    = 'https://github.com/bmuller/gatling_gun'
   s.summary     = "A Ruby library wrapping SendGrid's Newsletter API."
-  s.description = <<-END_DESCRIPTION.gsub(/\s+/, " ").strip
-  A library for working with SendGrid's Newsletter API.  The code is intended
-  for managing and sending newletters.
-  END_DESCRIPTION
-
-  s.required_ruby_version     = ">= 1.9.2"
-  s.required_rubygems_version = ">= 1.3.7"
+  s.description = "A Ruby library wrapping SendGrid's Newsletter API."
 
   s.files         = `git ls-files`.split("\n")
-  # s.test_files    = `git ls-files -- test/*.rb`.split("\n")
-  s.require_paths = %w[lib]
+  s.require_paths = ['lib']
+  s.add_development_dependency('rdoc')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rubocop')
 end

data/lib/gatling_gun.rb

@@ -1,195 +1,221 @@
-require "json"
-require "net/https"
-require "openssl"
-require "time"
-require "uri"
+require 'json'
+require 'net/https'
+require 'openssl'
+require 'time'
+require 'uri'
 
-require "gatling_gun/api_call"
-require "gatling_gun/response"
+require 'gatling_gun/api_call'
+require 'gatling_gun/response'
 
 class GatlingGun
-  VERSION = "0.0.3"
-  
+  VERSION = '0.0.4'
+
   def initialize(api_user, api_key)
     @api_user = api_user
     @api_key  = api_key
   end
-  
+
   ###################
   ### Newsletters ###
   ###################
-  
+
   def add_newsletter(newsletter, details)
-    fail ArgumentError, "details must be a Hash" unless details.is_a? Hash
-    %w[identity subject].each do |field|
-      unless details[field.to_sym] or details[field]
+    fail ArgumentError, 'details must be a Hash' unless details.is_a? Hash
+    %w(identity subject).each do |field|
+      unless details[field.to_sym] || details[field]
         fail ArgumentError, "#{field} is a required detail"
       end
     end
-    unless details[:text] or details["text"] or
-           details[:html] or details["html"]
-      fail ArgumentError, "either text or html must be provided as a detail"
+    unless details[:text] || details['text'] ||
+           details[:html] || details['html']
+      fail ArgumentError, 'either text or html must be provided as a detail'
     end
-    make_api_call("add", details.merge(name: newsletter))
+    make_api_call('add', details.merge(name: newsletter))
   end
 
   def edit_newsletter(newsletter, details)
-    fail ArgumentError, "details must be a Hash"  unless details.is_a? Hash
-    fail ArgumentError, "details cannot be empty" if     details.empty?
-    make_api_call("edit", details.merge(name: newsletter))
+    fail ArgumentError, 'details must be a Hash'  unless details.is_a? Hash
+    fail ArgumentError, 'details cannot be empty' if     details.empty?
+    make_api_call('edit', details.merge(name: newsletter))
   end
 
   def get_newsletter(newsletter)
-    make_api_call("get", name: newsletter)
+    make_api_call('get', name: newsletter)
   end
 
   def list_newsletters(newsletter = nil)
-    parameters        = { }
+    parameters        = {}
     parameters[:name] = newsletter if newsletter
-    make_api_call("list", parameters)
+    make_api_call('list', parameters)
   end
-  
+
   def delete_newsletter(newsletter)
-    make_api_call("delete", name: newsletter)
+    make_api_call('delete', name: newsletter)
   end
-  
+
   #############
   ### Lists ###
   #############
-  
-  def add_list(list, details = { })
-    fail ArgumentError, "details must be a Hash" unless details.is_a? Hash
-    make_api_call("lists/add", details.merge(list: list))
-  end
-  
-  def edit_list(list, details = { })
-    fail ArgumentError, "details must be a Hash"  unless details.is_a? Hash
-    fail ArgumentError, "details cannot be empty" if     details.empty?
-    make_api_call("lists/edit", details.merge(list: list))
-  end
-  
+
+  def add_list(list, details = {})
+    fail ArgumentError, 'details must be a Hash' unless details.is_a? Hash
+    make_api_call('lists/add', details.merge(list: list))
+  end
+
+  def edit_list(list, details = {})
+    fail ArgumentError, 'details must be a Hash'  unless details.is_a? Hash
+    fail ArgumentError, 'details cannot be empty' if     details.empty?
+    make_api_call('lists/edit', details.merge(list: list))
+  end
+
   def get_list(list = nil)
-    parameters        = { }
+    parameters        = {}
     parameters[:list] = list if list
-    make_api_call("lists/get", parameters)
+    make_api_call('lists/get', parameters)
   end
   alias_method :list_lists, :get_list
-  
+
   def delete_list(list)
-    make_api_call("lists/delete", list: list)
+    make_api_call('lists/delete', list: list)
   end
-  
+
   ##############
   ### Emails ###
   ##############
-  
+
   def add_email(list, data)
     json_data = case data
                 when Hash  then data.to_json
                 when Array then data.map(&:to_json)
                 else            fail ArgumentError,
-                                     "details must be a Hash or Array"
+                                     'details must be a Hash or Array'
                 end
-    make_api_call("lists/email/add", list: list, data: json_data)
+    make_api_call('lists/email/add', list: list, data: json_data)
   end
   alias_method :add_emails, :add_email
-  
+
   def get_email(list, emails = nil)
-    parameters         = {list: list}
+    parameters         = { list: list }
     parameters[:email] = emails if emails
-    make_api_call("lists/email/get", parameters)
+    make_api_call('lists/email/get', parameters)
   end
   alias_method :get_emails,  :get_email
   alias_method :list_emails, :get_email
-  
+
   def delete_email(list, emails)
-    make_api_call("lists/email/delete", list: list, email: emails)
+    make_api_call('lists/email/delete', list: list, email: emails)
   end
   alias_method :delete_emails, :delete_email
-  
+
   ################
   ### Identity ###
   ################
-  
+
   def add_identity(identity, details)
-    fail ArgumentError, "details must be a Hash" unless details.is_a? Hash
-    %w[name email address city state zip country].each do |field|
-      unless details[field.to_sym] or details[field]
+    fail ArgumentError, 'details must be a Hash' unless details.is_a? Hash
+    %w(name email address city state zip country).each do |field|
+      unless details[field.to_sym] || details[field]
         fail ArgumentError, "#{field} is a required detail"
       end
     end
-    make_api_call("identity/add", details.merge(identity: identity))
+    make_api_call('identity/add', details.merge(identity: identity))
   end
-  
+
   def edit_identity(identity, details)
-    fail ArgumentError, "details must be a Hash"  unless details.is_a? Hash
-    fail ArgumentError, "details cannot be empty" if     details.empty?
-    make_api_call("identity/edit", details.merge(identity: identity))
+    fail ArgumentError, 'details must be a Hash'  unless details.is_a? Hash
+    fail ArgumentError, 'details cannot be empty' if     details.empty?
+    make_api_call('identity/edit', details.merge(identity: identity))
   end
-  
+
   def get_identity(identity)
-    make_api_call("identity/get", identity: identity)
+    make_api_call('identity/get', identity: identity)
   end
-  
+
   def list_identities(identity = nil)
-    parameters            = { }
+    parameters            = {}
     parameters[:identity] = identity if identity
-    make_api_call("identity/list", parameters)
+    make_api_call('identity/list', parameters)
   end
-  
+
   def delete_identity(identity)
-    make_api_call("identity/delete", identity: identity)
+    make_api_call('identity/delete', identity: identity)
   end
-  
+
   ##################
   ### Recipients ###
   ##################
-  
+
   def add_recipient(newsletter, list)
-    make_api_call("recipients/add", name: newsletter, list: list)
+    make_api_call('recipients/add', name: newsletter, list: list)
   end
   alias_method :add_recipients, :add_recipient
 
   def get_recipient(newsletter)
-    make_api_call("recipients/get", name: newsletter)
+    make_api_call('recipients/get', name: newsletter)
   end
   alias_method :get_recipients,  :get_recipient
   alias_method :list_recipients, :get_recipient
-  
+
   def delete_recipient(newsletter, list)
-    make_api_call("recipients/delete", name: newsletter, list: list)
+    make_api_call('recipients/delete', name: newsletter, list: list)
   end
   alias_method :delete_recipients, :delete_recipient
-  
+
   #################
   ### Schedules ###
   #################
-  
-  def add_schedule(newsletter, details = { })
-    parameters      = {after: details[:after]}
-    parameters[:at] = details[:at].iso8601.sub("T", " ") \
+
+  def add_schedule(newsletter, details = {})
+    parameters      = { after: details[:after] }
+    parameters[:at] = details[:at].iso8601.sub('T', ' ') \
       if details[:at].respond_to? :iso8601
-    if not details[:after].nil? and ( not details[:after].is_a?(Integer) or 
-                                      details[:after] < 1 )
-      fail ArgumentError, "after must be a positive integer"
+    if !details[:after].nil? && ( !details[:after].is_a?(Integer) ||
+                                      details[:after] < 1)
+      fail ArgumentError, 'after must be a positive integer'
     end
-    make_api_call("schedule/add", parameters.merge(name: newsletter))
+    make_api_call('schedule/add', parameters.merge(name: newsletter))
   end
-  
+
   def get_schedule(newsletter)
-    make_api_call("schedule/get", name: newsletter)
+    make_api_call('schedule/get', name: newsletter)
   end
-  
+
   def delete_schedule(newsletter)
-    make_api_call("schedule/delete", name: newsletter)
+    make_api_call('schedule/delete', name: newsletter)
+  end
+
+  ##################
+  ### Categories ###
+  ##################
+
+  def create_category(category)
+    make_api_call('category/create', category: category)
   end
-  
+
+  def add_category(category, name)
+    make_api_call('category/add', category: category, name: name)
+  end
+
+  def remove_category(name, category = nil)
+    parameters = { name: name }
+    parameters[:category] = category if category
+    make_api_call('category/remove', parameters)
+  end
+
+  def list_categories(category = nil)
+    parameters = {}
+    parameters[:category] = category if category
+    make_api_call('category/list', parameters)
+  end
+
   #######
+
   private
+
   #######
-  
-  def make_api_call(action, parameters = { })
-    ApiCall.new( action, parameters.merge( api_user: @api_user,
-                                           api_key:  @api_key ) ).response
+
+  def make_api_call(action, parameters = {})
+    ApiCall.new(action, parameters.merge(api_user: @api_user,
+                                         api_key:  @api_key)).response
   end
 end