bulksms 0.5.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+*.swo

data/CHANGELOG

@@ -0,0 +1,22 @@
+* 0.5.0
+Completely re-written.
+Simple API via Bulksms module.
+Support for configuration object.
+Railtie links for Rails > 3.X configurations.
+
+* 0.4
+Adding method send_multiple to bulksms.rb file 
+
+* 0.3
+Fixing a bug related to getting the host of bulksms service
+Added gem spec file to the library
+Packaging the library as a gem
+
+* 0.2
+Added CHANGELOG and a README file
+Added support for BulkSMS international sites
+
+* 0.1
+Added support for sending messages
+Added support checking account balance
+Included a small example command-line client

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in bulksms.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,88 @@
+= Introduction
+
+BulkSMS is a Ruby library that allows you to easily integrate SMS services into your Ruby or Ruby on Rails applications.
+
+It has support for all BulkSMS international sites, including the UK, USA, South Africa, Spain and Europe.
+
+To use the library, you will need an account from www.bulksms.com and some credits.
+
+= Configuration
+
+Simply set using the configuration object provided by the Bulksms module:
+
+  Bulksms.config do |config|
+    config.username = 'testuser'
+    config.password = 'zepass'
+    config.country = :uk
+  end
+
+If Rails is available, the library can be configured using the standard environment configs:
+
+  SomeRails::Application.configure do
+
+    # set config in one go
+    config.bulksms do |c|
+      c.username = 'testuser'
+      c.password = 'zepass'
+    end
+
+    # single config options
+    config.bulksms.country = :es
+
+  end
+
+= Examples
+
+Sending a quick message is very simple:
+
+  Bulksms.deliver(:message => 'Hello, I hope you like my message!', :recipient => '44799123456')
+
+== Multiple messages
+
+Provide an array of hashes and multiple messages will be sent via the same HTTP connection:
+
+  Bulksms.deliver([{:message => 'Test Message', :recipient => "44342134131"}, {:message => "Another Msg", :recipient => "4441234354254"}])
+
+== Additional message options
+
+If you prefer more control, the <tt>Service</tt> and <tt>Message</tt> objects are also available for direct usage:
+
+  s = Bulksms::Service.new
+  m = Bulksms::Message.new(:message => "Test Message", :recipient => "34901123123")
+  m.routing_group = 1
+  m.want_report = 1
+  s.deliver(m)
+
+
+==  Checking your account balance
+
+Use the main module to request the current user's balance:
+
+  Bulksms.credits
+
+A <tt>Bulksms::AccountError</tt> will be raised if there is a problem.
+
+= Limitations
+
+This library currently only implements a small portion of the API, allowing you to send messages and check your account balance. Further parts of the BulkSMS API may be implemented in the future such as the ability to receive messages and status reports and manage the address book provided by BulkSMS.
+
+= Testing
+
+Rspec from the console:
+
+  rspec spec
+
+Tests still need a bit more work to cover all cases.
+
+= Authors
+
+The Original work on "ruby-bulksms" was made by Luke Redpath (email:contact@lukeredpath.co.uk). Modifications were added by Basayel Said (email:eng.basayel.said@gmail.com).
+
+The latest version, "bulksms", with a simpler interface, rspec testing, and an easier configuration was written by Sam Lown (me@samlown.com).
+
+Modifications include:
+
+* simple helper module for direct access to classes
+* DRYer support libraries
+* Railtie support for configuration
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bulksms.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bulksms/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bulksms"
+  s.version     = Bulksms::VERSION
+  s.authors     = ["Sam Lown", "Basayel Said", "Shuntyard Technologies"]
+  s.email       = ["me@samlown.com"]
+  s.homepage    = "https://github.com/samlown/bulksms"
+  s.summary     = %q{Simple BulkSMS API}
+  s.description = %q{Send SMS text messages via the BulkSMS API.}
+
+  s.rubyforge_project = "bulksms"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakeweb"
+  # s.add_runtime_dependency "rest-client"
+end

data/examples/client.rb

@@ -0,0 +1,56 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'bulksms'
+
+puts "\nWelcome to the BulkSMS Sender!"
+puts "--------------------------------\n\n"
+
+print 'Please enter your account username: '
+username = gets.strip
+
+print 'Please enter your account password: '
+password = gets.strip
+
+print 'Please enter your account country: (international)'
+country = gets.strip
+country = country.to_s.empty? ? :international : country.to_sym
+
+puts "\nChecking...\n\n"
+
+# set the configuration details
+Bulksms.config do |c|
+  c.username = username
+  c.password = password
+  c.country = country
+end
+
+begin
+  credits = Bulksms.credits
+  puts "Welcome back #{username}. You have #{credits} credits remaining.\n\n"
+rescue Bulksms::AccountError => d
+  puts "Sorry, there was an error validating your account details."
+  puts "\n\t#{d}\n\n"
+  puts "Goodbye."
+  exit
+end
+
+print "Enter the mobile number of the person you want to send an SMS to: "
+recipient = gets.strip
+
+print "Now enter your message: "
+message = gets.strip
+
+puts "\nThank you. Processing...\n\n"
+
+response = Bulksms.send(:message => message, :recipient => recipient, :test_always_success => 1)
+
+if response.success?
+  puts "Your SMS was sent successfully.\n\n"
+  puts "You now have #{Bulksms.credits} credits remaining."
+  puts "Goodbye!"
+else
+  puts "Sorry, but your SMS was not sent this time. The service returned the error:"
+  puts "\n\t#{response.code}: #{response.description}\n\n"
+  puts "Please try again later. Goodbye."
+end
+

data/lib/bulksms.rb

@@ -0,0 +1,50 @@
+
+require "net/http"
+require "uri"
+require "bulksms/version"
+require "bulksms/configuration"
+require "bulksms/message"
+require "bulksms/account"
+require "bulksms/service"
+require "bulksms/response"
+
+if defined?(Rails)
+  require "bulksms/railtie"
+end
+
+module Bulksms
+  extend self
+
+  def config
+    @config ||= Configuration.new
+    yield @config if block_given?
+    @config
+  end
+
+  # Simple wrapper for sending SMS messages via BulkSMS API.
+  # The most simple message should be provided as a hash as follows:
+  #
+  #     {
+  #       :message => "Body of message to send",
+  #       :recipient => "+34644477123"
+  #     }
+  #
+  # An array of messages may also be provided to send multiple SMS
+  # in the same HTTP connection.
+  #
+  def deliver(*args)
+    msg  = args.shift
+    opts = args.shift || {}
+    service = Service.new(opts)
+    service.deliver(msg)
+  end
+
+  # Request the number of credits available in your account.
+  # Returns a single float if successful, or raises an AccountError exception.
+  def credits(*args)
+    opts = args.last || { }
+    account = Account.new(opts)
+    account.credits
+  end
+
+end

data/lib/bulksms/account.rb

@@ -0,0 +1,59 @@
+module Bulksms
+
+  class AccountError < Exception; end
+
+  class Account
+
+    attr_reader :username, :password, :host, :port
+
+    def initialize(opts = {})
+      opts ||= { }
+      @username = opts[:username] || Bulksms.config.username
+      @password = opts[:password] || Bulksms.config.password
+      @host     = opts[:host] || Bulksms.config.host
+      @port     = opts[:port] || Bulksms.config.port
+    end
+
+    def to_params
+      { 'username' => @username, 'password' => @password }
+    end
+
+    def credits
+      res = request Bulksms.config.credits_path
+      raise(AccountError, res.result, caller) if res.code != 0
+      res.result.to_f
+    end
+
+    def request(path, params = {})
+      response = nil
+      connection do |http|
+        if params.is_a?(Array)
+          response = params.map{|p| post(http, path, p)}
+        else
+          response = post(http, path, params)
+        end
+      end
+      response
+    end
+
+    protected
+
+    def post(http, path, params = {})
+      payload = params_to_query_string(to_params.merge(params))
+      response = http.post path, payload
+      Response.parse(response.body)
+    end
+
+    def connection
+      Net::HTTP.start(host, port) do |http|
+        yield http
+      end
+    end
+
+    def params_to_query_string(params)
+      URI.encode(params.collect{|x,y| "#{x}=#{y}"}.join('&'))
+    end
+
+  end
+
+end

data/lib/bulksms/configuration.rb

@@ -0,0 +1,43 @@
+module Bulksms
+
+  class Configuration
+
+    attr_accessor :username
+    attr_accessor :password
+    attr_accessor :country
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :message_path
+    attr_accessor :credits_path
+    attr_accessor :message_class
+
+    def initialize
+      # Prepare default options
+      self.country = :international
+      self.port = 5567
+      self.message_path = "/eapi/submission/send_sms/2/2.0"
+      self.credits_path = "/eapi/user/get_credits/1/1.1"
+      self.message_class = 2
+    end
+
+    # Overide the default host config so that a short name will be converted
+    # into a full hostname.
+    def host
+      return @host unless @host.to_s.empty?
+      case @country
+      when :uk
+        'www.bulksms.co.uk'
+      when :usa
+        'usa.bulksms.com'
+      when :safrica
+        'bulksms.2way.co.za'
+      when :spain
+        'bulksms.com.es'
+      else # :international
+        'bulksms.vsms.net'
+      end
+    end
+
+  end
+
+end

data/lib/bulksms/message.rb

@@ -0,0 +1,48 @@
+module Bulksms
+
+  # Encapsulates a message to be sent by the gateway
+  class Message
+
+    # The various attributes for a message as defined
+    # by the BulkSMS HTTP API. For full details on the
+    # different attributes see:
+    #  http://www.bulksms.co.uk/docs/eapi/submission/send_sms/
+    attr_accessor :message, :recipient, :msg_class,
+                  :want_report, :routing_group, :source_id,
+                  :test_always_succeed, :test_always_fail,
+                  :concat_text_sms, :concat_max_parts
+
+    def initialize(opts = {})
+      @message = opts[:message]
+      @recipient = opts[:recipient]
+      @msg_class = Bulksms.config.message_class
+      @want_report = 0
+      @routing_group = 2
+      @source_id = ''
+      @test_always_succeed = opts[:test_always_succeed] || 0
+      @test_always_fail = opts[:test_always_fail] || 0
+      @concat_text_sms = 0
+      @concat_max_parts = 2
+    end
+
+    # Returns a message as a http query string for use
+    # by other gateway services
+    def to_params
+      raise "Missing message!" if @message.to_s.empty?
+      raise "Missing recipient!" if @recipient.to_s.empty?
+      {
+        'message' => @message,
+        'msisdn' => @recipient,
+        'msg_class' => @msg_class,
+        'want_report' => @want_report,
+        'routing_group' => @routing_group,
+        'source_id' => @source_id,
+        'test_always_succeed' => @test_always_succeed,
+        'test_always_fail' => @test_always_fail,
+        'allow_concat_text_sms' => @concat_text_sms,
+        'concat_text_sms_max_parts' => @concat_max_parts
+      }
+    end
+  end
+
+end

data/lib/bulksms/railtie.rb

@@ -0,0 +1,11 @@
+module Bulksms
+
+  class Railtie < ::Rails::Railtie
+
+    config.before_configuration do
+      config.bulksms = Bulksms.config
+    end
+
+  end
+
+end

data/lib/bulksms/response.rb

@@ -0,0 +1,22 @@
+module Bulksms
+  class Response
+
+    attr_reader :code, :result, :batch_id
+
+    def initialize(code, result, batch_id)
+      @code      = code
+      @result    = result
+      @batch_id  = batch_id
+    end
+
+    def success?
+      @code == 0
+    end
+
+    def self.parse(response_text)
+      tokens = response_text.split('|')
+      new tokens[0].to_i, tokens[1], tokens[2].to_i
+    end
+
+  end
+end

data/lib/bulksms/service.rb

@@ -0,0 +1,33 @@
+module Bulksms
+
+  class Service
+
+    attr_accessor :account
+
+    def initialize(opts = {})
+      @account = Account.new(opts)
+    end
+
+    # Send a single message or multiple messages.
+    def deliver(*args)
+      msg = args.shift
+      opts = args.shift || {}
+      case msg
+      when Hash
+        msg = Message.new(msg)
+      when Array
+        msg = msg.map{|m| m.is_a?(Message) ? m : Message.new(m)}
+      end
+      send_request(msg)
+    end
+
+    protected
+
+    def send_request(msg)
+      params = msg.is_a?(Array) ? msg.map{|m| m.to_params} : msg.to_params
+      @account.request Bulksms.config.message_path, params
+    end
+
+  end
+
+end

data/lib/bulksms/version.rb

@@ -0,0 +1,3 @@
+module Bulksms
+  VERSION = "0.5.0"
+end

data/spec/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/spec/account_spec.rb

@@ -0,0 +1,86 @@
+
+require 'spec_helper'
+
+describe Bulksms::Account do
+
+  before :all do
+    Bulksms.config.username = "fooobar"
+    Bulksms.config.password = "passs"
+  end
+
+  describe "initialisation" do
+
+    it "should set initial values" do
+      @account = Bulksms::Account.new
+      @account.username.should eql("fooobar")
+      @account.password.should eql("passs")
+    end
+
+    it "should allow override of attirbutes" do
+      @account = Bulksms::Account.new(:username => 'bardom', :password => "fooooed")
+      @account.username.should eql('bardom')
+      @account.password.should eql('fooooed')
+    end
+
+  end
+
+  describe "methods" do
+
+    before :each do
+      @account = Bulksms::Account.new
+    end
+
+    describe "#to_params" do
+      it "should return hash of username and password" do
+        @account.to_params.should eql('username' => 'fooobar', 'password' => 'passs')
+      end
+    end
+
+    describe "#credits" do
+
+      before :all do
+        @conf = Bulksms.config
+      end
+
+      it "returns credits on success" do
+        FakeWeb.register_uri(:post, "http://#{@conf.host}:#{@conf.port}#{@conf.credits_path}", :body => "0|302.3")
+        @account.credits.should eql(302.3)
+      end
+
+      it "raises an error when request fails" do
+        FakeWeb.register_uri(:post, "http://#{@conf.host}:#{@conf.port}#{@conf.credits_path}", :body => "23|Authentication failed")
+        expect { @account.credits }.to raise_error Bulksms::AccountError, /Authentication/
+      end
+
+    end
+
+    describe "#request" do
+      # TODO: fix: These tests are slightly flawed as they do not test the parameters.
+
+      before :all do
+        @conf = Bulksms.config
+      end
+
+      it "will send single request to server" do
+        FakeWeb.register_uri(:post, "http://#{@conf.host}:#{@conf.port}/test", {:body => "0|OK|1234"})
+        @account.request("/test", {:foo => :bar}).success?.should be_true
+      end
+
+      it "will send bad single request to server" do
+        FakeWeb.register_uri(:post, "http://#{@conf.host}:#{@conf.port}/test", {:body => "22|Internal fatal error|1234"})
+        @account.request("/test", {:foo => :bar}).success?.should be_false
+      end
+
+      it "will send multiple requests to server" do
+        FakeWeb.register_uri(:post, "http://#{@conf.host}:#{@conf.port}/test", [{:body => "0|OK|1234"}, {:body => "0|OK|1234"}])
+        res = @account.request("/test", [{:foo => :bar}, {:foo => :bar}])
+        res.should be_a(Array)
+        res[0].success?.should be_true
+        res[1].success?.should be_true
+      end
+
+    end
+
+  end
+
+end

data/spec/bulksms_spec.rb

@@ -0,0 +1,74 @@
+
+require 'spec_helper'
+
+describe Bulksms do
+
+  it "should exist" do
+    Bulksms.should be_a(Module)
+  end
+
+  describe "#config" do
+
+    it "should be provided" do
+      Bulksms.config.should be_a(Bulksms::Configuration)
+    end
+
+    it "should accept a block to set config options" do
+      Bulksms.config.username = ""
+      Bulksms.config do |c|
+        c.username = "foobar"
+      end
+      Bulksms.config.username.should eql('foobar')
+    end
+
+  end
+
+  describe "#deliver" do
+
+    it "should exist" do
+      Bulksms.should respond_to(:deliver)
+    end
+
+    it "should send a message" do
+      service = mock(:Service)
+      service.should_receive(:deliver)
+      Bulksms::Service.should_receive(:new).with({}).and_return(service)
+      Bulksms.deliver(:message => "Test", :recipient => "123456")
+    end
+
+    it "should send a message with opts" do
+      opts = {:opts => 'bar'}
+      service = mock(:Service)
+      service.should_receive(:deliver)
+      Bulksms::Service.should_receive(:new).with(opts).and_return(service)
+      Bulksms.deliver({:message => "Test", :recipient => "123456"}, opts)
+    end
+
+
+  end
+
+  describe "#credits" do
+
+    it "should exist" do 
+      Bulksms.should respond_to(:credits)
+    end
+
+    it "should request credits" do
+      account = mock(:Account)
+      account.should_receive(:credits)
+      Bulksms::Account.should_receive(:new).with({}).and_return(account)
+      Bulksms.credits
+    end
+
+    it "should pass options to account" do
+      opts = {:opts => 'bar'}
+      account = mock(:Account)
+      account.should_receive(:credits)
+      Bulksms::Account.should_receive(:new).with(opts).and_return(account)
+      Bulksms.credits(opts)
+    end
+
+
+  end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Bulksms::Configuration do
+
+  before :each do
+    @config = Bulksms::Configuration.new
+  end
+
+  describe "accessors" do
+    it "should be provided" do
+      [:username, :password, :country, :host, :port, :message_path,
+        :credits_path, :message_class].each do |accessor|
+        @config.should respond_to accessor
+      end
+    end
+  end
+
+  describe "initialize" do
+
+    it "should set defaults" do
+      @config.country.should eql(:international)
+      @config.port.should eql(5567)
+      @config.message_path.should_not be_empty
+      @config.credits_path.should_not be_empty
+      @config.message_class.should eql(2)
+    end
+
+  end
+
+  describe "#host" do
+
+    it "should provide international host by default" do
+      @config.host.should eql('bulksms.vsms.net')
+    end
+
+    it "should provide hostname from country if blank" do
+      @config.country = :uk
+      @config.host.should eql('www.bulksms.co.uk')
+    end
+
+    it "should provide host name if set" do
+      @config.host = "some.host"
+      @config.host.should eql("some.host")
+    end
+
+  end
+
+end
+

data/spec/message_spec.rb

@@ -0,0 +1,41 @@
+
+require 'spec_helper'
+
+describe Bulksms::Message do
+
+  describe "initialize" do
+
+    it "should instantiate" do
+      Bulksms::Message.new.should be_a(Bulksms::Message)
+    end
+
+    it "should accept message payload details" do
+      @msg = Bulksms::Message.new :message => "foo", :recipient => "1234"
+      @msg.message.should eql("foo")
+      @msg.recipient.should eql("1234")
+    end
+
+  end
+
+
+  describe "#to_params" do
+
+    it "should return a hash of parameters" do
+      @msg = Bulksms::Message.new :message => "foo", :recipient => "1234"
+      @msg.to_params['message'].should eql('foo')
+      @msg.to_params['msisdn'].should eql('1234')
+    end
+
+    it "should raise an error if recipient is missing" do
+      @msg = Bulksms::Message.new :message => "foo"
+      expect { @msg.to_params }.to raise_error /recipient/
+    end
+
+    it "should raise an error if message is missing" do
+      @msg = Bulksms::Message.new :recipient => "1234"
+      expect { @msg.to_params }.to raise_error /message/
+    end
+
+  end
+
+end

data/spec/service_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Bulksms::Service do
+
+  describe "initialization" do
+
+    it "instantiates account with options" do
+      opts = {:random => 'stuff'}
+      Bulksms::Account.should_receive(:new).once.with(opts)
+      Bulksms::Service.new(opts)
+    end
+
+  end
+
+  describe "#deliver" do
+
+    before :each do
+      @service = Bulksms::Service.new
+      @service.stub!(:send_request)
+    end
+
+    it "should convert hash into message" do
+      msg = {:message => "Foooo", :recipient => "1232131"}
+      Bulksms::Message.should_receive(:new).once.with(msg)
+      @service.deliver(msg)
+    end
+
+    it "should convert hash array into message array" do
+      msgs = [{:message => "Foooo", :recipient => "1232131"}, {:message => "Foooo", :recipient => "1232131"}]
+      Bulksms::Message.should_receive(:new).once.with(msgs[0])
+      Bulksms::Message.should_receive(:new).once.with(msgs[1])
+      @service.deliver(msgs)
+    end
+
+    it "should not do anything to a real Message" do
+      msg = Bulksms::Message.new(:message => "foobar", :recipient => "123344544")
+      @service.should_receive(:send_request).with(msg)
+      @service.deliver(msg)
+    end
+
+  end
+
+  describe "#send_request" do
+
+    before :each do
+      @service = Bulksms::Service.new
+    end
+
+    it "should convert messages to params" do
+      msg = Bulksms::Message.new(:message => 'test', :recipient => '1234')
+      @service.account = mock(:Account)
+      @service.account.should_receive(:request).with(Bulksms.config.message_path, msg.to_params)
+      @service.send(:send_request, msg)
+    end
+
+  end
+
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'fakeweb'
+require 'bulksms'
+
+RSpec.configure do |config|
+  # some (optional) config here
+  # end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: bulksms
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Sam Lown
+- Basayel Said
+- Shuntyard Technologies
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &21179040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21179040
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: &21178380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21178380
+description: Send SMS text messages via the BulkSMS API.
+email:
+- me@samlown.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- README.rdoc
+- Rakefile
+- bulksms.gemspec
+- examples/client.rb
+- lib/bulksms.rb
+- lib/bulksms/account.rb
+- lib/bulksms/configuration.rb
+- lib/bulksms/message.rb
+- lib/bulksms/railtie.rb
+- lib/bulksms/response.rb
+- lib/bulksms/service.rb
+- lib/bulksms/version.rb
+- spec/.rspec
+- spec/account_spec.rb
+- spec/bulksms_spec.rb
+- spec/configuration_spec.rb
+- spec/message_spec.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/samlown/bulksms
+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: bulksms
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simple BulkSMS API
+test_files: []