em-kannel 0.2.0

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    em-kannel (0.2.0)
+      activemodel (~> 3.1)
+      em-http-request (>= 1.0.0.beta.4)
+      eventmachine (>= 1.0.0.beta.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.3)
+      activesupport (= 3.1.3)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activesupport (3.1.3)
+      multi_json (~> 1.0)
+    addressable (2.2.6)
+    builder (3.0.0)
+    cookiejar (0.3.0)
+    crack (0.3.1)
+    diff-lcs (1.1.3)
+    em-http-request (1.0.1)
+      addressable (>= 2.2.3)
+      cookiejar
+      em-socksify
+      eventmachine (>= 1.0.0.beta.4)
+      http_parser.rb (>= 0.5.3)
+    em-socksify (0.1.0)
+      eventmachine
+    eventmachine (1.0.0.beta.4)
+    http_parser.rb (0.5.3)
+    i18n (0.6.0)
+    multi_json (1.0.4)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.0)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    webmock (1.7.7)
+      addressable (~> 2.2, > 2.2.5)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  em-kannel!
+  rspec (~> 2.7.0)
+  webmock (~> 1.7.7)

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT-License)
+
+Copyright (c) 2011 GroupMe
+
+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,62 @@
+# Kannel SMS delivery for EventMachine
+
+# Install
+
+      gem "em-kannel", :git => "git://github.com/groupme/em-kannel.git"
+
+# Usage
+
+      require "em-kannel"
+
+      kannel = EM::Kannel.new(
+        username: "user",
+        password: "password",
+        url:      "http://www.example.com/sendsms"
+      )
+
+
+      EM.run do
+        kannel.sendsms(
+          from: "+12105551010",
+          to: "+12125551212 +17185551212",
+          body: "Hello World"
+        )
+        EM.stop
+      end
+
+## Callbacks
+
+You can pass a block to process the response body:
+
+      kannel.sendsms(message_options) do |response|
+        if response.success?
+          log("Hooray!")
+        else
+          log("Boo! #{response.body}")
+        end
+      end
+
+# Testing
+
+To test em-kannel's deliveries, start by simply requiring this file after EM::Kannel has already
+been loaded:
+
+      require "em-kannel"
+      require "em-kannel/test_helper"
+
+This will nullify actual deliveries and instead, push them onto an accessible
+list:
+
+      kannel = EM::Kannel.new(configuration_options)
+
+      expect {
+       kannel.send_sms(message_options)
+      }.to change { EM::Kannel.deliveries.size }.by(1)
+
+      message = EM::Kannel.deliveries.first
+      message.should be_an_instance_of(EM::Kannel::Message)
+      message.body.should == ...
+
+# Legal
+
+See LICENSE for details

data/Rakefile

@@ -0,0 +1,5 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/em-kannel.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "em-kannel/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em-kannel"
+  s.version     = EventMachine::Kannel::VERSION
+  s.authors     = ["John Pignata"]
+  s.email       = ["john@groupme.com"]
+  s.homepage    = ""
+  s.summary     = %q{EventMachine-driven SMS delivery via Kannel}
+
+  s.rubyforge_project = "em-kannel"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "eventmachine", ">= 1.0.0.beta.3"
+  s.add_dependency "em-http-request", ">= 1.0.0.beta.4"
+  s.add_dependency "activemodel", "~> 3.1"
+
+  s.add_development_dependency "rspec", "~> 2.7.0"
+  s.add_development_dependency "webmock", "~> 1.7.7"
+end

data/lib/em-kannel.rb

@@ -0,0 +1,39 @@
+require "active_model"
+require "active_support/core_ext/hash"
+require "em-http-request"
+require "logger"
+
+require "em-kannel/validations"
+require "em-kannel/configuration"
+require "em-kannel/message"
+require "em-kannel/log_message"
+require "em-kannel/client"
+require "em-kannel/response"
+
+module EventMachine
+  class Kannel
+    attr_accessor :configuration
+
+    def initialize(configuration_options={})
+      self.configuration = Configuration.new(configuration_options)
+    end
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def self.logger=(new_logger)
+      @logger = new_logger
+    end
+
+    def send_sms(message_options, &block)
+      configuration.validate!
+
+      message = Message.new(message_options)
+      message.validate!
+
+      client = Client.new(message, configuration)
+      client.deliver(&block)
+    end
+  end
+end

data/lib/em-kannel/client.rb

@@ -0,0 +1,39 @@
+module EventMachine
+  class Kannel
+    class Client
+      attr_accessor :message, :configuration
+
+      def initialize(message, configuration)
+        self.message       = message
+        self.configuration = configuration
+      end
+
+      def deliver(&block)
+        start = Time.now.to_f
+        http  = EM::HttpRequest.new(configuration.url, options).get(query: query)
+
+        http.callback { callback(http, start, message, &block) }
+        http.errback { callback(http, start, message, &block) }
+      end
+
+      private
+
+      def options
+        { ssl: { verify_peer: configuration.verify_ssl_peer } }
+      end
+
+      def query
+        query = {}
+        query.merge!(configuration.as_query)
+        query.merge!(message.as_query)
+      end
+
+      def callback(http, start, message, &block)
+        response = Response.new(http, start)
+
+        LogMessage.new(message, response).log
+        block.call(response) if block_given?
+      end
+    end
+  end
+end

data/lib/em-kannel/configuration.rb

@@ -0,0 +1,39 @@
+module EventMachine
+  class Kannel
+    class Configuration
+      include Validations
+
+      attr_accessor :username,
+                    :password,
+                    :url,
+                    :dlr_callback_url,
+                    :dlr_mask,
+                    :verify_ssl_peer,
+                    :smsc
+
+      validates :username, presence: true
+      validates :password, presence: true
+      validates :url, presence: true
+
+      def initialize(attributes={})
+        attributes = attributes.with_indifferent_access
+
+        self.username         = attributes[:username]
+        self.password         = attributes[:password]
+        self.url              = attributes[:url]
+        self.dlr_callback_url = attributes[:dlr_callback_url]
+        self.dlr_mask         = attributes[:dlr_mask]
+        self.verify_ssl_peer  = attributes[:verify_ssl_peer]
+        self.smsc             = attributes[:smsc]
+      end
+
+      def as_query
+        query = { username: username, password: password }
+        query[:"dlr-mask"] = dlr_mask if dlr_mask
+        query[:"dlr-url"]  = dlr_callback_url if dlr_callback_url
+        query[:smsc]       = smsc if smsc
+        query
+      end
+    end
+  end
+end

data/lib/em-kannel/log_message.rb

@@ -0,0 +1,30 @@
+module EventMachine
+  class Kannel
+    class LogMessage
+      def initialize(message, response)
+        @message, @response = message, response
+      end
+
+      def log
+        EM::Kannel.logger.info(message)
+      end
+
+      private
+
+      def message
+        parts = [
+          "CODE=#{@response.status}",
+          "FROM=#{@message.from}",
+          "TO=#{@message.to}",
+          "BODY=#{@message.body[0..100]}",
+          "RESPONSE=#{@response.body}",
+          "TIME=#{@response.duration}"
+        ]
+        parts << "ERROR=#{@response.error}" unless @response.success?
+
+        parts.join(" ")
+      end
+    end
+  end
+end
+

data/lib/em-kannel/message.rb

@@ -0,0 +1,25 @@
+module EventMachine
+  class Kannel
+    class Message
+      include Validations
+
+      attr_accessor :body, :from, :to
+
+      validates :body, presence: true, length: { maximum: 160 }
+      validates :from, presence: true
+      validates :to, presence: true
+
+      def initialize(attributes={})
+        attributes = attributes.with_indifferent_access
+
+        self.from = attributes[:from]
+        self.to   = attributes[:to]
+        self.body = attributes[:body]
+      end
+
+      def as_query
+        { from: from, to: to, text: body }
+      end
+    end
+  end
+end

data/lib/em-kannel/response.rb

@@ -0,0 +1,38 @@
+module EventMachine
+  class Kannel
+    class Response
+      attr_reader :duration
+
+      def initialize(http, start=nil)
+        @http     = http
+        @duration = compute_duration(start)
+      end
+
+      def status
+        @http.response_header.status.to_i
+      end
+
+      def success?
+        status == 202
+      end
+
+      def body
+        @http.response
+      end
+
+      def error
+        @http.error
+      end
+
+      def guid
+        body.split(": ").last
+      end
+
+      private
+
+      def compute_duration(start)
+        start && ((Time.now.to_f - start.to_f) * 1000.0).round
+      end
+    end
+  end
+end

data/lib/em-kannel/test_helper.rb

@@ -0,0 +1,28 @@
+require "ostruct"
+
+module EventMachine
+  class Kannel
+    def self.deliveries
+      @deliveries ||= []
+    end
+
+    Client.class_eval do
+      def fake_response
+        guid = UUID.new.generate
+
+        status = OpenStruct.new(status: 202)
+        http   = OpenStruct.new(
+          response_header: status,
+          response: "0: Accepted for delivery: #{guid}"
+        )
+
+        Response.new(http, Time.now)
+      end
+
+      def deliver(&block)
+        EM::Kannel.deliveries << @message
+        yield(fake_response) if block_given?
+      end
+    end
+  end
+end

data/lib/em-kannel/validations.rb

@@ -0,0 +1,30 @@
+module EventMachine
+  class Kannel
+    module Validations
+      def self.included(base)
+        base.class_eval do
+          include ActiveModel::Validations
+        end
+      end
+
+      def validate!
+        if invalid?
+          message = "Invalid #{friendly_name}: #{full_messages}"
+          raise ArgumentError.new(message)
+        end
+
+        true
+      end
+
+      def friendly_name
+        self.class.model_name.human
+      end
+
+      private
+
+      def full_messages
+        errors.full_messages.to_sentence
+      end
+    end
+  end
+end

data/lib/em-kannel/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  class Kannel
+    VERSION = "0.2.0"
+  end
+end

data/spec/em-kannel/client_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe EventMachine::Kannel::Client do
+  describe "#deliver" do
+    let(:configuration) {
+      EM::Kannel::Configuration.new(
+        url: "http://www.example.com/api",
+        username: "user",
+        password: "pass"
+      )
+    }
+
+    let(:message) do
+      EM::Kannel::Message.new(
+        from: "+12125551212",
+        to:   "+17185551212",
+        body: "testing"
+      )
+    end
+
+    it "delivers the message to the specified URL" do
+      stub = stub_request(:get, "http://www.example.com/api").with(
+        query: {
+          username: "user",
+          password: "pass",
+          from:     "+12125551212",
+          to:       "+17185551212",
+          text:     "testing"
+        }
+      )
+
+      EM.run_block {
+        EM::Kannel::Client.new(message, configuration).deliver
+      }
+
+      stub.should have_been_requested
+    end
+
+    context "delivery succeeds" do
+      it "logs the delivery" do
+        uuid = "24b8d670-0ad6-012f-13e0-60c5470504ea"
+
+        stub = stub_request(:get, "http://www.example.com/api").with(
+          query: {
+            username: "user",
+            password: "pass",
+            from:     "+12125551212",
+            to:       "+17185551212",
+            text:     "testing"
+          }).
+          to_return(:status => 202, :body => uuid)
+
+        EM::Kannel.logger.should_receive(:info).with(
+          /CODE=202 FROM=\+12125551212 TO=\+17185551212 BODY=testing RESPONSE=#{uuid} TIME=[0-9]/
+        )
+
+        EM.run_block {
+          EM::Kannel::Client.new(message, configuration).deliver
+        }
+      end
+    end
+
+    context "delivery fails" do
+      it "logs the failure" do
+        stub = stub_request(:get, "http://www.example.com/api").with(
+          query: {
+            username: "user",
+            password: "pass",
+            from:     "+12125551212",
+            to:       "+17185551212",
+            text:     "testing"
+          }).
+          to_return(:status => 404, :body => "API not available")
+
+        EM::Kannel.logger.should_receive(:info).with(
+          /CODE=404 FROM=\+12125551212 TO=\+17185551212 BODY=testing RESPONSE=API not available TIME=[0-9]/
+        )
+
+        EM.run_block {
+          EM::Kannel::Client.new(message, configuration).deliver
+        }
+      end
+    end
+  end
+end

data/spec/em-kannel/configuration_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe EventMachine::Kannel::Configuration do
+  let(:attributes) do
+    {
+      :username             => "user",
+      :password             => "pass",
+      :url                  => "http://www.example.com/url",
+      :dlr_callback_url     => "http://www.example.com/dlr_callback_url",
+      :dlr_mask             => 1,
+      :smsc                 => "Provider"
+    }
+  end
+
+  describe ".new" do
+    it "sets the attributes passed in the argument hash" do
+      configuration = EM::Kannel::Configuration.new(attributes)
+
+      attributes.each do |attribute_name, attribute_value|
+        configuration.send(attribute_name).should == attribute_value
+      end
+    end
+  end
+
+  describe "validations" do
+    let(:configuration) do
+      EM::Kannel::Configuration.new(
+        :username => "user",
+        :password => "pass"
+      )
+    end
+
+    it "validates presence of username" do
+      configuration.username = nil
+      configuration.should_not be_valid
+      configuration.errors[:username].should include("can't be blank")
+    end
+
+    it "validates presence of password" do
+      configuration.password = nil
+      configuration.should_not be_valid
+      configuration.errors[:password].should include("can't be blank")
+    end
+  end
+
+  describe "#as_query" do
+    it "returns a hash for use in the HTTP request" do
+      configuration = EM::Kannel::Configuration.new(attributes)
+      configuration.as_query.should == {
+        :username   => "user",
+        :password   => "pass",
+        :"dlr-mask" => 1,
+        :"dlr-url"  => "http://www.example.com/dlr_callback_url",
+        :smsc       => "Provider"
+      }
+    end
+  end
+end

data/spec/em-kannel/message_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe EventMachine::Kannel::Message do
+  let(:message) {
+    EM::Kannel::Message.new.tap do |message|
+      message.body = "hi there"
+      message.from = "+12125551212"
+      message.to   = ["+17185551212"]
+    end
+  }
+
+  describe "validations" do
+    context "with valid attributes" do
+      it "is valid" do
+        message.should be_valid
+      end
+    end
+
+    it "validates presence of body" do
+      message.body = nil
+      message.should_not be_valid
+      message.errors[:body].should include("can't be blank")
+    end
+
+    it "validates body length is at most 160 characters" do
+      message.body = "x" * 161
+      message.should_not be_valid
+      message.errors[:body].should include("is too long (maximum is 160 characters)")
+    end
+
+    it "validates presence of from" do
+      message.from = nil
+      message.should_not be_valid
+      message.errors[:from].should include("can't be blank")
+    end
+
+    it "validates presence of to" do
+      message.to = nil
+      message.should_not be_valid
+      message.errors[:to].should include("can't be blank")
+    end
+  end
+
+  describe "#as_query" do
+    it "returns a hash for use in the HTTP request" do
+      message.as_query.should == {
+        from: "+12125551212",
+        to:   ["+17185551212"],
+        text: "hi there"
+      }
+    end
+  end
+end

data/spec/em-kannel/response_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe EM::Kannel::Response do
+  let(:header) { mock(:header, status: "202") }
+  let(:body) { "0: Accepted for delivery: 26ecfeea-6015-4025-bcae-0d0b71467d83" }
+  let(:http) { mock(:http_client, response_header: header, response: body) }
+
+  before do
+    now = Time.now
+    Time.stub(:now).and_return(now)
+  end
+
+  describe "#status" do
+    it "returns the status code" do
+      started = Time.now - 10
+      http = mock(:http_client, response_header: header)
+
+      response = EM::Kannel::Response.new(http, started)
+      response.status.should == 202
+    end
+  end
+
+  describe "#success?" do
+    context "the status code is 202" do
+      it "returns true" do
+        response = EM::Kannel::Response.new(http)
+        response.should be_success
+      end
+    end
+
+    context "other status codes" do
+      let(:header) { mock(:header, status: "500") }
+
+      it "returns false" do
+        response = EM::Kannel::Response.new(http)
+        response.should_not be_success
+      end
+    end
+  end
+
+  describe "#body" do
+    it "returns the body of the response" do
+      response = EM::Kannel::Response.new(http)
+      response.body.should == body
+    end
+  end
+
+  describe "#guid" do
+    it "returns the guid of the response" do
+      response = EM::Kannel::Response.new(http)
+      response.guid.should == "26ecfeea-6015-4025-bcae-0d0b71467d83"
+    end
+  end
+end

data/spec/em-kannel/validations_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe EM::Kannel::Validations do
+  before do
+    class Model
+      include EM::Kannel::Validations
+      attr_accessor :value
+      validates :value, presence: true
+    end
+  end
+
+  describe "#validate!" do
+    context "invalid" do
+      it "raises an ArgumentError" do
+        expect {
+          Model.new.validate!
+        }.to raise_exception(ArgumentError, /Invalid Model/)
+      end
+    end
+
+    context "valid" do
+      it "returns true" do
+        instance = Model.new
+        instance.value = "value"
+        instance.validate!.should be_true
+      end
+    end
+  end
+
+end

data/spec/em-kannel_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe EventMachine::Kannel do
+  describe ".send_sms" do
+    context "invalid configuration options" do
+      it "raises an ArgumentError with the validation errors" do
+        expect {
+          kannel = EM::Kannel.new({})
+          kannel.send_sms({})
+        }.to raise_exception(ArgumentError, /Invalid Configuration/)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "em-kannel"
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    EM::Kannel.logger = Logger.new("/dev/null")
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: em-kannel
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- John Pignata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.3
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.4
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+description: 
+email:
+- john@groupme.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- em-kannel.gemspec
+- lib/em-kannel.rb
+- lib/em-kannel/client.rb
+- lib/em-kannel/configuration.rb
+- lib/em-kannel/log_message.rb
+- lib/em-kannel/message.rb
+- lib/em-kannel/response.rb
+- lib/em-kannel/test_helper.rb
+- lib/em-kannel/validations.rb
+- lib/em-kannel/version.rb
+- spec/em-kannel/client_spec.rb
+- spec/em-kannel/configuration_spec.rb
+- spec/em-kannel/message_spec.rb
+- spec/em-kannel/response_spec.rb
+- spec/em-kannel/validations_spec.rb
+- spec/em-kannel_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: em-kannel
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: EventMachine-driven SMS delivery via Kannel
+test_files: []